RabbitMQ讲解文档

RabbitMQ

1、MQ是什么

全称 Message Queue ， 即消息总线

是一种跨进程、异步的通信机制

用于上下游传递消息，由消息系统来确保消息的可靠传递。

常见的MQ：

特性	RabbitMQ	Kafka	RocketMQ	ActiveMQ
开发语言	Erlang	Scala&Java	Java	Java
客户端支持	官方支持Erlang、Java、Ruby等，社区产出多语言API，几乎支持所有常用语言	官方支持Java，社区有多语言版本，如PHP、Python、Go、C/C++、Ruby、NodeJs等	Java、C++	Java、C/C++、Python、PHP、Perl、.net等
协议支持	AMQP、XMPP、SMTP、SMTOP	自定义协议，社区提供了HTTP协议支持	自定义协议，社区提供JMS	OpenWire、SMTOP、REST、XMPP、AMQP
可用性	高，基于主从架构实现高可用	很高，分布式，一个数据多个副本，少数机器宕机，不会丢失数据，不会导致不可用	很高，分布式架构	高，基于主从架构实现高可用
集群	支持	支持	支持	支持
负载均衡	支持	支持	支持	支持
单机吞吐量	万级	十万级	十万级	万级
topic数量对吞吐量的影响	-	topic从几十到几百个时候，吞吐量会大幅度下降，因为Kafka的每个Topic、每个分区都会对应一个物理文件，若需要支撑大规模的topic，则需要增加更多的机器资源	topic达到几百/几千的级别后，吞吐量会有较小幅度的下降，在同等机器下，可以支撑大量的 topic	-
消息批量操作	不支持	支持	支持	支持
消息推拉模式	pull/push均支持	pull	pull/push均支持	pull/push均支持
消息可靠性	支持最少投递一次	支持最少投递一次	支持最少投递一次	有较低的概率丢失数据
消息延迟	微秒级 (最快)	毫秒级	毫秒级	毫秒级
持久化能力	内存、文件，支持数据堆积，但影响生产速率	磁盘文件，只要容量够，可以做到无限堆积	磁盘文件	内存、文件、数据库
事务消息	不支持	不支持	支持	支持
死信	支持	不支持	支持	支持
消息回放	不支持	支持offset维度回放	支持offset维度回放	不支持
延迟队列	支持	不支持	支持	支持

2、什么是RabbitMQ

消息队列中间件 (Message Queue Middleware，简称 MQ) 是指利用高效可靠的消息传递机制进行与平台无关的数据交流，它可以在分布式环境下扩展进程间的数据通信，并基于数据通信来进行分布式系统的集成，是一套开源（MPL）的消息队列服务软件，是由 LShift 提供的一个 Advanced Message Queuing Protocol (AMQP) 的开源实现，由以高性能、健壮以及可伸缩性出名的 Erlang 写成。它主要适用于以下场景：

• 项目解耦：不同的项目或模块可以使用消息中间件进行数据的传递，从而可以保证模块的相对独立性，实现解耦。

• 流量削峰：可以将突发的流量 (如秒杀数据) 写入消息中间件，然后由多个消费者进行异步处理。

• 弹性伸缩：可以通过对消息中间件进行横向扩展来提高系统的处理能力和吞吐量。

• 发布订阅：可以用于任意的发布订阅模式中。

• 异步处理：当我们不需要对数据进行立即处理，或者不关心数据的处理结果时，可以使用中间件进行异步处理。

• 冗余存储：消息中间件可以对数据进行持久化存储，直到你消费完成后再进行删除。

  缺点有以下几个：

  • 系统可用性降低

  本来系统运行好好的，现在你非要加入个消息队列进去，那消息队列挂了，你的系统不是呵呵了。因此，系统可用性会降低；

  • 系统复杂度提高

  加入了消息队列，要多考虑很多方面的问题，比如：一致性问题、如何保证消息不被重复消费、如何保证消息可靠性传输等。因此，需要考虑的东西更多，复杂性增大。

  • 一致性问题

  A 系统处理完了直接返回成功了，人都以为你这个请求就成功了；但是问题是，要是 BCD 三个系统那里，BD 两个系统写库成功了，结果 C 系统写库失败了，咋整？你这数据就不一致了。

3、RabbitMQ安装配置

01.windows环境下安装RabbitMQ

1.下载Eralng，下面链接已提供otp_win64_20.2.exe

链接： https://pan.baidu.com/s/1lmvCMPVAV1Ba9UogCdQpZg

提取码：x9m7

2.下载rabbitmq，下面链接已提供rabbitmq-server-3.7.4.exe

链接： https://pan.baidu.com/s/1CPfhg5X1e7UitpgMWIcAEg

提取码：h4r3

1.1安装erlang并配置环境变量

双击otp_win64_20.2.exe，点击next

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ip6KHqZV-1667442274207)(file:///C:\Users\acer\AppData\Local\Temp\ksohtml16396\wps1.jpg)]

1.2选择安装目录

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jNAhMoXS-1667442274208)(file:///C:\Users\acer\AppData\Local\Temp\ksohtml16396\wps2.jpg)]

1.3配置环境变量

新建系统变量名为:ERLANG_HOME变量值为erlang的安装地址

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M7JH9Z6L-1667442274208)(file:///C:\Users\acer\AppData\Local\Temp\ksohtml16396\wps3.jpg)]

双击系统变量path，点击“新建”，将%ERLANG_HOME%\bin加入到path中。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iBtDx0Yv-1667442274209)(file:///C:\Users\acer\AppData\Local\Temp\ksohtml16396\wps4.jpg)]

\2. 安装RabbitMQ

2.1双击下载完成的.exe文件，安装过程与erlang的过程相同

2.2安装RabbitMQ-Plugins cmd打开在RabbitMQ的sbin目录下输入 rabbitmq-plugins enable rabbitmq_management，单击回车

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RIch3kCO-1667442274209)(file:///C:\Users\acer\AppData\Local\Temp\ksohtml16396\wps5.jpg)]

2.3随后访问RabbitMQ的地址http：//127.0.0.1:15672,默认用户名与密码为guest

02.虚拟机环境下安装RabbitMQ

1、打开终端cd安装包路所在文件夹

首先安装erlang，输入命令

rpm -ivh erlang-23.2.7-2.el7.x86_64.rpm

安装完成后erlang还需要安装一个依赖，保证网络通畅，输入命令

yum install socat -y

安装rabbitmq，输入命令

rpm -ivh rabbitmq-server-3.10.0-1.el7.noarch.rpm

1 首先安装erlang，输入命令 rpm -ivh erlang-23.2.7-2.el7.x86_64.rpm

2 安装完成后erlang还需要安装一个依赖，保证网络通畅，输入命令yum install socat -y

3 安装rabbitmq，输入命令rpm -ivh rabbitmq-server-3.10.0-1.el7.noarch.rpm

至此rabbitmq以安装完成

2、启动RabbitMQ

1 启动命令 ：/sbin/service rabbitmq-server start

2 查看状态 ：/sbin/service rabbitmq-server status

3 关闭命令 ：/sbin/service rabbitmq-server stop

4 在工作中中间件都是待命状态，所以要保证一直运行状态，为避免操作系统宕机重启后能够及时启动rabbitmq，可以设置开机自启

开机自启命令 ：chkconfig rabbitmq-server on

3、安装Web界面插件（web界面方便我们可视化管理rabbitmq）

安装前要关闭rabbitmq

/sbin/service rabbitmq-server stop

安装web界面插件

rabbitmq-plugins enable rabbitmq_management

重新启动rabbitmq

/sbin/service rabbitmq-server start

需要关闭防火墙才能当问

systemctl stop firewalld

设置防火墙为默认关闭状态

systemctl enable firewalld

查看防火墙状态

systemctl status firewalld

浏览器访问127.0.0.1:15672就可访问到如下界面

这里本地可以配置linux的IP，通过IP访问(liunx和windows有略微差异)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GHozkpAF-1667442274210)(file:///C:\Users\acer\AppData\Local\Temp\ksohtml16396\wps6.jpg)]

4、配置登录用户设置用户权限

默认登录名密码为guest，但是初次登录会发现提示没有权限拒绝登录，所以需要我们自己配置用户密码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FYVEHFjy-1667442274210)(file:///C:\Users\acer\AppData\Local\Temp\ksohtml16396\wps7.jpg)]

4、RabbitMQ 组件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1dvLpgsa-1667442274211)(C:\Users\acer\AppData\Roaming\Typora\typora-user-images\image-20221025171849583.png)]

• 消费者（consumer）

可以订阅某个队列

• 生产者（publisher）

创建消息，然后发布到队列中(queue)，最终将消息发送到监听的消费者

• Broker：

一个实体，用于标识消息队列服务器

• Virtual Host

虚拟主机

标识一批交换机、消息队列和相关对象

虚拟主机是共享相同的身份认证和加密环境的独立服务器域

每个vhost本质上就是一个mini版的RabbitMQ服务器，拥有自己的队列、交换器、绑定和权限机制

• Exchange

交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列

• Queue

消息队列，用来保存消息直到发送给消费者

它是消息的容器，也是消息的终点

一个消息可投入一个或多个队列

消息一直在队列里面，等待消费者连接到这个队列并将它取走

• Banding

绑定，用于消息队列和交换机之间的关联

一个绑定就是基于路由键将交换机和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表

• Channel

信道，多路复用连接中的一条独立的双向数据流通道

信道是建立在真实的TCP连接内地虚拟链接，AMQP命令都是通过新到发出去的，不管是发布消息、订阅队列还是接收消息，这些动作都是通过信道完成的，为了复用一条TCP连接

• Connection

网络连接，例如一个TCP连接，可以有多个

• Publisher

消息的生产者

也是一个向交换器发布消息的客户端应用程序

• Consumer

消息的消费者

表示从一个消息队列中取得消息的客户端应用程序

• Message

消息，它是由消息头和消息体组成

消息体是不透明的，而消息头则是由一系列的可选属性组成

这些属性包括如下参数

• routing-key (路由键)
• priority (优先级)
• delivery-mode (消息可能需要持久性存储[消息的路由模式]）

5、RabbitMQ的使用

1）、原生开发

01、simple简单模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-plPuEqne-1667442274211)(C:\Users\acer\AppData\Roaming\Typora\typora-user-images\image-20221025173159921.png)]

• 消息产生者将消息放入队列
• 消息的消费者监听消息队列，如果队列中有消息就消费掉

消息被拿走后，自动从队列中删除。

代码实现：

导入依赖

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.7.1</version>
</dependency>

建立连接工具类

public class ConncetionUtil {

    public static Connection getConnection() throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("guest");
        factory.setPassword("guest");
        Connection connection = factory.newConnection();
        return connection;
    }
}

生产者发送消息

public class Send {

    private final static String QUEUE_NAME = "simple_queue";

    public static void main(String[] args) throws Exception {
        Connection connection = ConncetionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        String msg = "Hello RabbitMQ";
        channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
        System.out.println("[x]Send" + msg + "");
        channel.close();
        connection.close();
    }
}

消费者接收消息

public class Received {
    private final static String QUEUE_NAME = "simple_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConncetionUtil.getConnection();
        Channel channel = connection.createChannel();
        //实现消费方法
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String exchange = envelope.getExchange();
                long deliveryTag = envelope.getDeliveryTag();
                String msg = new String(body, "utf-8");
                System.out.println("[消费者1]received:" + msg + "!");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

02、work工作模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cZlMSBIf-1667442274211)(C:\Users\acer\AppData\Roaming\Typora\typora-user-images\image-20221025174326640.png)]

• 消息产生者将消息放入队列，这里的消费者可以有多个

消费者C1，消费者C2，同时监听同一个队列

消息被消费者C1，C2共同争抢当前的消息队列内容，谁先拿到谁负责消费消息

这里就会有这样的问题，同一个消息会被不同的消费者都消费掉，我们需要处理这种问题

可以设置一个开关，syncronize，保证一条消息只能被一个消费者使用

• 用于场景

  • 红包场景
  • 大型项目中的资源调度

  代码与简单模式发送接收者一样，只需创建消费者2来接收消息

2）、SpringAMQP开发

2.1**.什么是SpringAMQP**

l AMQP: Advanced Message Queuing Protocol 是用于在应用程序或之间传递业务消息的开放标准。该协议与语言和平台无关，更符合微服务中的独立性的要求。

l SpringAMQP：SpringAMQP 是基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息；包含两部分，其中spring-amqp是基础抽象，spring-rabbit是底层的默认实现

l 应用间消息通信的一种协议，与语言和平台无关

2.2.AMQP协议

AMQP (Advanced Message Queuing Protocol) 是一个提供统一消息服务的应用层通讯协议，为消息中间件提供统一的开发规范。不同客户端可以将消息投递到中间件上，或从上面获取消息；发送消息和接收消息的客户端可以采用不同的语言开发、不同的技术实现，但必须遵循相同的 AMQP 协议。AMQP 协议本身包括以下三层：

• Module Layer：位于协议最高层，主要定义了一些供客户端调用的命令，客户端可以利用这些命令实现自己的业务逻辑。例如：可以使用 Queue.Declare 命令声明一个队列或者使用 Basic.Consume 订阅消费一个队列中的消息。
• Session Layer：位于中间层，主要负责将客户端的命令发送给服务器，再将服务端的应答返回给客户端，主要为客户端与服务器之间的通信提供可靠性同步机制和错误处理。
• Transport Layer：位于最底层，主要传输二进制数据流 ，提供帧的处理、信道复用、错误检测和数据表示等。

2.3**.SpringAMQP的特征**

侦听器容器，用于异步处理入站消息

用于发送和接受消息的RabbitTemplate

RabbitAdmin用于自动声明队列，交换和绑定

2.4**.SpringAMQP怎么发送消息？**

l 引入amqp的starter依赖

l 配置RabbitMQ的地址

l 利用RabbitTemplate的convertAndSend方法

03、fanout广播模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kv6Ty9WG-1667442274212)(C:\Users\acer\AppData\Roaming\Typora\typora-user-images\image-20221025182529932.png)]

• X 代表交换机 RabbitMQ 内部组件，每个消费者监听自己的队列
• 生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收 到消息
• 用于场景
  • 邮件群发
  • 群聊天
  • 广播(广告等)

代码实现：

导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

配置文件

logging:
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS
spring:
  rabbitmq:
    host: 127.0.0.1 # rabbitMQ的ip地址
    port: 5672 # 端口
    username: guest
    password: guest
    virtual-host: "/"

配置交换机

@Bean
public FanoutExchange fanoutExchange() {
    return new FanoutExchange("xinzhi.fanout");
}

配置队列

@RabbitListener(queues = "fanout.queue1")
public void listenFanoutQueue1(String msg) {
    System.out.println("消费者接收到fanout.queue1的消息：【" + msg + "】");
}

@RabbitListener(queues = "fanout.queue2")
public void listenFanoutQueue2(String msg) {
    System.out.println("消费者接收到fanout.queue2的消息：【" + msg + "】");
}

配置消息生产者

@Test
public void testSendFanoutExchange() {
    // 交换机名称
    String exchangeName = "xinzhi.fanout";
    // 消息
    String message = "hello, xinzhiRabbitMQ!";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "", message);
}

04、direct路由模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LbogLYpp-1667442274212)(C:\Users\acer\AppData\Roaming\Typora\typora-user-images\image-20221025202400471.png)]

• 每个消费者监听自己的队列，并且设置带统配符的 routingkey
• 生产者将消息发给broker，由交换机根据 routingkey 来转发消息到指定的队列

大致涉及的流程如下：

生产者处理流程：

声明队列并声明交换机 -> 创建连接 -> 创建通道 -> 通道声明交换机 -> 通道声明队列 -> 通过通道使队列绑定到交换机并指定该队列的routingkey（通配符） -> 制定消息 -> 发送消息并指定routingkey（通配符）

消费者处理流程：

声明队列并声明交换机 -> 创建连接 -> 创建通道 -> 通道声明交换机 -> 通道声明队列 -> 通过通道使队列绑定到交换机并指定routingkey（通配符） -> 重写消息消费方法 -> 执行消息方法

代码实现：

配置交换机以及队列

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "direct.queue1"),
        exchange = @Exchange(name = "xinzhi.direct", type = ExchangeTypes.DIRECT),
        key = {"a", "b"}

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "direct.queue2"),
        exchange = @Exchange(name = "xinzhi.direct", type = ExchangeTypes.DIRECT),
        key = {"a", "c"}
))

配置消息生产者

public void testSendDirectExchange() {
    // 交换机名称
    String exchangeName = "xinzhi.direct";
    // 消息
    String message = "hello, a!";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "a", message);
}

05、topic通配符模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WBPergzT-1667442274213)(C:\Users\acer\AppData\Roaming\Typora\typora-user-images\image-20221025210627048.png)]

• */#星号或者井号代表通配符
• *号代表多个单词，而#号代表一个单词
• 路由功能添加模糊匹配
• 消息生产者生产消息，把消息交给交换机 exchange
• 交换机 exchange 根据 key 的规则模糊匹配到对应的队列，由队列的监听消费者接收消息消费

代码实现

配置交换机及队列

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "topic.queue1"),
        exchange = @Exchange(name = "xinzhi.topic", type = ExchangeTypes.TOPIC),
        key = "china.#"
))

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "topic.queue2"),
        exchange = @Exchange(name = "xinzhi.topic", type = ExchangeTypes.TOPIC),
        key = "china.*"
))

配置消息生产者

@Test
public void testSendTopicExchange() {
    // 交换机名称
    String exchangeName = "xinzhi.topic";
    // 消息
    String message1 = "hello i am topic form china.news";
    String message2 = "hello i am topic form china.news.2";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "china.news", message1);
    rabbitTemplate.convertAndSend(exchangeName, "china.news.2", message2);
}

06、PRC模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nDeB3KFC-1667442274213)(C:\Users\acer\AppData\Roaming\Typora\typora-user-images\image-20221025212940347.png)]

这是基于Direct交换机实现的，流程如下：

• 客户端即是生产者也是消费者，向 RPC 请求队列发送 RPC 调用消息，同时监听RPC响应队列
• 服务端监听RPC请求队列的消息，收到消息后执行服务端的方法，得到方法返回的结果
• 服务端将RPC方法 的结果发送到RPC响应队列。
• 客户端监听RPC响应队列，接收到RPC调用结果

07、消息转化器

Spring 会把你发送的消息序列化为字节发送给 MQ，接收消息的时候，还会把字节反序列化为 Java 对象。

默认情况下 Spring 采用的序列化方式是 JDK 序列化。

@RabbitListener(queues = "object.queue")
public void listenObjectQueue(Map<String, Object> msg) {
    System.out.println("接收到object.queue的消息：" + msg);
}

生产者代码

@Test
public void testSendMap() {
    // 准备消息
    Map<String, Object> msg = new HashMap<>();
    msg.put("name", "欣知");
    msg.put("age", 66);
    // 发送消息
    rabbitTemplate.convertAndSend("object.queue", msg);
}

由于JDK序列化存在下列问题

• 数据体积过大

• 有安全漏洞

• 可读性差

所以我们可以通过JSON来序列化即可，只需要publisher和consumer导入依赖

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

RabbitMQ高级

1.消息可靠性

消息从发送，到消费者接收，会经理多个过程：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7tygKzXs-1667442274214)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718155059371.png)]

其中的每一步都可能导致消息丢失，常见的丢失原因包括：

• 发送时丢失：
  • 生产者发送的消息未送达exchange
  • 消息到达exchange后未到达queue
• MQ宕机，queue将消息丢失
• consumer接收到消息后未消费就宕机

针对这些问题，RabbitMQ分别给出了解决方案：

• 生产者确认机制
• mq持久化
• 消费者确认机制
• 失败重试机制

1.1.生产者消息确认

RabbitMQ提供了publisher confirm机制来避免消息发送到MQ过程中丢失。这种机制必须给每个消息指定一个唯一ID。消息发送到MQ以后，会返回一个结果给发送者，表示消息是否处理成功。

返回结果有两种方式：

• publisher-confirm，发送者确认
  • 消息成功投递到交换机，返回ack
  • 消息未投递到交换机，返回nack
• publisher-return，发送者回执
  • 消息投递到交换机了，但是没有路由到队列。返回ACK，及路由失败原因。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4G4u5BbN-1667442274214)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718160907166.png)]

注意：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3DXP0zSr-1667442274214)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718161707992.png)]

1.1.1.修改配置

首先，修改publisher服务中的application.yml文件，添加下面的内容：

spring:
  rabbitmq:
    publisher-confirm-type: correlated
    publisher-returns: true
    template:
      mandatory: true
   

说明：

• publish-confirm-type：开启publisher-confirm，这里支持两种类型：
  • simple：同步等待confirm结果，直到超时
  • correlated：异步回调，定义ConfirmCallback，MQ返回结果时会回调这个ConfirmCallback
• publish-returns：开启publish-return功能，同样是基于callback机制，不过是定义ReturnCallback
• template.mandatory：定义消息路由失败时的策略。true，则调用ReturnCallback；false：则直接丢弃消息

1.1.2.定义Return回调

每个RabbitTemplate只能配置一个ReturnCallback，因此需要在项目加载时配置：

修改publisher服务，添加一个：

package.com.xinzhi.mq.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Configuration;

@Slf4j
@Configuration
public class CommonConfig implements ApplicationContextAware {
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        // 获取RabbitTemplate
        RabbitTemplate rabbitTemplate = applicationContext.getBean(RabbitTemplate.class);
        // 设置ReturnCallback
        rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
            // 投递失败，记录日志
            log.info("消息发送失败，应答码{}，原因{}，交换机{}，路由键{},消息{}",
                     replyCode, replyText, exchange, routingKey, message.toString());
            // 如果有业务需要，可以重发消息
        });
    }
}

1.1.3.定义ConfirmCallback

ConfirmCallback可以在发送消息时指定，因为每个业务处理confirm成功或失败的逻辑不一定相同。

在publisher服务的cn.itcast.mq.spring.SpringAmqpTest类中，定义一个单元测试方法：

public void testSendMessage2SimpleQueue() throws InterruptedException {
    // 1.消息体
    String message = "hello, spring amqp!";
    // 2.全局唯一的消息ID，需要封装到CorrelationData中
    CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
    // 3.添加callback
    correlationData.getFuture().addCallback(
        result -> {
            if(result.isAck()){
                // 3.1.ack，消息成功
                log.debug("消息发送成功, ID:{}", correlationData.getId());
            }else{
                // 3.2.nack，消息失败
                log.error("消息发送失败, ID:{}, 原因{}",correlationData.getId(), result.getReason());
            }
        },
        ex -> log.error("消息发送异常, ID:{}, 原因{}",correlationData.getId(),ex.getMessage())
    );
    // 4.发送消息
    rabbitTemplate.convertAndSend("task.direct", "task", message, correlationData);

    // 休眠一会儿，等待ack回执
    Thread.sleep(2000);
}

1.2.消息持久化

生产者确认可以确保消息投递到RabbitMQ的队列中，但是消息发送到RabbitMQ以后，如果突然宕机，也可能导致消息丢失。

要想确保消息在RabbitMQ中安全保存，必须开启消息持久化机制。

• 交换机持久化
• 队列持久化
• 消息持久化

1.2.1.交换机持久化

RabbitMQ中交换机默认是非持久化的，mq重启后就丢失。

SpringAMQP中可以通过代码指定交换机持久化：

@Bean
public DirectExchange simpleExchange(){
    // 三个参数：交换机名称、是否持久化、当没有queue与其绑定时是否自动删除
    return new DirectExchange("simple.direct", true, false);
}

事实上，默认情况下，由SpringAMQP声明的交换机都是持久化的。

可以在RabbitMQ控制台看到持久化的交换机都会带上D的标示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CMV2DBus-1667442274215)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718164412450.png)]

1.2.2.队列持久化

RabbitMQ中队列默认是非持久化的，mq重启后就丢失。

SpringAMQP中可以通过代码指定交换机持久化：

@Bean
public Queue simpleQueue(){
    // 使用QueueBuilder构建队列，durable就是持久化的
    return QueueBuilder.durable("simple.queue").build();
}

事实上，默认情况下，由SpringAMQP声明的队列都是持久化的。

可以在RabbitMQ控制台看到持久化的队列都会带上D的标示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3HhypdHf-1667442274215)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718164729543.png)]

1.2.3.消息持久化

利用SpringAMQP发送消息时，可以设置消息的属性（MessageProperties），指定delivery-mode：

• 1：非持久化
• 2：持久化

用java代码指定：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ActUxCqo-1667442274215)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718165100016.png)]

默认情况下，SpringAMQP发出的任何消息都是持久化的，不用特意指定。

1.3.消费者消息确认

RabbitMQ是阅后即焚机制，RabbitMQ确认消息被消费者消费后会立刻删除。

而RabbitMQ是通过消费者回执来确认消费者是否成功处理消息的：消费者获取消息后，应该向RabbitMQ发送ACK回执，表明自己已经处理消息。

设想这样的场景：

• 1）RabbitMQ投递消息给消费者
• 2）消费者获取消息后，返回ACK给RabbitMQ
• 3）RabbitMQ删除消息
• 4）消费者宕机，消息尚未处理

这样，消息就丢失了。因此消费者返回ACK的时机非常重要。

而SpringAMQP则允许配置三种确认模式：

•manual：手动ack，需要在业务代码结束后，调用api发送ack。

•auto：自动ack，由spring监测listener代码是否出现异常，没有异常则返回ack；抛出异常则返回nack

•none：关闭ack，MQ假定消费者获取消息后会成功处理，因此消息投递后立即被删除

由此可知：

• none模式下，消息投递是不可靠的，可能丢失
• auto模式类似事务机制，出现异常时返回nack，消息回滚到mq；没有异常，返回ack
• manual：自己根据业务情况，判断什么时候该ack

一般，我们都是使用默认的auto即可。

1.3.1.演示none模式

修改consumer服务的application.yml文件，添加下面内容：

spring:
  rabbitmq:
    listener:
      simple:
        acknowledge-mode: none # 关闭ack

修改consumer服务的SpringRabbitListener类中的方法，模拟一个消息处理异常：

@RabbitListener(queues = "simple.queue")
public void listenSimpleQueue(String msg) {
    log.info("消费者接收到simple.queue的消息：【{}】", msg);
    // 模拟异常
    System.out.println(1 / 0);
    log.debug("消息处理完成！");
}

测试可以发现，当消息处理抛异常时，消息依然被RabbitMQ删除了。

1.3.2.演示auto模式

再次把确认机制修改为auto:

spring:
  rabbitmq:
    listener:
      simple:
        acknowledge-mode: auto # 关闭ack

在异常位置打断点，再次发送消息，程序卡在断点时，可以发现此时消息状态为unack（未确定状态）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8crfU8rc-1667442274216)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718171705383.png)]

抛出异常后，因为Spring会自动返回nack，所以消息恢复至Ready状态，并且没有被RabbitMQ删除：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pEZ5L86x-1667442274216)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718171759179.png)]

1.4.消费失败重试机制

当消费者出现异常后，消息会不断requeue（重入队）到队列，再重新发送给消费者，然后再次异常，再次requeue，无限循环，导致mq的消息处理飙升，带来不必要的压力：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FBgPVdj3-1667442274216)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718172746378.png)]

怎么办呢？

1.4.1.本地重试

我们可以利用Spring的retry机制，在消费者出现异常时利用本地重试，而不是无限制的requeue到mq队列。

修改consumer服务的application.yml文件，添加内容：

spring:
  rabbitmq:
    listener:
      simple:
        retry:
          enabled: true # 开启消费者失败重试
          initial-interval: 1000 # 初识的失败等待时长为1秒
          multiplier: 1 # 失败的等待时长倍数，下次等待时长 = multiplier * last-interval
          max-attempts: 3 # 最大重试次数
          stateless: true # true无状态；false有状态。如果业务中包含事务，这里改为false

重启consumer服务，重复之前的测试。可以发现：

• 在重试3次后，SpringAMQP会抛出异常AmqpRejectAndDontRequeueException，说明本地重试触发了
• 查看RabbitMQ控制台，发现消息被删除了，说明最后SpringAMQP返回的是ack，mq删除消息了

结论：

• 开启本地重试时，消息处理过程中抛出异常，不会requeue到队列，而是在消费者本地重试
• 重试达到最大次数后，Spring会返回ack，消息会被丢弃

1.4.2.失败策略

在之前的测试中，达到最大重试次数后，消息会被丢弃，这是由Spring内部机制决定的。

在开启重试模式后，重试次数耗尽，如果消息依然失败，则需要有MessageRecovery接口来处理，它包含三种不同的实现：

• RejectAndDontRequeueRecoverer：重试耗尽后，直接reject，丢弃消息。默认就是这种方式

• ImmediateRequeueMessageRecoverer：重试耗尽后，返回nack，消息重新入队

• RepublishMessageRecoverer：重试耗尽后，将失败消息投递到指定的交换机

比较优雅的一种处理方案是RepublishMessageRecoverer，失败后将消息投递到一个指定的，专门存放异常消息的队列，后续由人工集中处理。

1）在consumer服务中定义处理失败消息的交换机和队列

@Bean
public DirectExchange errorMessageExchange(){
    return new DirectExchange("error.direct");
}
@Bean
public Queue errorQueue(){
    return new Queue("error.queue", true);
}
@Bean
public Binding errorBinding(Queue errorQueue, DirectExchange errorMessageExchange){
    return BindingBuilder.bind(errorQueue).to(errorMessageExchange).with("error");
}

2）定义一个RepublishMessageRecoverer，关联队列和交换机

@Bean
public MessageRecoverer republishMessageRecoverer(RabbitTemplate rabbitTemplate){
    return new RepublishMessageRecoverer(rabbitTemplate, "error.direct", "error");
}

完整代码：

package cn.itcast.mq.config;

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.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.retry.MessageRecoverer;
import org.springframework.amqp.rabbit.retry.RepublishMessageRecoverer;
import org.springframework.context.annotation.Bean;

@Configuration
public class ErrorMessageConfig {
    @Bean
    public DirectExchange errorMessageExchange(){
        return new DirectExchange("error.direct");
    }
    @Bean
    public Queue errorQueue(){
        return new Queue("error.queue", true);
    }
    @Bean
    public Binding errorBinding(Queue errorQueue, DirectExchange errorMessageExchange){
        return BindingBuilder.bind(errorQueue).to(errorMessageExchange).with("error");
    }

    @Bean
    public MessageRecoverer republishMessageRecoverer(RabbitTemplate rabbitTemplate){
        return new RepublishMessageRecoverer(rabbitTemplate, "error.direct", "error");
    }
}

1.5.总结

如何确保RabbitMQ消息的可靠性？

• 开启生产者确认机制，确保生产者的消息能到达队列
• 开启持久化功能，确保消息未消费前在队列中不会丢失
• 开启消费者确认机制为auto，由spring确认消息处理成功后完成ack
• 开启消费者失败重试机制，并设置MessageRecoverer，多次重试失败后将消息投递到异常交换机，交由人工处理

2.死信交换机

2.1.初识死信交换机

2.1.1.什么是死信交换机

什么是死信？

当一个队列中的消息满足下列情况之一时，可以成为死信（dead letter）：

• 消费者使用basic.reject或 basic.nack声明消费失败，并且消息的requeue参数设置为false
• 消息是一个过期消息，超时无人消费
• 要投递的队列消息满了，无法投递

如果这个包含死信的队列配置了dead-letter-exchange属性，指定了一个交换机，那么队列中的死信就会投递到这个交换机中，而这个交换机称为死信交换机（Dead Letter Exchange，检查DLX）。

如图，一个消息被消费者拒绝了，变成了死信：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WL2V1T6v-1667442274216)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718174328383.png)]

因为simple.queue绑定了死信交换机 dl.direct，因此死信会投递给这个交换机：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fn9KXK9G-1667442274217)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718174416160.png)]

如果这个死信交换机也绑定了一个队列，则消息最终会进入这个存放死信的队列：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jr31M3oK-1667442274217)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718174506856.png)]

另外，队列将死信投递给死信交换机时，必须知道两个信息：

• 死信交换机名称
• 死信交换机与死信队列绑定的RoutingKey

这样才能确保投递的消息能到达死信交换机，并且正确的路由到死信队列。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0COXVc2U-1667442274217)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210821073801398.png)]

2.1.2.利用死信交换机接收死信（拓展）

在失败重试策略中，默认的RejectAndDontRequeueRecoverer会在本地重试次数耗尽后，发送reject给RabbitMQ，消息变成死信，被丢弃。

我们可以给simple.queue添加一个死信交换机，给死信交换机绑定一个队列。这样消息变成死信后也不会丢弃，而是最终投递到死信交换机，路由到与死信交换机绑定的队列。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DZBuR7KL-1667442274217)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718174506856.png)]

我们在consumer服务中，定义一组死信交换机、死信队列：

// 声明普通的 simple.queue队列，并且为其指定死信交换机：dl.direct
@Bean
public Queue simpleQueue2(){
    return QueueBuilder.durable("simple.queue") // 指定队列名称，并持久化
        .deadLetterExchange("dl.direct") // 指定死信交换机
        .build();
}
// 声明死信交换机 dl.direct
@Bean
public DirectExchange dlExchange(){
    return new DirectExchange("dl.direct", true, false);
}
// 声明存储死信的队列 dl.queue
@Bean
public Queue dlQueue(){
    return new Queue("dl.queue", true);
}
// 将死信队列 与 死信交换机绑定
@Bean
public Binding dlBinding(){
    return BindingBuilder.bind(dlQueue()).to(dlExchange()).with("simple");
}

2.1.3.总结

什么样的消息会成为死信？

• 消息被消费者reject或者返回nack
• 消息超时未消费
• 队列满了

死信交换机的使用场景是什么？

• 如果队列绑定了死信交换机，死信会投递到死信交换机；
• 可以利用死信交换机收集所有消费者处理失败的消息（死信），交由人工处理，进一步提高消息队列的可靠性。

2.2.TTL

一个队列中的消息如果超时未消费，则会变为死信，超时分为两种情况：

• 消息所在的队列设置了超时时间
• 消息本身设置了超时时间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4nl6ODkk-1667442274218)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718182643311.png)]

2.2.1.接收超时死信的死信交换机

在consumer服务的SpringRabbitListener中，定义一个新的消费者，并且声明 死信交换机、死信队列：

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "dl.ttl.queue", durable = "true"),
    exchange = @Exchange(name = "dl.ttl.direct"),
    key = "ttl"
))
public void listenDlQueue(String msg){
    log.info("接收到 dl.ttl.queue的延迟消息：{}", msg);
}

2.2.2.声明一个队列，并且指定TTL

要给队列设置超时时间，需要在声明队列时配置x-message-ttl属性：

@Bean
public Queue ttlQueue(){
    return QueueBuilder.durable("ttl.queue") // 指定队列名称，并持久化
        .ttl(10000) // 设置队列的超时时间，10秒
        .deadLetterExchange("dl.ttl.direct") // 指定死信交换机
        .build();
}

注意，这个队列设定了死信交换机为dl.ttl.direct

声明交换机，将ttl与交换机绑定：

@Bean
public DirectExchange ttlExchange(){
    return new DirectExchange("ttl.direct");
}
@Bean
public Binding ttlBinding(){
    return BindingBuilder.bind(ttlQueue()).to(ttlExchange()).with("ttl");
}

发送消息，但是不要指定TTL：

@Test
public void testTTLQueue() {
    // 创建消息
    String message = "hello, ttl queue";
    // 消息ID，需要封装到CorrelationData中
    CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
    // 发送消息
    rabbitTemplate.convertAndSend("ttl.direct", "ttl", message, correlationData);
    // 记录日志
    log.debug("发送消息成功");
}

发送消息的日志：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zJAQwhFD-1667442274218)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718191657478.png)]

查看下接收消息的日志：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sYhLq2Or-1667442274218)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718191738706.png)]

因为队列的TTL值是10000ms，也就是10秒。可以看到消息发送与接收之间的时差刚好是10秒。

2.2.3.发送消息时，设定TTL

在发送消息时，也可以指定TTL：

@Test
public void testTTLMsg() {
    // 创建消息
    Message message = MessageBuilder
        .withBody("hello, ttl message".getBytes(StandardCharsets.UTF_8))
        .setExpiration("5000")
        .build();
    // 消息ID，需要封装到CorrelationData中
    CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
    // 发送消息
    rabbitTemplate.convertAndSend("ttl.direct", "ttl", message, correlationData);
    log.debug("发送消息成功");
}

查看发送消息日志：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mDYs9WRE-1667442274219)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718191939140.png)]

接收消息日志：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PW37UH7a-1667442274219)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718192004662.png)]

这次，发送与接收的延迟只有5秒。说明当队列、消息都设置了TTL时，任意一个到期就会成为死信。

2.2.4.总结

消息超时的两种方式是？

• 给队列设置ttl属性，进入队列后超过ttl时间的消息变为死信
• 给消息设置ttl属性，队列接收到消息超过ttl时间后变为死信

如何实现发送一个消息20秒后消费者才收到消息？

• 给消息的目标队列指定死信交换机
• 将消费者监听的队列绑定到死信交换机
• 发送消息时给消息设置超时时间为20秒

2.3.延迟队列

利用TTL结合死信交换机，我们实现了消息发出后，消费者延迟收到消息的效果。这种消息模式就称为延迟队列（Delay Queue）模式。

延迟队列的使用场景包括：

• 延迟发送短信
• 用户下单，如果用户在15 分钟内未支付，则自动取消
• 预约工作会议，20分钟后自动通知所有参会人员

因为延迟队列的需求非常多，所以RabbitMQ的官方也推出了一个插件，原生支持延迟队列效果。

这个插件就是DelayExchange插件。参考RabbitMQ的插件列表页面：https://www.rabbitmq.com/community-plugins.html

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1zQpgRZr-1667442274219)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718192529342.png)]

使用方式可以参考官网地址：https://blog.rabbitmq.com/posts/2015/04/scheduling-messages-with-rabbitmq

2.3.1.DelayExchange原理

DelayExchange需要将一个交换机声明为delayed类型。当我们发送消息到delayExchange时，流程如下：

• 接收消息
• 判断消息是否具备x-delay属性
• 如果有x-delay属性，说明是延迟消息，持久化到硬盘，读取x-delay值，作为延迟时间
• 返回routing not found结果给消息发送者
• x-delay时间到期后，重新投递消息到指定队列

2.3.2.使用DelayExchange

插件的使用也非常简单：声明一个交换机，交换机的类型可以是任意类型，只需要设定delayed属性为true即可，然后声明队列与其绑定即可。

1）声明DelayExchange交换机

基于注解方式（推荐）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OTpEZ5CM-1667442274219)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718193747649.png)]

也可以基于@Bean的方式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hlcT5gFq-1667442274220)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718193831076.png)]

2）发送消息

发送消息时，一定要携带x-delay属性，指定延迟的时间：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e2pcPcaa-1667442274220)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718193917009.png)]

2.3.4.总结

延迟队列插件的使用步骤包括哪些？

•声明一个交换机，添加delayed属性为true

•发送消息时，添加x-delay头，值为超时时间

3.惰性队列

3.1.消息堆积问题

当生产者发送消息的速度超过了消费者处理消息的速度，就会导致队列中的消息堆积，直到队列存储消息达到上限。之后发送的消息就会成为死信，可能会被丢弃，这就是消息堆积问题。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qXpqPmdN-1667442274220)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718194040498.png)]

解决消息堆积有两种思路：

• 增加更多消费者，提高消费速度。也就是我们之前说的work queue模式
• 扩大队列容积，提高堆积上限

要提升队列容积，把消息保存在内存中显然是不行的。

3.2.惰性队列

从RabbitMQ的3.6.0版本开始，就增加了Lazy Queues的概念，也就是惰性队列。惰性队列的特征如下：

• 接收到消息后直接存入磁盘而非内存
• 消费者要消费消息时才会从磁盘中读取并加载到内存
• 支持数百万条的消息存储

3.2.1.基于命令行设置lazy-queue

而要设置一个队列为惰性队列，只需要在声明队列时，指定x-queue-mode属性为lazy即可。可以通过命令行将一个运行中的队列修改为惰性队列：

rabbitmqctl set_policy Lazy "^lazy-queue$" '{"queue-mode":"lazy"}' --apply-to queues  

命令解读：

• rabbitmqctl ：RabbitMQ的命令行工具
• set_policy ：添加一个策略
• Lazy ：策略名称，可以自定义
• "^lazy-queue$" ：用正则表达式匹配队列的名字
• '{"queue-mode":"lazy"}' ：设置队列模式为lazy模式
• --apply-to queues ：策略的作用对象，是所有的队列

3.2.2.基于@Bean声明lazy-queue

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-294n1cOq-1667442274221)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718194522223.png)]

3.2.3.基于@RabbitListener声明LazyQueue

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DiTehXvD-1667442274221)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718194539054.png)]

3.3.总结

消息堆积问题的解决方案？

• 队列上绑定多个消费者，提高消费速度
• 使用惰性队列，可以再mq中保存更多消息

惰性队列的优点有哪些？

• 基于磁盘存储，消息上限高
• 没有间歇性的page-out，性能比较稳定

惰性队列的缺点有哪些？

• 基于磁盘存储，消息时效性会降低
• 性能受限于磁盘的IO

4.MQ集群

4.1.集群分类

RabbitMQ的是基于Erlang语言编写，而Erlang又是一个面向并发的语言，天然支持集群模式。RabbitMQ的集群有两种模式：

•普通集群：是一种分布式集群，将队列分散到集群的各个节点，从而提高整个集群的并发能力。

•镜像集群：是一种主从集群，普通集群的基础上，添加了主从备份功能，提高集群的数据可用性。

镜像集群虽然支持主从，但主从同步并不是强一致的，某些情况下可能有数据丢失的风险。因此在RabbitMQ的3.8版本以后，推出了新的功能：仲裁队列来代替镜像集群，底层采用Raft协议确保主从的数据一致性。

4.2.普通集群

4.2.1.集群结构和特征

普通集群，或者叫标准集群（classic cluster），具备下列特征：

• 会在集群的各个节点间共享部分数据，包括：交换机、队列元信息。不包含队列中的消息。
• 当访问集群某节点时，如果队列不在该节点，会从数据所在节点传递到当前节点并返回
• 队列所在节点宕机，队列中的消息就会丢失

结构如图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1YOmxqcZ-1667442274221)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718220843323.png)]

4.3.镜像集群

4.3.1.集群结构和特征

镜像集群：本质是主从模式，具备下面的特征：

• 交换机、队列、队列中的消息会在各个mq的镜像节点之间同步备份。
• 创建队列的节点被称为该队列的主节点，备份到的其它节点叫做该队列的镜像节点。
• 一个队列的主节点可能是另一个队列的镜像节点
• 所有操作都是主节点完成，然后同步给镜像节点
• 主宕机后，镜像节点会替代成新的主

结构如图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-psO1USd4-1667442274221)(E:\MQ\day05-MQ高级\day05-MQ高级\讲义\assets\image-20210718221039542.png)]

4.4.仲裁队列

4.4.1.集群特征

仲裁队列：仲裁队列是3.8版本以后才有的新功能，用来替代镜像队列，具备下列特征：

• 与镜像队列一样，都是主从模式，支持主从数据同步
• 使用非常简单，没有复杂的配置
• 主从同步基于Raft协议，强一致

4.4.2.Java代码创建仲裁队列

@Bean
public Queue quorumQueue() {
    return QueueBuilder
        .durable("quorum.queue") // 持久化
        .quorum() // 仲裁队列
        .build();
}

4.4.3.SpringAMQP连接MQ集群

注意，这里用address来代替host、port方式

spring:
  rabbitmq:
    addresses: 192.168.150.105:8071, 192.168.150.105:8072, 192.168.150.105:8073
    username: itcast
    password: 123321
    virtual-host: /

• 队列上绑定多个消费者，提高消费速度
• 使用惰性队列，可以再mq中保存更多消息

惰性队列的优点有哪些？

• 基于磁盘存储，消息上限高
• 没有间歇性的page-out，性能比较稳定

惰性队列的缺点有哪些？

• 基于磁盘存储，消息时效性会降低
• 性能受限于磁盘的IO

4.MQ集群

4.1.集群分类

RabbitMQ的是基于Erlang语言编写，而Erlang又是一个面向并发的语言，天然支持集群模式。RabbitMQ的集群有两种模式：

•普通集群：是一种分布式集群，将队列分散到集群的各个节点，从而提高整个集群的并发能力。

•镜像集群：是一种主从集群，普通集群的基础上，添加了主从备份功能，提高集群的数据可用性。

镜像集群虽然支持主从，但主从同步并不是强一致的，某些情况下可能有数据丢失的风险。因此在RabbitMQ的3.8版本以后，推出了新的功能：仲裁队列来代替镜像集群，底层采用Raft协议确保主从的数据一致性。

4.2.普通集群

4.2.1.集群结构和特征

普通集群，或者叫标准集群（classic cluster），具备下列特征：

• 会在集群的各个节点间共享部分数据，包括：交换机、队列元信息。不包含队列中的消息。
• 当访问集群某节点时，如果队列不在该节点，会从数据所在节点传递到当前节点并返回
• 队列所在节点宕机，队列中的消息就会丢失

结构如图：

[外链图片转存中…(img-1YOmxqcZ-1667442274221)]

4.3.镜像集群

4.3.1.集群结构和特征

镜像集群：本质是主从模式，具备下面的特征：

• 交换机、队列、队列中的消息会在各个mq的镜像节点之间同步备份。
• 创建队列的节点被称为该队列的主节点，备份到的其它节点叫做该队列的镜像节点。
• 一个队列的主节点可能是另一个队列的镜像节点
• 所有操作都是主节点完成，然后同步给镜像节点
• 主宕机后，镜像节点会替代成新的主

结构如图：

[外链图片转存中…(img-psO1USd4-1667442274221)]

4.4.仲裁队列

4.4.1.集群特征

仲裁队列：仲裁队列是3.8版本以后才有的新功能，用来替代镜像队列，具备下列特征：

• 与镜像队列一样，都是主从模式，支持主从数据同步
• 使用非常简单，没有复杂的配置
• 主从同步基于Raft协议，强一致

4.4.2.Java代码创建仲裁队列

@Bean
public Queue quorumQueue() {
    return QueueBuilder
        .durable("quorum.queue") // 持久化
        .quorum() // 仲裁队列
        .build();
}

4.4.3.SpringAMQP连接MQ集群

注意，这里用address来代替host、port方式

spring:
  rabbitmq:
    addresses: 192.168.150.105:8071, 192.168.150.105:8072, 192.168.150.105:8073
    username: itcast
    password: 123321
    virtual-host: /