1. 引言
我们知道，RabbmitMQ实现的是一种异步通信方式，而RabbmitMQ是通过 网络 与生产者和消费者建立联系的。在网络传输的时候，就很容易出现消息丢失的情况。除此之外，我们还要考虑RabbmitMQ本身的宕机导致数据丢失的问题。
这就是我们需要考虑的 消息可靠性 问题。
那么，具体来说，在RabbitMQ处理信息的流程中，可能在哪些环节出现问题呢？
- 问题1 - 如图例①：生产者发送的消息未送达exchange
- 问题2 - 如图例②：消息到达exchange后未到达queue
- 问题3 - MQ宕机，queue将消息丢失
- 问题4 - 如图例③：consumer接收到消息后未消费就宕机
针对这些问题，RabbitMQ分别给出了解决方案：
- 生产者发送确认机制（解决问题1和问题2）
- MQ消息持久化（解决问题3）
- 消费者消费确认机制（解决问题4）
- 失败重试机制（解决问题4）
我们接下来就具体地讲述以下这四种解决方案
2. 生产者消息确认
RabbitMQ提供了生产者消息确认机制来避免消息发送到MQ过程中丢失。这种机制必须给每个消息指定一个唯一ID。消息发送到MQ以后，会返回一个结果给发送者，表示消息是否处理成功。
返回结果有两种方式：
publisher-confirm（发送者确认）- 消息成功投递到交换机，返回 ack
- 消息未投递到交换机，返回 nack
publisher-return（发送者回执）- 消息投递到交换机了，但是没有路由到队列。返回ACK，及路由失败原因。
确认机制发送消息时，需要给每个消息设置一个全局唯一id，以区分不同消息，避免ack冲突
总结来说，publisher-confirm用来确认消息是否发给了交换机，publisher-return用来确认消息是否发给了队列。
接下来，我们具体说明一下如何实现
2.1. 配置文件
首先，修改publisher服务中的application.yml文件，添加下面的内容：
spring:
rabbitmq:
host: MQ的具体IP
port: 5672
virtual-host: /
username: mq用户名
password: mq密码
# 开启publisher-confirm功能，开启异步回调
publisher-confirm-type: correlated
# 开启publish-return功能
publisher-returns: true
template:
# 路由失败策略：调用回调方法
mandatory: true说明：
-
publish-confirm-type：发送者消息确认类型，支持种类型：
- none：禁用消息确认，默认值
- correlated：异步回调，需要定义回调函数ConfirmCallback，MQ返回结果时会调用这个回调函数。
- simple：同步等待confirm结果，直到超时，结果回来也会调用回调函数ConfirmCallback。
-
publish-returns：开启发动者回执功能，需要定义回调函数ReturnCallback
-
template.mandatory：定义消息路由失败时的策略。为true则调用ReturnCallback，为false则直接丢弃消息
2.2. 是否发到交换机
开启publisher-confirm选项后，我们通过定义ConfirmCallback来 确认消息是否发到了交换机 。
因为每个业务处理confirm成功或失败的逻辑不一定相同，所以逻辑应该写在具体需要发送消息的代码中。
下面是一个简单的案例：
// ↑ 其他业务代码
// 1.消息体
String message = "这是一条消息";
// 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("交换机名字", "具体的bindingKey", message, correlationData);
// ↓ 其他业务代码2.3. 是否到达指定队列
开启publisher-returns选项后，我们通过定义ReturnCallback来 确认消息是否发到了指定队列 。
需要注意的是，不同于ConfirmCallback，每个RabbitTemplate 只能配置一个 ReturnCallback，所以我们需要在生产者端添加如下文件：
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
@Configuratio
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());
// TODO:如果有业务需要，可以重发消息
................
});
}
}3. MQ消息持久化
注意！！！！
当我们使用SpringAMQP创建队列、交换机和消息的时候，它们默认都是持久化的！
本章节只是展开描述一下，如何显式的将它们设置为持久化。同时，知道如何持久化，就知道如何设置为非持久化了。
也可以直接跳过本章节
生产者确认可以确保消息投递到RabbitMQ的队列中，但是消息发送到RabbitMQ以后，如果突然宕机，也可能导致消息丢失。
要想确保消息在RabbitMQ中安全保存，必须开启消息持久化机制。MQ中有以下三种信息需要持久化：
-
交换机持久化
-
队列持久化
-
消息持久化
3.1. 交换机持久化
RabbitMQ中交换机 默认是非持久化的，MQ重启后交换机就会丢失。所以我们需要在创建交换机的时候，就需要指定交换机为持久交换机。
- 使用Bean声明方式创建：
创建交换机时，额外添加如下参数即可。
@Bean
public DirectExchange simpleExchange(){
// 三个参数：交换机名称、是否持久化、当没有queue与其绑定时是否自动删除
return new DirectExchange("simple.direct", true, false);
}- 使用注解声明方式创建
需要在创建交换机的时候，指定参数durable=true。不过因为默认是true，所以不写也可以
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "simple.queue",durable = "true"),
exchange = @Exchange(value = "simple.exchange", type = ExchangeTypes.DIRECT),
key = "simple"
))
public void demoListener(String msg) {
log.info("simple.queue的数据：{}", msg);
/////// 具体的业务逻辑 //////
.........
}可以在RabbitMQ控制台看到持久化的交换机都会带上D的标示：
3.2. 队列持久化
RabbitMQ中队列 默认是非持久化的 ，MQ重启后队列就会丢失。所以我们需要在创建队列的时候，就需要指定交换机为持久交换机。
SpringAMQP中可以通过代码指定交换机持久化。
-
使用Bean声明方式创建：
需要使用QueueBuilder创建队列，并通过durable方法指定队列名字。
@Bean
public Queue simpleQueue(){
// 使用QueueBuilder构建队列，durable就是持久化的
return QueueBuilder.durable("simple.queue").build();
}- 使用注解声明方式创建
需要在创建队列的时候，指定参数durable=true。不过因为默认是true，所以不写也可以
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "simple.queue",durable = "true"),
exchange = @Exchange(value = "simple.exchange", type = ExchangeTypes.DIRECT),
key = "simple"
))
public void demoListener(String msg) {
log.info("simple.queue的数据：{}", msg);
/////// 具体的业务逻辑 //////
.........
}可以在RabbitMQ控制台看到持久化的队列都会带上D的标示：
3.3. 消息持久化
不同于前两种方式，消息的持久化需要在消息生产者端设置
利用SpringAMQP发送消息时，可以设置消息的属性（MessageProperties），指定delivery-mode：
- 1-非持久化
- 2-持久化
// ↑ 其他业务代码
// 创建消息
Message message = MessageBuilder.withBody("这是一条消息".getBytes())
.setDeliveryMode(MessageDeliveryMode.PERSISTENT)
.build();
// 消息ID
CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
// 发送
rabbitTemplate.convertAndSend("simple.exchange",message,correlationData);
// ↓ 其他业务代码4. 消费者消息确认
首先，我们需要再次重申，RabbitMQ是阅后即焚机制，RabbitMQ确认消息被消费者消费后会立刻删除。
RabbitMQ是通过消费者回执来确认消费者是否成功处理消息的。
当消费者获取消息并处理后，应该向RabbitMQ发送ACK回执，表明自己已经处理消息。
回执分为3种类型：ack、nack、reject，分别表示处理成功，处理失败和拒绝处理。
如果消费者返回 ack，MQ会把消息从队列删除；
如果返回 nack 或者 reject ，如果requeue是true的话，MQ会把消息重新投递给消费者，如果requeue是false的话，MQ会把消息删掉。
设想这样的场景：
- 1）RabbitMQ投递消息给消费者
- 2）消费者获取消息后，返回ACK给RabbitMQ
- 3）RabbitMQ删除消息
- 4）消费者宕机，消息尚未处理
这样，消息就丢失了。因此消费者返回ACK的时机非常重要。
想要开启消费者消息确认，需要在application.yml中进行如下配置：
spring:
rabbitmq:
host: MQ的具体IP
port: 5672
virtual-host: /
username: mq用户名
password: mq密码
listener:
simple:
acknowledge-mode: auto #消费者消息确认类型在SpringAMQP则允许配置三种确认模式：
-
manual：手动ack，需要在业务代码结束后，调用api发送ack。
-
auto：自动ack，由spring监测listener代码是否出现异常，没有异常则返回ack；抛出异常则返回nack，并且requeue是true
-
none：关闭ack，MQ假定消费者获取消息后会成功处理，因此消息投递后立即被删除
由此可知：
- none模式下，消息投递是不可靠的，可能丢失
- auto模式类似事务机制，出现异常时返回nack，消息回滚到mq；没有异常，返回ack
- manual：自己根据业务情况，判断什么时候该ack
一般，我们都是使用默认的auto即可。
然而，直接使用auto模式也存在一些问题。设置为auto以后，当消费者出现异常后，消费返回nack，并且requeue是true。这时消息会不断requeue（重入队）到队列，再重新发送给消费者，然后再次异常，再次requeue，无限循环，导致mq的消息处理飙升，带来不必要的压力：
所以，auto模式应该配合
5. 消费失败重试机制
5.1. 配置文件
需要在配置文件中，添加失败重试的策略，避免无限重试
我们可以利用Spring的retry机制，在消费者出现异常时利用本地重试，而不是无限制的requeue到mq队列。
修改consumer服务的application.yml文件，添加内容：
spring:
rabbitmq:
host: MQ的具体IP
port: 5672
virtual-host: /
username: mq用户名
password: mq密码
listener:
simple:
acknowledge-mode: auto #消费者消息确认类型
retry:
enabled: true # 开启消费者失败重试
initial-interval: 1000 # 初识的失败等待时长为1秒
multiplier: 3 # 失败的等待时长倍数，下次等待时长 = multiplier * last-interval
max-attempts: 3 # 最大重试次数
stateless: true # true无状态；false有状态。如果业务中包含事务，这里改为false- 开启本地重试时，消息处理过程中抛出异常，不会requeue到队列，而是在消费者本地重试
- 重试达到最大次数后，Spring会返回reject，消息会被丢弃
5.2.失败策略
使用上面的方式，重试达到最大重试次数后，消息会被丢弃，这是由Spring内部机制决定的。
在开启重试模式后，重试次数耗尽，如果消息依然失败，则需要有MessageRecovery接口来处理，它包含三种不同的实现：
-
方案一：RejectAndDontRequeueRecoverer：重试耗尽后，直接reject，丢弃消息。默认就是这种方式
-
方案二：ImmediateRequeueMessageRecoverer：重试耗尽后，返回nack，消息重新入队
-
方案三：RepublishMessageRecoverer：重试耗尽后，将失败消息投递到指定的交换机
比较优雅的一种处理方案是方案三，失败后将消息投递到一个指定的，专门存放异常消息的队列，后续由人工集中处理。
接下来，我们将具体的讲述一下方案三的代码实现。
5.3. 失败消息投递到指定交换机
这种方式，其实最主要的就是创建一个RepublishMessageRecoverer的bean对象，在这个对象中规定重试失败后的投递规则。
1）在生产者端定义处理失败消息的交换机和队列
@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");
}
Comments NOTHING