1.消息重试机制
消费者消费消息的时候,发生异常情况,导致消息未确认,该消息会被重复消费(默认没有重复次数,即无限循环消费),但可以通过设置重试次数以及达到重试次数之后的消息处理
spring:
rabbitmq:
port: 5672
host: 127.0.0.1
username: guest
password: guest
2.案例重现
首先来看一个案例:
自动确认模式
package com.yzm.rabbitmq_04.config;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitConfig {
public static final String RETRY_QUEUE = "retry_queue";
public static final String RETRY_EXCHANGE = "retry.exchange";
public static final String RETRY_KEY = "retry.key";
}
package com.yzm.rabbitmq_04.sender;
import com.yzm.rabbitmq_04.config.RabbitConfig;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class Sender {
private final RabbitTemplate rabbitTemplate;
public Sender(RabbitTemplate rabbitTemplate) {
this.rabbitTemplate = rabbitTemplate;
}
@GetMapping("/retry")
public void retry() {
String message = "Hello World !";
rabbitTemplate.convertAndSend(RabbitConfig.RETRY_EXCHANGE, RabbitConfig.RETRY_KEY, message);
System.out.println(" [ 生产者 ] Sent ==> '" + message + "'");
}
}
这里创建队列和交换机是通过注解实现的,跟前面的篇章的创建方式是等同的
消费者在处理消息时发生异常情况
package com.yzm.rabbitmq_04.receiver;
import com.yzm.rabbitmq_04.config.RabbitConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.core.Message;
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;
@Slf4j
@Component
public class Receiver {
private int count = 1;
@RabbitListener(bindings = @QueueBinding(
value = @Queue(value = RabbitConfig.RETRY_QUEUE),
exchange = @Exchange(value = RabbitConfig.RETRY_EXCHANGE, type = ExchangeTypes.DIRECT),
key = {RabbitConfig.RETRY_KEY}
))
public void retry(Message message) {
log.info("当前执行次数:{}", count++);
log.info(" [ 消费者@A号 ] 接收到消息 ==> '" + new String(message.getBody()));
// 制造异常
int i = 1 / 0;
log.info(" [ 消费者@A号 ] 消费了消息 ==> '" + new String(message.getBody()));
}
}
启动,运行结果
无限循环报错
停止后,消息重回Ready状态
3.实现消息重试
启动重试机制
spring:
rabbitmq:
port: 5672
host: 127.0.0.1
username: guest
password: guest
listener:
simple:
retry:
enabled: true
max-attempts: 5 # 重试次数
max-interval: 10000 # 重试最大间隔时间
initial-interval: 2000 # 重试初始间隔时间
multiplier: 2 # 间隔时间乘子,间隔时间*乘子=下一次的间隔时间,最大不能超过设置的最大间隔时间
重启,运行结果:
首先重试次数是5次(包括自身初次消费的那次)没问题,
第一个执行时间:09:50:39,第二次执行时间:09:50:41 ,跟第一次的时间间隔2秒(初始间隔)没问题
第三次执行时间:09:50:45,跟第二次的时间间隔 = 初始间隔(2秒) * 间隔因子(2) = 4秒没问题
以此类推… 2s、4s、8s、16s(最后一次16s,但由于设置的最大间隔10s,所以16s就变成了10s)
最后查看retry_queue队列,消息没有了,也就是说重试5次失败之后就会移除该消息
移除操作是由日志中的这个类处理:RejectAndDontRequeueRecoverer(拒绝和不要重新排队)
具体实现可以看SimpleRabbitListenerContainerFactoryConfigurer类中的MessageRecoverer接口,这个接口有一个cover方法,用来实现重试完成之后对消息的处理,源码如下:
RejectAndDontRequeueRecoverer 是 接口 MessageRecoverer 的一个实现类
同时 MessageRecoverer 还有另外两个实现类,分别是
RepublishMessageRecoverer(重新发布消息)和ImmediateRequeueMessageRecoverer(立即重新返回队列)
先来使用下 ImmediateRequeueMessageRecoverer 重新排队
在RabbitConfig中配置
package com.yzm.rabbitmq_04.config;
import org.springframework.amqp.rabbit.retry.ImmediateRequeueMessageRecoverer;
import org.springframework.amqp.rabbit.retry.MessageRecoverer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitConfig {
public static final String RETRY_QUEUE = "retry_queue";
public static final String RETRY_EXCHANGE = "retry.exchange";
public static final String RETRY_KEY = "retry.key";
@Bean
public MessageRecoverer messageRecoverer() {
return new ImmediateRequeueMessageRecoverer();
}
}
重启,运行结果:
可以看出:重试5次之后,返回队列,然后再重试5次,周而复始直到不抛出异常为止,这样还是会影响后续的消息消费。
接着使用 RepublishMessageRecoverer 重新发布
在RabbitConfig中配置
package com.yzm.rabbitmq_04.config;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.retry.ImmediateRequeueMessageRecoverer;
import org.springframework.amqp.rabbit.retry.MessageRecoverer;
import org.springframework.amqp.rabbit.retry.RepublishMessageRecoverer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitConfig {
public static final String RETRY_EXCHANGE = "retry.exchange";
public static final String RETRY_QUEUE = "retry_queue";
public static final String RETRY_FAILURE_QUEUE = "retry_failure_queue";
public static final String RETRY_FAILURE_KEY = "retry.failure.key";
public static final String RETRY_KEY = "retry.key";
// @Bean
public MessageRecoverer messageRecoverer() {
return new ImmediateRequeueMessageRecoverer();
}
@Bean
public MessageRecoverer messageRecoverer(RabbitTemplate rabbitTemplate) {
// 需要配置交换机和绑定键
return new RepublishMessageRecoverer(rabbitTemplate, RETRY_EXCHANGE, RETRY_FAILURE_KEY);
}
}
创建重试失败消息监听
package com.yzm.rabbitmq_04.receiver;
import com.yzm.rabbitmq_04.config.RabbitConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.core.Message;
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;
@Slf4j
@Component
public class Receiver {
private int count = 1;
@RabbitListener(bindings = @QueueBinding(
value = @Queue(value = RabbitConfig.RETRY_QUEUE),
exchange = @Exchange(value = RabbitConfig.RETRY_EXCHANGE, type = ExchangeTypes.DIRECT),
key = {RabbitConfig.RETRY_KEY}
))
public void retry(Message message) {
log.info("当前执行次数:{}", count++);
log.info(" [ 消费者@A号 ] 接收到消息 ==> '" + new String(message.getBody()));
// 制造异常
int i = 1 / 0;
log.info(" [ 消费者@A号 ] 消费了消息 ==> '" + new String(message.getBody()));
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(value = RabbitConfig.RETRY_FAILURE_QUEUE),
exchange = @Exchange(value = RabbitConfig.RETRY_EXCHANGE),
key = {RabbitConfig.RETRY_FAILURE_KEY}
))
public void retryFailure(Message message) {
log.info(" [ 消费者@重试失败号 ] 接收到消息 ==> '" + new String(message.getBody()));
}
}
重启,运行结果:
重试5次之后,将消息 Republishing failed message to exchange ‘retry.exchange’ with routing key retry-key 转发到重试失败队列,由重试失败消费者消费