微服务间通讯：同步异步对比与消息队列MQ实践-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_42871989/article/details/119705860

1.初识MQ

1.1.同步和异步通讯

微服务间通讯有同步和异步两种方式：

同步通讯：就像打电话，需要实时响应。
异步通讯：就像发邮件，不需要马上回复。

两种方式各有优劣，打电话可以立即得到响应，但是你却不能跟多个人同时通话。发送邮件可以同时与多个人收发邮件，但是往往响应会有延迟。

【1】同步通讯

同步调用的优点：

时效性较强，可以立即得到结果。

同步调用的缺点：

耦合度高 : 每次加入新的需求,都要修改原来的代码。
性能下降 : 调用者需要等待服务提供者响应,如果调用链过长则响应时间等于每次调用的时间之和。
资源浪费 : 调用链中的每个服务在等待响应的过程中,不能释放请求占用的资源,高并发场景下会极度浪费系统资源。
级联失败 : 如果服务提供者出现问题,所有调用方都会跟着出问题。

【2】异步通讯

优点：

吞吐量提升：无需等待订阅者处理完成，响应更快速。
故障隔离：服务没有直接调用，不存在级联失败问题。
调用间没有阻塞，不会造成无效的资源占用。
耦合度极低，每个服务都可以灵活插拔，可替换。
流量削峰：不管发布事件的流量波动多大，都由Broker接收，订阅者可以按照自己的速度去处理事件。

缺点：

架构复杂了，业务没有明显的流程线，不好管理。
需要依赖于Broker的可靠、安全、性能。

1.2.技术对比

MQ，中文是消息队列（MessageQueue），字面来看就是存放消息的队列。也就是事件驱动架构中的Broker。

目前主流的消息队列通信协议标准包括:

AMQP (Advanced Message Queuing Protocol) : 通用协议，IBM公司研发。
JMS (Java Message Service) : 专门为Java语言服务，SUN公司研发，一组由Java接口组成的Java标准。

比较常见的MQ实现：ActiveMQ、RabbitMQ、RocketMQ、Kafka。

几种常见MQ的对比：

	RabbitMQ	ActiveMQ	RocketMQ	Kafka
公司/社区	Rabbit	Apache	阿里	Apache
开发语言	Erlang	Java	Java	Scala&Java
协议支持	AMQP，XMPP，SMTP，STOMP	OpenWire,STOMP，REST,XMPP,AMQP	自定义协议	自定义协议
可用性	高	一般	高	高
单机吞吐量	一般	差	高	非常高
消息延迟	微秒级	毫秒级	毫秒级	毫秒以内
消息可靠性	高	一般	高	一般

追求可用性：Kafka、 RocketMQ 、RabbitMQ。
追求可靠性：RabbitMQ、RocketMQ。
追求吞吐能力：RocketMQ、Kafka。
追求消息低延迟：RabbitMQ、Kafka。

2.快速入门

2.1 RabbitMQ的基本结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5Yn6rGi3-1628945049082)(assets/image-20210717162752376.png)]
RabbitMQ中的一些角色：

publisher：生产者
consumer：消费者
exchange个：交换机，负责消息路由
queue：队列，存储消息
virtualHost：虚拟主机，隔离不同租户的exchange、queue、消息的隔离(相当于不同的database)

2.2 入门案例(了解)

简单队列模式的模型图：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kwilZYe9-1628945049085)(assets/image-20210717163434647.png)]
官方的HelloWorld是基于最基础的消息队列模型来实现的，只包括三个角色：

publisher：消息发布者，将消息发送到队列queue
queue：消息队列，负责接受并缓存消息
consumer：订阅队列，处理队列中的消息

【1】创建工程

包括三部分：

rabbitmq-demo：父工程，管理项目依赖
publisher：消息的发送者
consumer：消息的消费者

1. 创建父工程rabbitmq-demo
引入依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.13</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--AMQP依赖，包含RabbitMQ-->
        <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>
    </dependencies>

创建module: publisher 和 consumer

【2】publisher实现

public class PublisherTest {
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("localhost");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("guest");
        factory.setPassword("guest");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, true, false, false, null);

        // 4.发送消息
        String message = "hello, rabbitmq!";
        channel.basicPublish("", queueName, null, message.getBytes());
        System.out.println("发送消息成功：【" + message + "】");

        // 5.关闭通道和连接
        channel.close();
        connection.close();

    }
}

【3】consumer实现

public class ConsumerTest {

    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("localhost");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("guest");
        factory.setPassword("guest");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, true, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }
}

3. RabbitMQ消息模型

RabbitMQ官方提供了5个不同的Demo示例，对应了不同的消息模型：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fKZAi5XW-1628945049083)(assets/image-20210717163332646.png)]

3.1 SpringAMQP

SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。
SpringAmqp的官方地址：https://spring.io/projects/spring-amqp
AMQP: Advanced Message Queuing Protocol,是用于在应用程序之间传递业务消息的开放标准.该协议与语言和平台无关,更符合微服务中独立性的要求.
Spring AMQP : Spring AMQP是基于AMQP协议定义的一套API规范,提供了模板来发送和接收消息.包含两部分,其中spring-amqp是基础抽象,spring-rabbit是底层的默认实现.

SpringAMQP提供了三个功能：

自动声明队列、交换机及其绑定关系
基于注解的监听器模式，异步接收消息
封装了RabbitTemplate工具，用于发送消息

简单模式和工作队列模式是基于队列的,可以不用设置交换机

3.1.简单模式 (Basic Queue)

一个生产者对应一个消费者
在父工程mq-demo中引入依赖

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

消息发送和消息接收都需要在application.yml中添加配置:

spring:
  rabbitmq:
    host: 127.0.0.1# 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: guest # 用户名
    password: guest# 密码

【1】消息发送

在publisher服务中编写测试类SpringAmqpTest，并利用RabbitTemplate实现消息发送：

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue() {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello, spring amqp!";
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

【2】消息接收

在consumer服务中新建一个类SpringRabbitListener，代码如下：

@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }
}

【3】测试

启动consumer服务，然后在publisher服务中运行测试代码，发送MQ消息

3.2.工作队列模式(WorkQueue)

Work queues，也被称为（Task queues），任务模型。简单来说就是让多个消费者绑定到一个队列，共同消费队列中的消息。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fv3wsR1h-1628945049086)(assets/image-20210717164238910.png)]
当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。
此时就可以使用work 模型，多个消费者共同处理消息处理，速度就能大大提高了。

【1】消息发送

这次我们循环发送，模拟大量消息堆积现象。
在publisher服务中的SpringAmqpTest类中添加一个测试方法：

@Test
public void testWorkQueue(){
    // 队列名称
    String queueName = "work.queue";
    // 消息
    String message = "hello, message_";
    // 向队列中不停发送消息，模拟消息堆积
    for (int i = 0; i < 50; i++) {
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message + i);
        Thread.sleep(20);
    }
}

【2】消息接收

要模拟多个消费者绑定同一个队列，我们在consumer服务的SpringRabbitListener中添加2个新的方法：

@RabbitListener(queues = "work.queue")
public void listenWorkQueue1(String msg) throws InterruptedException {
    System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
}

@RabbitListener(queues = "work.queue")
public void listenWorkQueue2(String msg) throws {
    System.err.println("消费者2接收到消息：【" + msg + "】" + LocalTime.now());
}

【3】测试

启动ConsumerApplication后，在执行publisher服务中刚刚编写的发送测试方法testWorkQueue。
可以看到消费者1很快完成了自己的25条消息。消费者2却在缓慢的处理自己的25条消息。
也就是说消息是平均分配给每个消费者，并没有考虑到消费者的处理能力。这样显然是有问题的。

【4】能者多劳

在spring中有一个简单的配置，可以解决这个问题。我们修改consumer服务的application.yml文件，添加配置：

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息

【5】总结

Work模型的使用：

多个消费者绑定到一个队列，同一条消息只会被一个消费者处理。
同一条消息只会被一个消费者处理(默认轮询)。
通过设置prefetch来控制消费者预取的消息数量。

3.3.发布/订阅模式

发布订阅的模型如图：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bf2bV58G-1628945049087)(assets/image-20210717165309625.png)]
可以看到，在订阅模型中，多了一个exchange角色，而且过程略有变化：

Publisher：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有以下3种类型：
- Fanout：广播，将消息交给所有绑定到交换机的队列
- Direct：定向，把消息交给符合指定routing key 的队列
- Topic：通配符，把消息交给符合routing pattern（路由模式）的队列
Consumer：消费者，与以前一样，订阅队列，没有变化
Queue：消息队列也与以前一样，接收消息、缓存消息。

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

3.4 Fanout 交换机(广播模式)

Fanout Exchange 会将接收到的消息路由到每一个跟其绑定的queue，所以也叫广播模式。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f6UBqDPO-1628945049088)(assets/image-20210717165438225.png)]
在广播模式下，消息发送流程是这样的：

1）可以有多个队列
2）每个队列都要绑定到Exchange（交换机）
3）生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定
4）交换机把消息发送给绑定过的所有队列
5）订阅队列的消费者都能拿到消息

【1】声明队列和交换机

Spring提供了一个接口Exchange，来表示所有不同类型的交换机：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OvEcamqu-1628945049089)(assets/image-20210717165552676.png)]
在consumer中创建一个类，声明队列和交换机：

@Configuration
public class FanoutConfig {
    /**
     * 声明交换机
     * @return Fanout类型交换机
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("exchange.fanout");
    }

    /**
     * 第1个队列
     */
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }

    /**
     * 第2个队列
     */
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
}

【2】消息发送

在publisher服务的SpringAmqpTest类中添加测试方法：

@Test
public void testFanoutExchange() {
    // 队列名称
    String exchangeName = "exchange.fanout";
    // 消息
    String message = "hello, everyone!";
    rabbitTemplate.convertAndSend(exchangeName, "", message);
}

【3】消息接收

在consumer服务的SpringRabbitListener中添加两个方法，作为消费者：

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

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

【4】总结

交换机的作用是什么？

接收publisher发送的消息
将消息按照规则路由到与之绑定的队列
不能缓存消息，路由失败，消息丢失
FanoutExchange的会将消息路由到每个绑定的队列

声明队列、交换机、绑定关系的Bean是什么？

Queue
FanoutExchange
Binding

3.5 Direct 交换机 (路由模式)[此模式使用最多]

在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6DjjoOzb-1628945049090)(assets/image-20210717170041447.png)]
在Direct模型下：

队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
消息的发送方在向 Exchange发送消息时，也必须指定消息的 RoutingKey。
Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

【1】基于注解声明队列和交换机

基于@Bean的方式声明队列和交换机比较麻烦，Spring还提供了基于注解方式来声明。
在consumer的SpringRabbitListener中添加两个消费者，同时基于注解来声明队列和交换机：

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue1"),
    exchange = @Exchange(name = "exchange.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "blue"}
))
public void listenDirectQueue1(String msg){
    System.out.println("消费者接收到direct.queue1的消息：【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue2"),
    exchange = @Exchange(name = "exchange.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "yellow"}
))
public void listenDirectQueue2(String msg){
    System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
}

【2】消息发送

在publisher服务的SpringAmqpTest类中添加测试方法：

@Test
public void testSendDirectExchange() {
    // 交换机名称
    String exchangeName = "exchange.direct";
    // 消息
    String message = "红色警报！日本乱排核废水，导致海洋生物变异，惊现哥斯拉！";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "red", message);
}

【3】总结

描述下Direct交换机与Fanout交换机的差异？

Fanout交换机将消息路由给每一个与之绑定的队列
Direct交换机根据RoutingKey判断路由给哪个队列
如果多个队列具有相同的RoutingKey，则与Fanout功能类似

基于@RabbitListener注解声明队列和交换机有哪些常见注解？

@Queue
@Exchange

3.6 Topic 交换机 (通配符模式)

【1】说明

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！
Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：
#：匹配一个或多个词
*：匹配不多不少恰好1个词

举例：
china.#：能够匹配china.spu.insert 或者 china.spu
china.*：只能匹配china.spu

图示：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VYG9RO5X-1628945049091)(assets/image-20210717170705380.png)]
解释：

Queue1：绑定的是china.# ，因此凡是以 china.开头的routing key 都会被匹配到。包括china.news和china.weather
Queue2：绑定的是#.news ，因此凡是以 .news结尾的 routing key 都会被匹配。包括china.news和japan.news

【2】消息发送

在publisher服务的SpringAmqpTest类中添加测试方法：

/**
     * topicExchange
     */
@Test
public void testSendTopicExchange() {
    // 交换机名称
    String exchangeName = "exchange.topic";
    // 消息
    String message = "喜报！孙悟空大战哥斯拉，胜!";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "china.news", message);
}

【3】消息接收

在consumer服务的SpringRabbitListener中添加方法：

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue1"),
    exchange = @Exchange(name = "exchange.topic", type = ExchangeTypes.TOPIC),
    key = "china.#"
))
public void listenTopicQueue1(String msg){
    System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue2"),
    exchange = @Exchange(name = "exchange.topic", type = ExchangeTypes.TOPIC),
    key = "#.news"
))
public void listenTopicQueue2(String msg){
    System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
}

【4】总结

描述下Direct交换机与Topic交换机的差异？

Topic交换机接收的消息RoutingKey必须是多个单词，以 **.** 分割
Topic交换机与队列绑定时的bindingKey可以指定通配符
#：代表0个或多个词
*：代表1个词

3.7 声明队列和交换机

【1】基于Java Bean方式声明

@Configuration
public class FanoutConfig {
    /**
     * 声明交换机
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("exchange.fanout");
    }

    /**
     * 声明队列
     */
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }
}
// 如果有其他的,按照上述方法继续绑定....

【2】基于注解方式声明

基于@Bean的方式声明队列和交换机比较麻烦，Spring还提供了基于注解方式来声明。

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name = "exchange.direct", type = ExchangeTypes.DIRECT),
            key = {"red", "yellow"}
    ))
    public void listenDirectQueue2(String msg){
        System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
    }

3.8 消息转换器

之前说过，Spring会把你发送的消息序列化为字节发送给MQ，接收消息的时候，还会把字节反序列化为Java对象。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ub5uDYnm-1628945049092)(assets/image-20200525170410401.png)]
只不过，默认情况下Spring采用的序列化方式是JDK序列化。众所周知，JDK序列化存在下列问题：

数据体积过大
有安全漏洞
可读性差
配置JSON转换器
在publisher和consumer两个服务中都引入依赖：

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

配置消息转换器。
publisher和consumer两个服务都添加添加RabbitMq配置类

@Component
public class MessageConvertConfig {
    @Bean
    public MessageConverter messageConverter(){
        // 1.定义消息转换器
        Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();
        // 2.配置自动创建消息id，用于识别不同消息，也可以在业务中基于ID判断是否是重复消息
        jackson2JsonMessageConverter.setCreateMessageIds(true);
        return jackson2JsonMessageConverter;
    }
}

4. 生产者的可靠性

4.1 生产者的消息确认机制

RabbitMQ提供了生产者消息确认机制，包括 Confirm 和 Return 两种。在开启确认机制的情况下，当生产者发送消息给MQ后，MQ会根据消息处理的情况返回不同的回执。

其中ack和nack属于Publisher Confirm机制，ack是投递成功；nack是投递失败。而return则属于Publisher Return机制。默认两种机制都是关闭状态，需要通过配置文件来开启。

方法名	方法功能	所属接口	接口所属类
confirm()	确认消息是否发送到交换机	ConfirmCallback	RabbitTemplate
returnedMessage()	确认消息是否发送到队列	ReturnsCallback	RabbitTemplate

【1】API说明

① ConfirmCallback接口

	@FunctionalInterface
	public interface ConfirmCallback {
		void confirm(@Nullable CorrelationData correlationData, boolean ack, @Nullable String cause);
	}

生产者端发送消息之后，回调confirm()方法

ack参数值为true：表示消息成功发送到了交换机。
ack参数值为false：表示消息没有发送到交换机。
② ReturnCallback接口

	@FunctionalInterface
	public interface ReturnsCallback extends ReturnCallback {
		@Override
		void returnedMessage(ReturnedMessage returned);
		};

注意：接口中的returnedMessage()方法仅在消息没有发送到队列时调用。

ReturnedMessage类中主要属性含义如下：

属性名	类型	含义
message	org.springframework.amqp.core.Message	消息以及消息相关数据
replyCode	int	应答码，类似于HTTP响应状态码
replyText	String	应答码说明
exchange	String	交换机名称
routingKey	String	路由键名称

【2】开启消息确认机制

spring:
  rabbitmq:
    host: localhost # rabbitMQ的ip地址
    port: 5672 # 端口
    username: guest
    password: guest
    virtual-host: /
    publisher-confirm-type: correlated # # 交换机的确认
    publisher-returns: true # 队列的确认

这里publisher-confirm-type有三种模式可选：

none：关闭confirm机制(默认)。
simple：同步阻塞等待MQ的回执。
correlated：MQ异步回调返回回执(推荐)。

【3】代码定义

每个RabbitTemplate只能配置一个ReturnCallback，因此我们可以在配置类中统一设置。我们在publisher模块定义一个配置类：

@Configuration
@Slf4j
public class RabbitMqConfig {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init(){
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (ack) {
                    log.info("消息发送到交换机成功！数据：" + correlationData);
                } else {
                    log.info("消息发送到交换机失败！数据：" + correlationData + " 原因：" + cause);
                }
            }
        });

        // 只有发送队列失败的时候才会触发
        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            @Override
            public void returnedMessage(ReturnedMessage returned) {
                log.error("触发return callback");
                log.info("消息主体: {}" ,new String(returned.getMessage().getBody()));
                log.info("应答码: {}" ,returned.getReplyCode());
                log.info("描述：{}" , returned.getReplyText());
                log.info("消息使用的交换器 exchange : {}" , returned.getExchange());
                log.info("消息使用的路由键 routing : {}" , returned.getRoutingKey());
            }
        });
    }
}

由于每个消息发送时的处理逻辑不一定相同，因此ConfirmCallback需要在每次发消息时定义。具体来说，是在调用RabbitTemplate中的convertAndSend方法时，多传递一个参数：
在这里插入图片描述
这里的CorrelationData中包含两个核心的东西：

id：消息的唯一标示，MQ对不同的消息的回执以此做判断，避免混淆。
SettableListenableFuture：回执结果的Future对象。

【4】测试

通过调整代码，测试如下三种情况：

交换机正确、路由键正确。
交换机正确、路由键不正确，无法发送到队列。
交换机不正确，无法发送到交换机。

@SpringBootTest
public class PublisherConfirmTest {

    public static final String EXCHANGE_NAME = "exchange.direct.20241119.order";
    public static final String QUEUE_NAME = "queue.order";
    public static final String ROUTING_KEY = "order";

    @Autowired
    private RabbitTemplate rabbitTemplate;

    // 交换机不正确，无法发送到交换机
    @Test
    public void test() {
        rabbitTemplate.convertAndSend(EXCHANGE_NAME + "~", ROUTING_KEY, "生产者消息确认消息" );
    }

    // 交换机正确、路由键不正确，无法发送到队列
    @Test
    public void test1() {
        rabbitTemplate.convertAndSend(EXCHANGE_NAME, ROUTING_KEY  + "~", "生产者消息确认消息" );
    }

    // 交换机正确、路由键正确
    @Test
    public void test2() {
        rabbitTemplate.convertAndSend(EXCHANGE_NAME, ROUTING_KEY , "生产者消息确认消息" );
    }
}

4.2 生产者重连

首先第一种情况，就是生产者发送消息时，出现了网络故障，导致与MQ的连接中断。

为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。(默认情况下是不会重连的。)

修改生产者publisher模块的application.yml文件，添加下面的内容：

spring:
  rabbitmq:
    connection-timeout: 1s # 设置MQ的连接超时时间
    template:
      retry:
        enabled: true # 开启超时重试机制
        initial-interval: 1000ms # 失败后的初始等待时间
        multiplier: 1 # 失败后下次的等待时长倍数，下次等待时长 = initial-interval * multiplier
        max-attempts: 3 # 最大重试次数

5. MQ的可靠性

在默认情况下，RabbitMQ会将接收到的信息保存在内存中以降低消息收发的延迟。这样会导致两个问题:

一旦MO宕机，内存中的消息会丢失。
内存空间有限，当消费者故障或处理过慢时，会导致消息积压，引发MQ阻塞。

【1】数据持久化

为了提升性能，默认情况下MQ的数据都是在内存存储的临时数据，重启后就会消失。为了保证数据的可靠性，必须配置数据持久化，包括：

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

【2】Lazy Queue

为了解决这个问题，从RabbitMQ的3.6.0版本开始，就增加了Lazy Queues的模式，也就是惰性队列。惰性队列的特征如下：

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

而在3.12版本之后，LazyQueue已经成为所有队列的默认格式，而且无法更改。因此官方推荐升级MQ为3.12版本或者所有队列都设置为LazyQueue模式。

旧版本配置:
方式一:

@Bean
public Queue lazyQueue(){
    return QueueBuilder
            .durable("lazy.queue")
            .lazy() // 开启Lazy模式
            .build();
}

方式二:

@RabbitListener(queuesToDeclare = @Queue(
        name = "lazy.queue",
        durable = "true",
        arguments = @Argument(name = "x-queue-mode", value = "lazy")
))
public void listenLazyQueue(String msg){
    log.info("接收到 lazy.queue的消息：{}", msg);
}

6. 消费者的可靠性

为了确认消费者是否成功处理消息，RabbitMQ提供了消费者确认机制（Consumer Acknowledgement）。即：当消费者处理消息结束后，应该向RabbitMQ发送一个回执，告知RabbitMQ自己消息处理状态。回执有三种可选值：

ack：成功处理消息，RabbitMQ从队列中删除该消息。
nack：消息处理失败，RabbitMQ需要再次投递消息。
reject：消息处理失败并拒绝该消息，RabbitMQ从队列中删除该消息。

由于消息回执的处理代码比较统一，因此SpringAMQP帮我们实现了消息确认。并允许我们通过配置文件设置ACK处理方式，有三种模式：

none：不处理。即消息投递给消费者后立刻ack，消息会立刻从MQ删除。非常不安全，不建议使用。
manual：手动模式。需要自己在业务代码中调用api，发送ack或reject，存在业务入侵，但更灵活。
auto：自动模式。SpringAMQP利用AOP对我们的消息处理逻辑做了环绕增强，当业务正常执行时则自动返回ack. 当业务出现异常时，根据异常判断返回不同结果：
- 如果是业务异常，会自动返回nack。
- 如果是消息处理或校验异常，自动返回reject。

6.1 消费者的手动确认机制

① basicAck()方法

方法功能：给Broker返回ACK确认信息，表示消息已经在消费端成功消费，这样Broker就可以把消息删除了。
参数列表：

参数名称	含义
long deliveryTag	Broker给每一条进入队列的消息都设定一个唯一标识
boolean multiple	取值为true：为小于、等于deliveryTag的消息批量返回ACK信息取值为false：仅为指定的deliveryTag返回ACK信息

② basicNack()方法

方法功能：给Broker返回NACK信息，表示消息在消费端消费失败，此时Broker的后续操作取决于参数requeue的值。
参数列表：

参数名称	含义
long deliveryTag	Broker给每一条进入队列的消息都设定一个唯一标识
boolean multiple	取值为true：为小于、等于deliveryTag的消息批量返回ACK信息取值为false：仅为指定的deliveryTag返回ACK信息
boolean requeue	取值为true：Broker将消息重新放回队列，接下来会重新投递给消费端取值为false：Broker将消息标记为已消费，不会放回队列

spring:
  rabbitmq:
    host: localhost # rabbitMQ的ip地址
    port: 5672 # 端口
    username: guest
    password: guest
    virtual-host: /
    listener:
      simple:
        acknowledge-mode: manual # manual 手动确认, auto 自动确认

@Slf4j
@Component
public class ConsumerManualConfirmListener {
    public static final String EXCHANGE_NAME = "exchange.direct.20241119.order";
    public static final String QUEUE_NAME = "queue.order";
    public static final String ROUTING_KEY = "order";

    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(value = QUEUE_NAME, durable = "true", autoDelete = "false"),
                    exchange = @Exchange(value = EXCHANGE_NAME, durable = "true", autoDelete = "false"),
                    key = {ROUTING_KEY}))
    public void consumerConfirmListenerMessage(String dataString, Message message, Channel channel) throws IOException {
        // 获取当前消息的 deliveryTag
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            // 正常业务操作
            log.info("消费端接收到消息内容：" + dataString);

             System.out.println(10 / 0);

            // 给 RabbitMQ 服务器返回 ACK 确认信息
            channel.basicAck(deliveryTag, false);
        } catch (Exception e) {
            log.info("消费端消费异常");
            // 获取信息，看当前消息是否曾经被投递过
            Boolean redelivered = message.getMessageProperties().getRedelivered();

            if (!redelivered) {
                log.info("消息之前没有重新投递过,本次重新投递队列");
                // 如果没有被投递过，那就重新放回队列，重新投递，再试一次
                channel.basicNack(deliveryTag, false, true);
            } else {
                log.info("消息之前重新投递过,本次不再重新投递队列");
                // 如果已经被投递过，且这一次仍然进入了 catch 块，那么返回拒绝且不再放回队列
                channel.basicNack(deliveryTag, false, false);
            }
        }
    }
}

6.2 消费者的自动确认机制

当消费者出现异常后，消息会不断requeue（重入队）到队列，再重新发送给消费者。如果消费者再次执行依然出错，消息会再次requeue到队列，再次投递，直到消息处理成功为止。
极端情况就是消费者一直无法执行成功，那么消息requeue就会无限循环，导致mq的消息处理飙升，带来不必要的压力。

为了应对上述情况Spring又提供了消费者失败重试机制：在消费者出现异常时利用本地重试，而不是无限制的requeue到mq队列。

在消费者consumer中配置:

server:
  port: 9001
logging:
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS
spring:
  rabbitmq:
    host: localhost # rabbitMQ的ip地址
    port: 5672 # 端口
    username: guest
    password: guest
    virtual-host: /
    listener:
      simple:
        prefetch: 1  # 每次只能获取一条消息，处理完成才能获取下一个消息
        acknowledge-mode: auto  # manual 手动确认, auto 自动确认
        retry:
          enabled: true # 开启消费者失败重试
          initial-interval: 1000ms # 初识的失败等待时长为1秒
          multiplier: 1 # 失败的等待时长倍数，下次等待时长 = multiplier * last-interval
          max-attempts: 3 # 最大重试次数
          stateless: true # true无状态；false有状态。如果业务中包含事务，这里改为false

因此Spring允许我们自定义重试次数耗尽后的消息处理策略，这个策略是由MessageRecovery接口来定义的，它有3个不同实现：

RejectAndDontRequeueRecoverer：重试耗尽后，直接reject，丢弃消息。默认就是这种方式。 (默认)
ImmediateRequeueMessageRecoverer：重试耗尽后，返回nack，消息重新入队。
RepublishMessageRecoverer：重试耗尽后，将失败消息投递到指定的交换机。 (推荐)

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

例如:
在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");
}

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

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

3.9 高级

3.9.1 发送者的可靠性

3.9.3 消费者的可靠性

【2】失败重试策略

【3】业务幂等性

在程序开发中，指同一个业务，执行一次或多次对业务状态的影响是一致的。
在这里插入图片描述
因此，我们必须想办法保证消息处理的幂等性。这里给出两种方案：

唯一消息ID
业务状态判断

唯一消息ID
① 每一条消息都生成一个唯一的id，与消息一起投递给消费者。
② 消费者接收到消息后处理自己的业务，业务处理成功后将消息ID保存到数据库。
③ 如果下次又收到相同消息，去数据库查询判断是否存在，存在则为重复消息放弃处理。

    @Bean
    public MessageConverter messageConverter(){
        // 1.定义消息转换器
        Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();
        // 2.配置自动创建消息id，用于识别不同消息，也可以在业务中基于ID判断是否是重复消息
        jackson2JsonMessageConverter.setCreateMessageIds(true);
        return jackson2JsonMessageConverter;
    }

业务判断
业务判断就是基于业务本身的逻辑或状态来判断是否是重复的请求或消息，不同的业务场景判断的思路也不一样。

3.9.4 延迟消息

延迟消息:发送者发送消息时指定一个时间，消费者不会立刻收到消息，而是在指定时间之后才收到消息。

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

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

如果一个队列中的消息已经成为死信，并且这个队列通过dead-letter-exchange属性指定了一个交换机，那么队列中的死信就会投递到这个交换机中，而这个交换机就称为死信交换机死信交换机（Dead Letter Exchange）。而此时加入有队列与死信交换机绑定，则最终死信就会被投递到这个队列中。

例如:
1. 消费者:定义普通的队列并绑定死信交换机。

@Configuration
public class DeadLetterConfig {
    /**
     * 声明交换机
     */
    @Bean
    public DirectExchange normalExchange(){
        return new DirectExchange("normal.direct");
    }

    /**
     * 声明队列
     */
    @Bean
    public Queue normalQueue(){
        return QueueBuilder.durable("normal.queue").deadLetterExchange("dlx.direct").build();
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue(Queue normal, DirectExchange normalExchange){
        return BindingBuilder.bind(normal).to(normalExchange).with("hi");
    }
}

2. 消费者: 定义死信交换机,消费死信消息。

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "dlx.queue", durable = "true"),
            exchange = @Exchange(name = "dlx.direct"),
            key = "hi"
    ))
    public void listenPaySuccess(String message){
        log.info("===消费者DeadLetterRabbitListener监听到消息:{}", message);
    }

3. 生产者: 发送消息。

    @GetMapping("/delayPushMessage")
    public Map<String, String> delayPushMessage(@RequestParam("msg") String msg){
        rabbitTemplate.convertAndSend("normal.direct", "hi", msg, new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setExpiration("10000");
                return message;
            }
        });
        return new HashMap<>();
    }