第九章 RabbitMQ消息可靠性之生产者

王哲晓 tiger

于 2024-10-11 10:20:56 发布

阅读量629

点赞数 16

分类专栏： RabbitMQ 文章标签： rabbitmq 分布式

本文链接：https://blog.csdn.net/qushaming/article/details/142828630

版权

RabbitMQ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、引言

我们在实际项目过程中使用RabbitMQ消息队列时，需要充分意识到存在的消息可靠性问题。如下图所示，在电商项目中用户支付后发起消息请求修改订单，就会存在多种消息可靠性不受保障的情况：

用户支付成功，即调用支付服务接口付款成功后，给RabbitMQ发送消息请求修改订单状态为已支付，RabbitMQ接收到消息再去通知交易服务更新订单状态。这个过程中有3处节点会发生消息可靠性问题：

1. RabbitMQ和支付服务（生产者）的通信过程中出现网络故障。

2. RabbitMQ在接收到消息后，消息未发送给交易服务（消费者）前宕机。

3. 交易服务（消费者）在接收到消息后，在处理过程中发生代码异常或者服务宕机。

以上情况就会导致我们的支付服务在通过RabbitMQ调用交易服务时导致失败，这对于企业来说是致命的，因此我们需要通过一些策略来解决使用RabbitMQ过程中存在的可靠性问题。

总结消息的可靠性问题归为以下三类：

1. 生产者可靠性

2. MQ可靠性

3. 消费者可靠性

二、如何解决生产者可靠性

生产者的可靠性涉及到生产者重连以及生产者确认机制两个方面，下面我们通过配置以及代码来讲解演示这两个方面的问题如何解决：

2.1. 生产者重连

有的时候由于网络波动，可能会出现发送者连接MQ失败的情况，这时候我们可能会希望有尝试重连的机制。在Spring AMQP中，通过配置我们可以开启连接失败后的重连机制：

2.1.1. 生产者重连配置

spring:
  rabbitmq:
    # MQ连接配置
    host: 127.0.0.1
    port: 5672
    username: Wangzhexiao
    password: Wangzhexiao
    virtual-host: /hangzhou
    # 生产者重连配置
    connection-timeout: 1s # 设置MQ的连接超时时间
    template:
      retry:
        enabled: true # 开启超时重试机制
        initial-interval: 1000ms # 失败后的初始等待时间
        multiplier: 1 # 失败后下次的等待时长倍数，下次等待时长 = initial-interval * multiplier
        max-attempts: 3 # 最大重试次数

2.1.2. 开启生产者重连效果

我们停止RabbitMQ的服务，然后启动生产者，查看控制台的日志输出，就可以看到重试机制生效了：

注：当网络不稳定的时候，利用重试机制可以有效提高消息发送的成功率。不过SpringAMQP提供的重试机制是阻塞式的重试，也就是说多次重试等待的过程中，当前线程是被阻塞的，会影响业务性能。如果对于业务性能有要求，建议禁用重试机制。如果一定要使用，请合理配置等待时长和重试次数，当然也可以考虑使用异步线程来执行发送消息的代码。

2.2. 生产者确认

SpringAMQP提供了Publisher Confirm和Publisher Return两种确认机制，来确保消息从生产者发送到RabbitMQ的过程中没有丢失，并且可以处理消息无法投递到目的队列时的情况。开启确机制认后，当生产者发送消息给MQ后，MQ会返回确认结果给生产者。返回的结果有以下几种情况：

1. 消息投递到了MQ，但是路由失败。此时会通过PublisherReturn返回路由异常原因，然后返回ACK，告知投递成功。

2. 临时消息投递到了MQ，并且入队成功，返回ACK，通过Publisher Confirm告知投递成功

3. 持久消息投递到了MQ，并且入队完成持久化，返回ACK ，通过Publisher Confirm告知投递成功

4. 其它情况都会返回NACK，通过Publisher Confirm告知投递失败

2.2.1. 生产者确认配置

spring:
  rabbitmq:
    # MQ连接配置
    host: 127.0.0.1
    port: 5672
    username: Wangzhexiao
    password: Wangzhexiao
    virtual-host: /hangzhou
    # 生产者重连配置
    connection-timeout: 1s # 设置MQ的连接超时时间
    template:
      retry:
        enabled: true # 开启超时重试机制
        initial-interval: 1000ms # 失败后的初始等待时间
        multiplier: 1 # 失败后下次的等待时长倍数，下次等待时长 = initial-interval * multiplier
        max-attempts: 3 # 最大重试次数
    # 生产者确认配置
    publisher-confirm-type: correlated # 开启publisher confirm机制，并设置confirm类型
    publisher-returns: true # 开启publisher return机制

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

none：关闭confirm机制
simple：同步阻塞等待MQ的回执消息
correlated：MQ异步回调方式返回回执消息

注：通常我们会选择correlated这种模式，比较符合实际项目中的需求。

publisher-returns

注：return是在路由失败时返回，大多数情况下路由失败是由开发人员自己导致的，所以一般情况下我们会设置为false来关闭路由失败回执，如若开启后需按下述方式配置实现路由失败回执生产者消息确认机制

2.2.2. 生产者确认代码实现

每个RabbitTemplate只能配置一个ReturnCallback，我们统一在一个配置类中对ReturnCallback和ConfirmCallback配置：

package com.example.publisher;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class SendReturnCallback implements RabbitTemplate.ReturnsCallback {

    @Override
    public void returnedMessage(ReturnedMessage msg) {
        log.error("message fail:{}, 从交换机exchange:{}, 以路由键routingKey:{}, 未匹配到队列, replyCode:{},replyText:{}",
                msg.getMessage(), msg.getExchange(), msg.getRoutingKey(), msg.getReplyCode(), msg.getReplyText());
    }
}

package com.example.publisher;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class SendConfirmCallback implements RabbitTemplate.ConfirmCallback {
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if (!ack) {
            log.info("消息发送到交换机失败,cause:{}",cause);
        }
        log.info("消息成功发送到交换机，correlationData:{}", correlationData);
    }
}

package com.example.publisher;

import jakarta.annotation.PostConstruct;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Slf4j
@AllArgsConstructor
@Configuration
public class MQConfig {
//    private final RabbitTemplate rabbitTemplate;
//
//    @PostConstruct
//    public void init(){
//        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
//            @Override
//            public void returnedMessage(ReturnedMessage returned) {
//                log.error("触发return callback,");
//                log.debug("exchange: {}", returned.getExchange());
//                log.debug("routingKey: {}", returned.getRoutingKey());
//                log.debug("message: {}", returned.getMessage());
//                log.debug("replyCode: {}", returned.getReplyCode());
//                log.debug("replyText: {}", returned.getReplyText());
//            }
//        });
//    }

    @Bean
    RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnsCallback(new SendReturnCallback());
        rabbitTemplate.setConfirmCallback(new SendConfirmCallback());
        return rabbitTemplate;
    }
}

package com.example.publisher;

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.util.concurrent.ListenableFutureCallback;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

@Slf4j
@SpringBootTest
class PublisherApplicationTests {

    @Resource
    private RabbitTemplate rabbitTemplate;

//    @Autowired
//    public PublisherApplicationTests(RabbitTemplate rabbitTemplate) {
//        this.rabbitTemplate = rabbitTemplate;
//        // 确保消息发送到RabbitMQ后，会收到一个回调，表明消息是否成功送达
//        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
//            if (ack) {
//                System.out.println("消息成功送达");
//            } else {
//                System.out.println("消息未送达, 原因: " + cause);
//            }
//        });
//    }

//    public void sendMessage(String message) {
//        rabbitTemplate.convertAndSend("exchangeName", "routingKey", message);
//    }

    @Test
    void sendMessage() throws InterruptedException {
        String exchangeName = "wzx.topic";
        Map<String,Object> msg = new HashMap<>(2);
        msg.put("name", "wangzhexiao");
        msg.put("motto", "只要学不死，就往死里学！");
        rabbitTemplate.convertAndSend(exchangeName,"china.news", msg, new CorrelationData());
    }


}

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>publisher</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>publisher</name>
    <description>publisher</description>
    <url/>
    <licenses>
        <license/>
    </licenses>
    <developers>
        <developer/>
    </developers>
    <scm>
        <connection/>
        <developerConnection/>
        <tag/>
        <url/>
    </scm>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2.2.3. 运行效果

生产者消息投递成功后，Publisher Confirm机制返回的结果：

我们可以设置错误/不存在的交换机名或者路由key（routingKey），生产者消息投递后，Publisher Return机制返回的结果：

至此，我们就完成了对生产者消息可靠性的实现！

2.2.4. 其他代码实现方式

上述方式是配置Publisher Confirm和Publisher Return的主流推荐方式，实际代码中我们还可以尝试其他多种写法，如下代码所示，大家做个了解即可：

package com.example.publisher;

import jakarta.annotation.PostConstruct;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Slf4j
@AllArgsConstructor
@Configuration
public class MQConfig {
    private final RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void initReturnsCallback(){
        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            @Override
            public void returnedMessage(ReturnedMessage returned) {
                log.error("触发return callback,");
                log.debug("exchange: {}", returned.getExchange());
                log.debug("routingKey: {}", returned.getRoutingKey());
                log.debug("message: {}", returned.getMessage());
                log.debug("replyCode: {}", returned.getReplyCode());
                log.debug("replyText: {}", returned.getReplyText());
            }
        });
    }

    @PostConstruct
    public void initConfirmCallback(){
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (!ack) {
                    log.info("消息发送到交换机失败,cause:{}",cause);
                }
                log.info("消息成功发送到交换机，correlationData:{}", correlationData);
            }
        });
    }
}

package com.example.publisher;

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 = applicationContext.getBean(RabbitTemplate.class);
        rabbitTemplate.setReturnsCallback((returnedMessage -> {
            log.info("消息发送失败，应答码{},原因{},交换机{},路由键{},消息{}",
                    returnedMessage.getReplyCode(),returnedMessage.getReplyText(),
                    returnedMessage.getExchange(),returnedMessage.getRoutingKey(),returnedMessage.getMessage());
        }));
    }
}

package com.example.publisher;

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.util.concurrent.ListenableFutureCallback;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

@Slf4j
@SpringBootTest
class PublisherApplicationTests {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Autowired
    public PublisherApplicationTests(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
        // 确保消息发送到RabbitMQ后，会收到一个回调，表明消息是否成功送达
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            if (ack) {
                System.out.println("消息成功送达");
            } else {
                System.out.println("消息未送达, 原因: " + cause);
            }
        });
    }

    @Test
    void sendMessage() throws InterruptedException {
        String exchangeName = "wzx.topic";
        Map<String,Object> msg = new HashMap<>(2);
        msg.put("name", "wangzhexiao");
        msg.put("motto", "只要学不死，就往死里学！");
        rabbitTemplate.convertAndSend(exchangeName,"china.news", msg, new CorrelationData());
    }
}