springboot——RabbitMQ的使用

RabbitMQ 介绍

RabbitMQ 是实现 AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在							分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。 RabbitMQ 主要是为了实现系统之间的双向解耦而实现的。当生产者大量产生数据时，消费者无法快速消费，那么需要一个中间层。保存这个数据。

AMQP，即 Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。AMQP 的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。

RabbitMQ 是一个开源的 AMQP 实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP 等，支持 AJAX。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。

相关概念

通常我们谈到队列服务, 会有三个概念： 发消息者、队列、收消息者，RabbitMQ 在这个基本概念之上, 多做了一层抽象, 在发消息者和 队列之间, 加入了交换器 (Exchange). 这样发消息者和队列就没有直接联系, 转而变成发消息者把消息给交换器, 交换器根据调度策略再把消息再给队列。

左侧 P 代表 生产者，也就是往 RabbitMQ 发消息的程序。
中间即是 RabbitMQ，其中包括了 交换机 和 队列。
右侧 C 代表 消费者，也就是往 RabbitMQ 拿消息的程序。
那么，其中比较重要的概念有 4 个，分别为：虚拟主机，交换机，队列，和绑定。

虚拟主机：

一个虚拟主机持有一组交换机、队列和绑定。为什么需要多个虚拟主机呢？很简单， RabbitMQ 当中，用户只能在虚拟主机的粒度进行权限控制。 因此，如果需要禁止A组访问B组的交换机/队列/绑定，必须为A和B分别创建一个虚拟主机。每一个 RabbitMQ 服务器都有一个默认的虚拟主机“/”。
交换机：Exchange 用于转发消息，但是它不会做存储 ，如果没有 Queue bind 到 Exchange 的话，它会直接丢弃掉 Producer 发送过来的消息。
这里有一个比较重要的概念：路由键 。消息到交换机的时候，交互机会转发到对应的队列中，那么究竟转发到哪个队列，就要根据该路由键。
绑定：也就是交换机需要和队列相绑定，这其中如上图所示，是多对多的关系。

交换机(Exchange)

交换机的功能主要是接收消息并且转发到绑定的队列，交换机不存储消息，在启用ack模式后，交换机找不到队列会返回错误。交换机有四种类型：Direct, topic, Headers and Fanout
Direct：direct 类型的行为是"先匹配, 再投送". 即在绑定时设定一个 routing_key, 消息的routing_key 匹配时, 才会被交换器投送到绑定的队列中去.
Topic：按规则转发消息（最灵活）
Headers：设置 header attribute 参数类型的交换机
Fanout：转发消息到所有绑定队列

Direct Exchange 交换机

Direct Exchange 是 RabbitMQ 默认的交换机模式，也是最简单的模式，根据key全文匹配去寻找队列。

第一个 X - Q1 就有一个 binding key，名字为 orange； X - Q2 就有 2 个 binding key，名字为 black 和 green。当消息中的 路由键 和 这个 binding key 对应上的时候，那么就知道了该消息去到哪一个队列中。

Topic Exchange 交换机

Topic Exchange 转发消息主要是根据通配符。 在这种交换机下，队列和交换机的绑定会定义一种路由模式，那么，通配符就要在这种路由模式和路由键之间匹配后交换机才能转发消息。

在这种交换机模式下：
路由键必须是一串字符，用句号（.） 隔开，比如说 agreements.us，或者 agreements.eu.stockholm 等。
路由模式必须包含一个 星号（），主要用于匹配路由键指定位置的一个单词，比如说，一个路由模式是这样子：agreements…b.，那么就只能匹配路由键是这样子的：第一个单词是 agreements，第四个单词是 b。 井号（#）就表示相当于一个或者多个单词，例如一个匹配模式是 agreements.eu.berlin.#，那么，以agreements.eu.berlin 开头的路由键都是可以的。
具体代码发送的时候还是一样，第一个参数表示交换机，第二个参数表示 routing key，第三个参数即消息。如下：

rabbitTemplate.convertAndSend(“testTopicExchange”,“key1.a.c.key2”, " this is RabbitMQ!");
topic 和 direct 类似, 只是匹配上支持了"模式", 在"点分"的 routing_key 形式中, 可以使用两个通配符:

*表示一个词.
#表示零个或多个词.
Headers Exchange

headers 交换机

也是根据规则匹配, 相较于 direct 和 topic 固定地使用 routing_key , headers 则是一个自定义匹配规则的类型.
在队列与交换器绑定时, 会设定一组键值对规则, 消息中也包括一组键值对( headers 属性), 当这些键值对有一对, 或全部匹配时, 消息被投送到对应队列.

Fanout Exchange 交换机

Fanout Exchange 消息广播的模式，不管路由键或者是路由模式，会把消息发给绑定给它的全部队列，如果配置了 routing_key 会被忽略。

springboot 集成RabbitMQ

一、引入pom 文件依赖

<dependency>
	<groupId>org.springframework.bootgroupId>
	<artifactId>spring-boot-starter-amqpartifactId>
dependency>

二、配置 RabbitMQ 的安装地址、端口以及账户信息

spring:
  rabbitmq: 
    host: 123.56.59.39 //连接地址
    username: guest //默认的用户名
    password: guest //默认的密码

三、代码示例及说明

//点对点分发器
rabbitAdmin.declareExchange(new DirectExchange("direct.exchange"));
//广播 订阅
rabbitAdmin.declareExchange(new FanoutExchange("fanout.exchange"));
//规则匹配 可用 * 和 # 通配符
rabbitAdmin.declareExchange(new TopicExchange("topic.exchange"));

rabbitAdmin.declareQueue(new Queue("queue.sun"));

rabbitAdmin.declareQueue(new Queue("queue.test"));

rabbitAdmin.declareQueue(new Queue("sun.test"));

		//rabbitAdmin.declareBinding(new Binding("queue.sun", Binding.DestinationType.QUEUE,"direct.exchange","queue.sun",null));

		//rabbitAdmin.declareBinding(new Binding("queue.test", Binding.DestinationType.QUEUE,"fanout.exchange","",null));

		//rabbitAdmin.declareBinding(new Binding("queue.test", Binding.DestinationType.QUEUE,"topic.exchange","#.test",null));
		//rabbitAdmin.declareBinding(new Binding("sun.test", Binding.DestinationType.QUEUE,"topic.exchange","sun.#",null));

		//rabbitTemplate.convertAndSend("direct.exchange","queue.sun","点对点哦");

		//rabbitTemplate.convertAndSend("fanout.exchange","queue.test","订阅哦");

		rabbitTemplate.convertAndSend("topic.exchange","queue.test","#规则哦");
		rabbitTemplate.convertAndSend("topic.exchange","sun.test","规则哦#");

四、源码解析参数含义

交换器 EXCHANGE

//该类是创建DirectExchange交换器的 可适用fanout 和topic交换器
public class DirectExchange extends AbstractExchange {
     
    public static final DirectExchange DEFAULT = new DirectExchange("");

	//默认创建可以只给一个交换器的名字
    public DirectExchange(String name) {
     
        super(name);
    }

	//name：名字、durable：是否持久化、autoDelete：是否自动删除（在存入第一个值后如果被消费了，就会自动删除）
	
    public DirectExchange(String name, boolean durable, boolean autoDelete) {
     
        super(name, durable, autoDelete);
    }
	//arguments:头信息 自行百度
    public DirectExchange(String name, boolean durable, boolean autoDelete, Map<String, Object> arguments) {
     
        super(name, durable, autoDelete, arguments);
    }

    public final String getType() {
     
        return "direct";
    }
}

队列 QUEUE

public class Queue extends AbstractDeclarable implements Cloneable {
     
    public static final String X_QUEUE_MASTER_LOCATOR = "x-queue-master-locator";
    private final String name;
    private final boolean durable;
    private final boolean exclusive;
    private final boolean autoDelete;
    private volatile String actualName;

	//默认只写一个那么就可以创建
    public Queue(String name) {
     
        this(name, true, false, false);
    }

	// name:名字、durable:是否持久化
    public Queue(String name, boolean durable) {
     
        this(name, durable, false, false, (Map)null);
    }
	//exclusive:是否独有（独有代表其他的只能是当前关联的交换器可以使用，其他的交换器匹配规则无法使用）、autoDelete：是否自动删除-在被消费后是否自动删除
    public Queue(String name, boolean durable, boolean exclusive, boolean autoDelete) {
     
        this(name, durable, exclusive, autoDelete, (Map)null);
    }
	//arguments:头信息 自行百度
    public Queue(String name, boolean durable, boolean exclusive, boolean autoDelete, @Nullable Map<String, Object> arguments) {
     
        super(arguments);
        Assert.notNull(name, "'name' cannot be null");
        this.name = name;
        this.actualName = StringUtils.hasText(name) ? name : Base64UrlNamingStrategy.DEFAULT.generateName() + "_awaiting_declaration";
        this.durable = durable;
        this.exclusive = exclusive;
        this.autoDelete = autoDelete;
    }

    public String getName() {
     
        return this.name;
    }

    public boolean isDurable() {
     
        return this.durable;
    }

    public boolean isExclusive() {
     
        return this.exclusive;
    }

    public boolean isAutoDelete() {
     
        return this.autoDelete;
    }

    public void setActualName(String name) {
     
        this.actualName = name;
    }

    public String getActualName() {
     
        return this.actualName;
    }

    public final void setMasterLocator(@Nullable String locator) {
     
        if (locator == null) {
     
            this.removeArgument("x-queue-master-locator");
        } else {
     
            this.addArgument("x-queue-master-locator", locator);
        }

    }

    public Object clone() {
     
        Queue queue = new Queue(this.name, this.durable, this.exclusive, this.autoDelete, new HashMap(this.getArguments()));
        queue.setActualName(this.actualName);
        return queue;
    }

    public String toString() {
     
        return "Queue [name=" + this.name + ", durable=" + this.durable + ", autoDelete=" + this.autoDelete + ", exclusive=" + this.exclusive + ", arguments=" + this.getArguments() + ", actualName=" + this.actualName + "]";
    }
}

绑定器 Binding 绑定交换器和队列的

public class Binding extends AbstractDeclarable {
     
    private final String destination;
    private final String exchange;
    private final String routingKey;
    private final Binding.DestinationType destinationType;

	//destination：目的地（那个队列）、DestinationType在下方、exchange：交换器、routingKey：路由键（匹配规则到那个对应的队列上）、arguments：头信息自行百度
    public Binding(String destination, Binding.DestinationType destinationType, String exchange, String routingKey, @Nullable Map<String, Object> arguments) {
     
        super(arguments);
        this.destination = destination;
        this.destinationType = destinationType;
        this.exchange = exchange;
        this.routingKey = routingKey;
    }

    public String getDestination() {
     
        return this.destination;
    }

    public Binding.DestinationType getDestinationType() {
     
        return this.destinationType;
    }

    public String getExchange() {
     
        return this.exchange;
    }

    public String getRoutingKey() {
     
        return this.routingKey;
    }

    public boolean isDestinationQueue() {
     
        return Binding.DestinationType.QUEUE.equals(this.destinationType);
    }

    public String toString() {
     
        return "Binding [destination=" + this.destination + ", exchange=" + this.exchange + ", routingKey=" + this.routingKey + ", arguments=" + this.getArguments() + "]";
    }

	//在这里
    public static enum DestinationType {
     
        QUEUE,
        EXCHANGE;

        private DestinationType() {
     
        }
    }
}

五、@RabbitListener 监听注解

//调用@RabbitListener 监听注解 必须在启动类上加@EnableRabbit 开启基于注解的rabbitmq

	@RabbitListener(queues="队列name")
	public void add(book book){
     
		//接收的内容会存到方法的参数里
	}

更改存储的对象默认的序列化

需要手动创建一个配置类 自行百度