初识RabbitMQ
一、消息队列
1、消息队列的介绍
在介绍RabbitMQ之前，首先来介绍下消息队列。消息队列是生产者-消费者模型的一个典型的代表，由一端往消息队列中不断的写入消息，而另一端则可以读取或者订阅队列中的消息。当新的消息入队时，就会通知接收方进行处理，消息的发送方称为生产者，消息的接收方称为消费者。那么，当我们发起HTTP请求的时候，就可以将请求丢到消息队列中，由消费者取出。这种加入“中间商”的方式，很好的实现了解耦，并且在高并发的情况下，由于消费者能力有限，消息队列也可以扮演“削峰填谷”的作用，先堆积一部分的请求，然后由消费者进行慢处理，避免大量请求导致接口崩溃的情况。常见的消息队列有以下几种：
- RabbitMQ：性能很强、吞吐量很高，且支持多种协议、集群化，适合于企业级开发
- Kafka：提供了超高的吞吐量，ms级别的延迟，具有极高的可用性以及可靠性，且分布式可以任意扩展
- RocketMQ：阿里巴巴推出的消息队列，单机吞吐量高、消息的高可靠性，扩展性很强，支持事务
2、消息队列的作用
(1)解耦
假设有系统B、C、D都需要系统A的数据，于是系统A调用三个方法发送数据到B、C、D。这时，系统D不需要了，那就需要在系统A把相关的代码删掉。假设这时有个新的系统E需要数据，这时系统A又要增加调用系统E的代码。为了降低这种强耦合，就可以使用MQ，系统A只需要把数据发送到MQ，其他系统如果需要数据，则从MQ中获取即可。
(2)异步
一个客户端请求发送进来，系统A会调用系统B、C、D三个系统，同步请求的话，响应时间就是系统A、B、C、D的总和，也就是800ms。如果使用MQ，系统A发送数据到MQ，然后就可以返回响应给客户端，不需要再等待系统B、C、D的响应，可以大大地提高性能。对于一些非必要的业务，比如发送短信，发送邮件等等，就可以采用MQ。
(3)削峰填谷
假设系统A在某一段时间请求数暴增，有5000个请求发送过来，系统A这时就会发送5000条SQL进入MySQL进行执行，MySQL对于如此庞大的请求当然处理不过来，MySQL就会崩溃，导致系统瘫痪。如果使用MQ，系统A不再是直接发送SQL到数据库，而是把数据发送到MQ，MQ短时间积压数据是可以接受的，然后由消费者每次拉取2000条进行处理，防止在请求峰值时期大量的请求直接发送到MySQL导致系统崩溃。
此处参考博客：https://blog.csdn.net/Rok728/article/details/123106242
二、RabbitMQ介绍
1、RabbitMQ
(1)RabbitMQ的设计架构
RabbitMQ是一款使用Erlang语言开发的，实现AMQP(高级消息队列协议)的开源消息中间件，其架构如下：
可以看到：
- 生产者：消息的发送方
- 消费者：消息的接收方
- Channel：每个客户端连接都会使用一个Channel，再通过Channel去访问到RabbitMQ服务器，这里的通信协议不是HTTP，而是amqp协议
- Exchange：类似于交换机，会根据我们的请求转发给相应的消息队列，每个队列都可以绑定到Exchange上，这样Exchange就可以将数据转发给队列了。Exchange可以存在很多个，不同的Exchange类型可以用于实现不同的消息的模式。
- Queue：消息队列本体，生产者的所有消息都在消息队列中，由消费者取出
- Virtual Host：类似于环境隔离。不同环境可以单独配置一个Virtual Host，每个Virtual Host可以包含很多个Exchange和Queue，每个Virtual Host之间互不影响
(2)RabbitMQ的特点
- 可靠性。支持持久化，传输确认，发布确认等保证了MQ的可靠性。
- 灵活的分发消息策略。这应该是RabbitMQ的一大特点。在消息进入MQ前由Exchange(交换机)进行路由消息。分发消息策略有：简单模式、工作队列模式、发布订阅模式、路由模式、通配符模式。
- 支持集群。多台RabbitMQ服务器可以组成一个集群，形成一个逻辑Broker。
- 多种协议。RabbitMQ支持多种消息队列协议，比如 STOMP、MQTT 等等。
- 支持多种语言客户端。RabbitMQ几乎支持所有常用编程语言，包括 Java、.NET、Ruby 等等。
- 可视化管理界面。RabbitMQ提供了一个易用的用户界面，使得用户可以监控和管理消息 Broker。
- 插件机制。RabbitMQ提供了许多插件，可以通过插件进行扩展，也可以编写自己的插件。
2、RabbitMQ安装
前面介绍了RabbitMQ是一款使用Erlang语言开发的，因此在RabbitMQ的安装的过程中需要下载ErLang安装包和RabbitMQ安装包，这里需要注意的是ErLang和RabbitMQ的版本的匹配，可参考此网站，查看Erlang和RabbitMQ不同版本之间的对应关系：RabbitMQ Erlang Version Requirements — RabbitMQ
我在安装使用的Erlang的版本是26.1.2，RabbitMQ的版本是3.12.2，这里以Windows下的RabbitMQ安装为例进行介绍。
(1)Erlang安装
Erlang官网：http://www.erlang.org/downloads
下载之后一路点击next即可。
(2)RabbitMQ安装
RabbitMQ官网：http://www.rabbitmq.com/
下载安装之后，在RabbitMQ的安装路径的sbin目录下，打开终端，执行：rabbitmq-plugins enable rabbitmq_management命令安装管理页面的插件。
然后双击rabbitmq-server.bat启动脚本，打开浏览器输入http://localhost:15672，账号密码默认是：guest/guest
3、消息发送接收案例
这里我们先通过界面模拟一个消息的发送案例。
(1)新建队列
点击Quues and Streams创建一个队列first_queue。
(2)查看交换机
点击Exchanges，查看当前的交换机。
(3)发送消息
这里先选择一个交换机，以amp.direct为例，点击进入。
在其下方可以看到Publish message，然后在Payload中填写消息信息：this is a message，点击发送，这时弹出提示可以看到：消息发布了，但是没有被路由。在前面我们介绍了：消息发送给交换机之后，交换机会将消息路由到队列中。但是这里并没有路由到队列中，这是为什么呢？很简单，因为目前amq.redirect交换机和first_queue队列之间并没有绑定，那么自然而然的交换机就不会将消息路由到队列中。从这里我们可以看到：交换机是负责消息的路由转发的，并没有存储消息的能力。那么如何实现交换机和队列的绑定呢？请继续。
(4)绑定交换机和队列
在amq.direct交换机里面可以看到：目前该交换机并没有绑定任何队列。
因此，我们可以在这里选择first_queue队列，并与之绑定。在Bingdings里面填写队列名称之后，即可绑定。
再回到队列里面查看，同样也可以看到队列已经绑定。
(5)发送消息验证
前面绑定了队列，这里我们再次发送消息，可以看到：消息已经发送成功！
我们看下交换机的信息，可以看到有个消息已经发送。
我们再去队列里面看下，同样可以在Overview里面看到有一个消息，在 get message里面也可以看到消息。
三、Java操作RabbitMQ
1、基本准备
(1)引入依赖包
创建Maven工程，引入下面的依赖：
org.springframework.boot
spring-boot-starter-amqp
(2)创建工具类
package com.yht.RabbitMQDemo.simple.utils;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class RabbitMQUtils {
//队列名称
public static final String QUEUE_NAME = "learn_queue";
public static Connection getConnection() throws Exception {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
//主机地址 如果是本机就是localhost 如果在其他 地方比如:虚拟机中 那么就是ip地址
connectionFactory.setHost("localhost");
//连接端口;默认为 5672
connectionFactory.setPort(5672);
//虚拟主机名称 就是和你用户绑定的虚拟机 在创建用户时候就指定了
connectionFactory.setVirtualHost("/virtualHost1");
//连接用户名
connectionFactory.setUsername("guest");
//连接密码
connectionFactory.setPassword("guest");
//创建连接
return connectionFactory.newConnection();
}
}
2、生产者生产消息
创建生产者Producer
package com.yht.RabbitMQDemo.simple;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.yht.RabbitMQDemo.simple.utils.RabbitMQUtils;
public class Producer {
public static void main(String[] args) throws Exception {
//创建连接
Connection connection = RabbitMQUtils.getConnection();
// 创建频道
Channel channel = connection.createChannel();
// 声明（创建）队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接
* 参数4：是否在不使用的时候自动删除队列
* 参数5：队列其它参数
*/
channel.queueDeclare(RabbitMQUtils.QUEUE_NAME, true, false, false, null);
// 要发送的信息
String message = "Hello RabbitMQ！";
/**
* 参数1：交换机名称，如果没有指定则使用默认Default Exchage
* 参数2：路由key,简单模式可以传递队列名称
* 参数3：消息其它属性
* 参数4：消息内容
*/
channel.basicPublish("", RabbitMQUtils.QUEUE_NAME, null, message.getBytes());
System.out.println("消息：" + message + "已经发送！");
// 关闭资源
channel.close();
connection.close();
}
}
执行上述代码之后，可以看到控制台的打印信息：
同时，也可以进入RabbitMQ管理界面，即在浏览器地址栏输入： http://localhost:15672/ ，并输入用户名和密码之后，可以看到：
3、消费者取出消息
创建消费者Consumer
package com.yht.RabbitMQDemo.simple;
import com.rabbitmq.client.*;
import com.yht.RabbitMQDemo.simple.utils.RabbitMQUtils;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
//消费者
public class Consumer {
public static void main(String[] args) throws Exception {
Connection connection = RabbitMQUtils.getConnection();
// 创建频道
Channel channel = connection.createChannel();
// 声明（创建）队列
/**
* 参数1：队列名称
* 参数2：是否定义持久化队列
* 参数3：是否独占本次连接
* 参数4：是否在不使用的时候自动删除队列
* 参数5：队列其它参数
*/
channel.queueDeclare(RabbitMQUtils.QUEUE_NAME, true, false, false, null);
//创建消费者；并设置消息处理
DefaultConsumer consumer = new DefaultConsumer(channel){
@Override
/**
* consumerTag 消息者标签，在channel.basicConsume时候可以指定
* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为：" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为：" + envelope.getExchange());
//消息id
System.out.println("消息id为：" + envelope.getDeliveryTag());
//收到的消息
System.out.println("接收到的消息为：" + new String(body, StandardCharsets.UTF_8));
}
};
//监听消息
/**
* 参数1：队列名称
* 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置为false则需要手动确认
* 参数3：消息接收到后回调
*/
channel.basicConsume(RabbitMQUtils.QUEUE_NAME, true, consumer);
//不关闭资源，应该一直监听消息
//channel.close();
//connection.close();
}
}
这里可以执行下消费者，控制台输出如下：
我们再登进网页端可以去看下队列里面的消息，提示队列为空，这是因为在basicConsume()方法中，我们将第二个参数设置为true，代表当取出这个消息之后，就会将其删除；如果取出消息后不想删除，则可以将其置为false。
四、SpringBoot整合RabbitMQ
1、整合过程
(1)依赖包
org.springframework.boot
spring-boot-starter-amqp
org.projectlombok
lombok
true
org.springframework.boot
spring-boot-starter-test
test
org.springframework.amqp
spring-rabbit-test
test
(2)编写yml文件
spring:
rabbitmq:
host: 127.0.0.1
port: 5672
username: guest
password: guest
virtual-host: /virtualHost1
(3)编写配置类
import org.springframework.amqp.core.*;
import org.springframework.amqp.core.ExchangeBuilder;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitMQConfig {
//定义交换机Bean
@Bean("directExchange")
public Exchange exchange(){
return ExchangeBuilder.directExchange("amq.direct").build();
}
//定义消息队列
@Bean("learnQueue")
public Queue queue(){
return QueueBuilder.nonDurable("learn_queue").build();
}
@Bean("binding")
public Binding binding(@Qualifier("directExchange")Exchange exchange, @Qualifier("learnQueue")Queue queue){
return BindingBuilder.bind(queue).to(exchange).with("my-key").noargs();
}
}
(4)生产者生产消息
在测试类里编写测试方法
@Test
void producer() {
//最后一个是消息
rabbitTemplate.convertAndSend("amq.direct", "my-key", "Hello SpringBoot");
}执行完成之后，可以在learn_queue里面看到在该队列里面已经有一个消息了。
(5)消费者消费消息
创建监听器
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class MQListener {
@RabbitListener(queues = "learn_queue")
public void getMessage(Message message){
System.out.println( "消费者取出消息：" + new String(message.getBody()));
}
}
启动SpringBoot，就可以看到消费者取出了消息。
五、RabbitMQ案例
1、Work Queues模型
前面在SpringBoot里面整合RabbitMQ的案例是比较简单的，只有一个消费者和一个生产者，这里我们介绍一个新的模型，实现一个队列绑定多个消费者。如下图：
这里我们先来模拟一个场景，即：生产者生产50个消息，由两个消费者来进行消费。因此，我们对上面的代码做一个改变。
(1)创建一个队列：work.queue
(2)生产者生产50个消息到work.queue
@Test
void producer() {
for (int i = 1; i <= 50; i++) {
String msg = "Hello SpringBoot: + 【" + i + "】";
rabbitTemplate.convertAndSend("amq.direct", "my-key", msg);
}
System.out.println("消息已经发送");
}(3)消费者取出消息
在监听器里面创建两个消费者，都监听work.queue队列。
@Component
public class MQListener {
@RabbitListener(queues = "learn_queue")
public void getMessage1(Message message){
System.out.println( "【消费者1】取出消息：" + new String(message.getBody()));
}
@RabbitListener(queues = "learn_queue")
public void getMessage2(Message message){
System.err.println( "【消费者2】取出消息：" + new String(message.getBody()));
}
}这里我们来看下执行的结果：
从上面的图我们可以看到几个关键点：
- 两个消费者是以轮询的方式来处理消息的，即生产者的消息平均分给了两个消费者
- 每个消息只会被消费者消费一次
这里就带来了一个问题：如果两个消费者的能力不一样，那么这种轮询的方式就无法很好的利用消费者的性能。我们更希望的是如果消费者1的性能比较好，处理的比较快，那么完全可以让消费者1多处理一些消息，这样更符合我们的实际场景。
综上所述，在默认情况下，RabbitMQ会将消息依次轮询的绑定到队列的每一个消费者，这种情况下因为消费者的性能不同会导致出现消息堆积的情况。因此，我们就需要修改配置文件，设置preFetch值为1，确保同一时刻最多给消费者一条消息，即：每个消费者只有在处理完当前消息之后，才能获取下一个消息。如下：
spring:
rabbitmq:
host: 127.0.0.1
port: 5672
username: guest
password: guest
virtual-host: /virtualHost1
listener:
simple:
prefetch: 1这里修改下消费者的代码，模拟两个消费者的能力不同。
@Component
public class MQListener {
@RabbitListener(queues = "learn_queue")
public void getMessage1(Message message) throws InterruptedException {
Thread.sleep(20);
System.out.println( "【消费者1】取出消息：" + new String(message.getBody()));
}
@RabbitListener(queues = "learn_queue")
public void getMessage2(Message message) throws InterruptedException {
Thread.sleep(200);
System.err.println( "【消费者2】取出消息：" + new String(message.getBody()));
}
}执行结果如下：
2、Fanout交换机
Fanout交换机会将接收到的消息光波导每一个跟其绑定的queue，因此也称为广播模式，如下：
(1) 在RabbitMQ控制台创建两个队列，并绑定到fanout交换机。
(2)生产者生产消息
@Test
void fanout() {
rabbitTemplate.convertAndSend("amq.fanout", "fanout", "Hello Everyone");
}(3)消费者监听消息
@RabbitListener(queues = "fanout.queue1")
public void fanout1(Message message) throws InterruptedException {
System.out.println( "fanout.queue1的消息：" + new String(message.getBody()));
}
@RabbitListener(queues = "fanout.queue2")
public void fanout(Message message) throws InterruptedException {
System.err.println( "fanout.queue2的消息：" + new String(message.getBody()));
}执行结果如下：
3、Direct交换机
该交换机会将接收到的消息根据规则路由到指定的Queue，因此又被称为定向路由。发布者在发送消息时，会指定消息的RoutingKey，而每个Queue都与Exchange会设置一个BindingKey，之后交换机会将消息路由到BindingKey与消息队列RoutingKey一致的队列。 如下图：
(1) 在RabbitMQ控制台创建两个队列，并绑定到fanout交换机。
(2)创建消费者
@RabbitListener(queues = "direct.queue1")
public void direct1(Message message){
System.out.println( "direct.queue1的消息：" + new String(message.getBody()));
}
@RabbitListener(queues = "direct.queue2")
public void direct2(Message message) {
System.err.println( "direct.queue2的消息：" + new String(message.getBody()));
}(3)生产者生产消息
@Test
void direct() {
rabbitTemplate.convertAndSend("amq.direct", "red", "明天暴雨");
}
@Test
void direct() {
rabbitTemplate.convertAndSend("amq.direct", "blue", "明天微风，适合游玩");
}
4、Topic交换机
该交换机与Direct Exchange类似，区别在于routingKey可以时多个单词的列表，并且以.分割。也就是说，Topic交换机接收的消息的RoutingKey可以是多个单词，单词之间以.分割。
Topic交换机的通配符有两种形式：
- *（星号）：表示匹配一个单词。
- #（井号）：表示匹配零个或多个单词。
(1)创建两个队列
(2)修改消费者
@RabbitListener(queues = "topic.queue1")
public void topic1(Message message) {
System.out.println( "topic.queue1的消息：" + new String(message.getBody()));
}
@RabbitListener(queues = "topic.queue2")
public void topic2(Message message){
System.err.println( "topic.queue2的消息：" + new String(message.getBody()));
}(3)创建生产者
第一种：两个队列的routingkey都匹配成功
@Test
void Topic() {
rabbitTemplate.convertAndSend("amq.topic", "zhejiang.weather", "今天天气挺好");
}
第二种：只有一个队列的routingkey匹配成功
@Test
void Topic() {
rabbitTemplate.convertAndSend("amq.topic", "zhejiang.news", "杭州发优惠券了");
}
5、声明队列和交换机
(1)方式一：代码方式
SpringAMQP提供了几个类，用来声明队列、交换机及其绑定关系：
- Queue：用于声明队列，可以用工厂类QueueBuilder创建
- Exchange：用于声明交换机，可以用工厂类ExchangeBuilder构建
- Binding：用于声明队列和交换机的绑定关系，可以用工厂类BindingBuilder构建
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class DirectListener {
@Bean
public DirectExchange directExchange(){
return new DirectExchange("amq.direct");
}
@Bean
public Queue directQueue(){
return new Queue("direct.queue1");
}
@Bean
public Binding directBind(Queue directQueue, DirectExchange directExchange){
return BindingBuilder.bind(directQueue).to(directExchange).withQueueName();
}
}
(2)方式二：注解方式
Spring AMQP还提供了基于@RabbitListener注解来声明队列和交换机的方式。
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue1", durable = "true"),
exchange = @Exchange(name = "amq.direct", type = ExchangeTypes.DIRECT),
key = {"red"}
))
public void directByAnno(Message message){
System.out.println( "direct.queue1的消息：" + new String(message.getBody()));
}6、消息转换器
如果我们需要利用Spring AMQP发送对象类型的消息，需要基于JDK的ObejctOutputStream完成序列化。否则的话，拿到的消息就是有问题的，如下图：
(1)引入依赖
com.fasterxml.jackson.core
jackson-databind
(2)配置消息转换器MessageConverter
@Bean
public MessageConverter messageConverter(){
return new Jackson2JsonMessageConverter();
}(3)发送消息
@Test
void fanout() {
Map map = new HashMap<>();
map.put("name", "tom");
map.put("age", "23");
rabbitTemplate.convertAndSend("amq.fanout", "fanout", map);
} 执行之后，可以去获取消息，如下：
