RabbitMQ 采用 Erlang 语言开发，同时具有高可用性、高可靠性、消息低延迟，支持的多种开发语言的等优点，是当前比较流行的综合性最好的消息队列。当然有些杠精肯定会拿 RocketMQ 和 Kafka 等消息队列的相关性能跟 RabbitMQ 进行对比说事儿，这里不进行评价，你们这些杠精开心就好，说服一个人没有意义，把技术学到手，能够解决工作中的实际问题才是最重要的。
RabbitMQ 的官网地址：https://www.rabbitmq.com
AMQP 全称 Advanced Message Queuing Protocol（高级消息队列协议），是用于在应用程序之间传递业务消息的开放标准。该协议与语言和平台无关，很符合微服务中独立性的要求。Spring AMQP 是基于 AMQP 协议定义的一套 API 规范，提供了模板来发送和接收消息。默认情况下是基于 RabbitMQ 实现，能够使用 SpringBoot 进行自动装配，大大简化了程序代码的开发。
Spring AMQP 的官网地址：https://spring.io/projects/spring-amqp
本篇博客的 Demo 使用 Spring AMQP 操作 RabbitMQ，在博客最后提供源代码下载。
一、安装部署 RabbitMQ
之前的博客已经介绍了 Docker，为了简化安装过程，因此这里采用 Docker 安装启动 RabbitMQ
我安装 Docker 的虚拟机是 CentOS7，IP 地址是 192.168.216.128
在写本篇博客时，RabbitMQ 的官网上最新版本是 3.12 ，因此使用 Docker 安装的命令如下：
# 反斜杠（\）表示命令换行，因此命令太长，因此换行编写命令比较方便查看
docker run \
-e RABBITMQ_DEFAULT_USER=jobs \
-e RABBITMQ_DEFAULT_PASS=qwert \
--name mq \
--hostname mq \
-p 15672:15672 \
-p 5672:5672 \
-d rabbitmq:3.12-management
e 表示环境变量，RABBITMQ_DEFAULT_USER 表示默认用户名，RABBITMQ_DEFAULT_PASS 表示默认密码
hostname 表示主机名（这个很重要，因为 RabbitMQ 使用主机名来命名节点，当进行集群部署时用以区分每个节点，当然我们现在先使用单节点部署 RabbitMQ）。
p 表示宿主机映射 Docker 容器内部的端口，这里映射出 2 个端口（如果你防火墙没关闭的话，需要开放这 2 个端口），其中 5672 是程序连接发送和接收消息的端口，15672 是可视化界面的访问端口。
rabbitmq:3.12-management 是当前最新版本的 Docker 镜像名称。
以上操作都完成后，打开浏览器访问 http://192.168.216.128:15672，即可访问到可视化界面：
然后输入用户名 jobs ，密码 qwert 即可登录进去。可以查看到 RabbitMQ 的客户端连接、Exchange 交换机、Queue 队列、VirtualHost 虚拟主机等信息，可以直接进行可视化界面操作，有关 RabbitMQ 的相关概念介绍，这里不做过多介绍。
二、搭建工程
搭建一个父工程，包含 2 个 SpringBoot 子工程，分别用来发送和接收消息。
publish_msg 是发送消息的项目工程，其发送代码都是在测试类 PublishMessageTest 中编写。
consumer_msg 是接收消息的项目工程，其接收代码都是在 SpringAmqpListener 类中编写。
publish_msg 和 consumer_msg 中的 pom 文件由于需要使用相同的依赖，因此这两个工程的 pom 中没有引入任何依赖，它们所使用的依赖都是在父工程的 pom 中引入的，父工程的完成 pom 文件内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jobs</groupId>
<artifactId>spring_amqp</artifactId>
<version>v1.0</version>
<modules>
<module>publish_msg</module>
<module>consumer_msg</module>
</modules>
<packaging>pom</packaging>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.5</version>
<relativePath/>
</parent>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<!--在此主要使用 lombok 自带的 log 方法-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!--Spring AMQP 消息队列依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<!--引入单元测试依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<!--发送和接收消息，默认使用 jdk 的序列化进行消息转换，
引入该依赖，是为了配置消息转换使用 json 格式-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
</dependencies>
</project>
三、消息接收者
之所以先介绍消息接收者，是因为在消息接收者代码中，能够通过注解声明出 Exchange 交换机和 Queue 队列，默认情况下是持久化的，因此只要先启动一次消费者程序，在 RabbitMQ 中就能够永久存储 Exchange 和 Queue ，后续就无所谓发送者和消费者的启动顺序了。首先我们先在 application.yml 中配置好 RabittMQ 的连接信息：
spring:
rabbitmq:
host: 192.168.216.128
port: 5672
username: jobs
password: qwert
virtual-host: /
listener:
simple:
# 每次取 1 条消息进行消费，消费成功后再去取下一条消息
# 防止多个消费者被均匀分配消息，让消费能力强的消费者能够获取更多的消息
prefetch: 1
这里需要特别说明的是：最好配置上 prefetch，并且给予一个合理的值。如果不配置的话，当有多个消费者时，消费同一个消息队列时，不管消费者所在的机器性能如何，都会得到均匀数量的消息分配，这显然不是我们所期望的。我们肯定期望性能好的机器上的消费者能够多消费一些消息，因此配置上 prefetch 后，每个消费者都会先取出一定数量的消息消费完成后，再去获取下一批消息，这样就能够实现根据机器性能分配消息了。
下面列出 RabbitMQ 的 5 种消息队列的监听程序代码：
package com.jobs.listener;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import java.util.Map;
@Component
public class SpringAmqpListener {
/* SimpleQueue 接收消息代码 */
@RabbitListener(queuesToDeclare = @Queue(name = "simple.queue"))
public void simpleQueuelistener(String msg) {
System.out.println("接收到simple.queue的消息：" + msg);
}
//-------------------------
/* WorkQueue 接收消息代码，这里写了 2 个监听程序，用以模拟 2 个消费者 */
@RabbitListener(queuesToDeclare = @Queue(name = "work.queue"))
public void workQueueListener1(String msg) {
System.out.println("listener【1】接收到work.queue消息：" + msg);
}
@RabbitListener(queuesToDeclare = {@Queue(name = "work.queue")})
public void workQueueListener2(String msg) {
System.out.println("listener【2】接收到work.queue消息：" + msg);
}
//-------------------------
/* fanout 接收消息代码，这里写了 2 个监听程序，用以模拟 2 个消费者 */
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "fanout.queue1"),
exchange = @Exchange(name = "jobs.fanout", type = ExchangeTypes.FANOUT)
))
public void listenerFanoutQueue1(String msg) {
System.out.println("接收到fanout.queue【1】消息：" + msg);
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "fanout.queue2"),
exchange = @Exchange(name = "jobs.fanout", type = ExchangeTypes.FANOUT)
))
public void listenerFanoutQueue2(String msg) {
System.out.println("接收到fanout.queue【2】消息：" + msg);
}
//-------------------------
/* direct 接收消息代码，这里写了 2 个监听程序，用以模拟 2 个消费者 */
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue1"),
exchange = @Exchange(name = "jobs.direct", type = ExchangeTypes.DIRECT),
key = {"big", "middle"}
))
public void listenerDirectQueue1(String msg) {
System.out.println("接收到direct.queue【1】消息：" + msg);
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue2"),
exchange = @Exchange(name = "jobs.direct", type = ExchangeTypes.DIRECT),
key = {"small", "middle"}
))
public void listenerDirectQueue2(String msg) {
System.out.println("接收到direct.queue【2】消息：" + msg);
}
//-------------------------
/* toppic 接收消息代码，这里写了 2 个监听程序，用以模拟 2 个消费者
toppic 表达式中的占位符：# 表示一个或多个单词，* 表示一个单词 */
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "topic.queue1"),
exchange = @Exchange(name = "jobs.topic", type = ExchangeTypes.TOPIC),
key = "china.#"
))
public void listenerTopicQueue1(String msg) {
System.out.println("接收到topic.queue【1】消息：" + msg);
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "topic.queue2"),
exchange = @Exchange(name = "jobs.topic", type = ExchangeTypes.TOPIC),
key = "#.news"
))
public void listenerTopicQueue2(String msg) {
System.out.println("接收到topic.queue【2】消息：" + msg);
}
//-------------------------
/* 自定义接收消息代码，接收自定义对象的消息，通过配置消息转换，使用 Json 格式进行传输 */
@RabbitListener(queuesToDeclare = @Queue(name = "object.queue"))
public void listenerObjectQueue(Map<String, Object> msg) {
System.out.println("接收到object.queue的消息：" + msg);
}
}
启动消费者 SpringBoot 程序，就可以在可视化界面中，看到声明的 Exchange 和 Queue 了：
四、消息发送者
首先在 application.yml 中配置好 RabbitMQ 的连接信息：
spring:
rabbitmq:
host: 192.168.216.128
port: 5672
username: jobs
password: qwert
virtual-host: /
我们在测试类 PublishMessageTest 中编写为各种类型消息队列发送消息的代码：
package com.jobs.publishtest;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.HashMap;
import java.util.Map;
@SpringBootTest
public class PublishMessageTest {
@Autowired
private RabbitTemplate rabbitTemplate;
//给 SimpleQueue 类型的消息队列发送消息
@Test
public void SendMsgToSimpleQueue() {
String queueName = "simple.queue";
String message = "hello，simple.queue";
rabbitTemplate.convertAndSend(queueName, message);
}
//给 WorkQueue 类型的消息队列发送消息，
//WorkQueue 实际上也是 SimpleQueue 类型的消息队列，只不过有多个消费者来接收消息而已
@Test
public void SendMessageWorkQueue() {
String queueName = "work.queue";
String message = "hello，work.queue__";
for (int i = 1; i <= 20; i++) {
rabbitTemplate.convertAndSend(queueName, message + i);
}
}
//给 Fanout 类型的消息队列发送消息
@Test
public void sendFanoutExchange() {
String exchangeName = "jobs.fanout";
String message = "打雷了，下雨了，快来收衣服了";
rabbitTemplate.convertAndSend(exchangeName, "", message);
}
//给 Direct 类型的消息队列发送消息
@Test
public void sendDirectExchange() {
String exchangeName = "jobs.direct";
String message1 = "hello，big";
rabbitTemplate.convertAndSend(exchangeName, "big", message1);
String message2 = "hello，middle";
rabbitTemplate.convertAndSend(exchangeName, "middle", message2);
String message3 = "hello，small";
rabbitTemplate.convertAndSend(exchangeName, "small", message3);
}
//给 Topic 类型的消息队列发送消息
@Test
public void sendTopicExchange() {
String exchangeName = "jobs.topic";
String message1 = "hello，usa新闻";
rabbitTemplate.convertAndSend(exchangeName, "usa.news", message1);
String message2 = "hello，china新闻";
rabbitTemplate.convertAndSend(exchangeName, "china.news", message2);
}
//发送自定义对象类型消息，这里的 object.queue 实际上是 SimpleQueue 类型的消息队列
@Test
public void sendObjectMessage() {
Map<String, Object> map = new HashMap<>();
map.put("name", "乔豆豆");
map.put("age", 39);
rabbitTemplate.convertAndSend("object.queue", map);
}
}
最后我们启动消费者 SpringBoot 程序后，依次运行发送者 SpringBoot 程序中的测试类中的方法，查看控制台打印的内容验证运行成果。以上就是使用 Spring AMQP 操作 RabbitMQ 实现 5 种消息队列的消息发送和接收的程序代码，有兴趣的话可以上网查询一下使用原生 api 方法操作 RabbitMQ 的代码进行对比一下，可以发现 Spring AMQP 的代码要简单很多，非常容易。
本篇博客的 Demo 源代码下载地址：https://files.cnblogs.com/files/blogs/699532/spring_amqp.zip