• RabbitMQ 消息丢失解决 (高级发布确认、消息回退与重发、备份交换机)


    目录

    一、发布确认SpringBoot版本

    确认机制图例:

    代码实战:

    代码架构图:

    1.1交换机的发布确认

    添加配置类

    消息消费者

    消息生产者发布消息后的回调接口

    测试:

     1.2回退消息并重发(队列的发布确认)

    修改回调接口

    生产者:

    测试:

    二、备份交换机

    实战

    生产者

    报警消费者:

    测试:


    一、发布确认SpringBoot版本

            首先发布消息后进行备份在缓存里,如果消息成功发布确认到交换机,则从缓存里删除该消息,如果没有成功发布,则设置一个定时任务,重新从缓存里获取消息发布到交换机,直到成功发布到交换机。

    确认机制图例:

    代码实战:

    一个交换机:confirm.exchange,一个队列:confirm.queue,一个消费者:confirm.consumer

    其中交换机类型时 direct,与队列关联的 routingKey 是 key1

    代码架构图:

    1.1交换机的发布确认

    配置文件中添加:

    1. server:
    2. port: 8888
    3. spring:
    4. rabbitmq:
    5. host: 192.168.163.132
    6. port: 5672
    7. username: 2252631565
    8. password: 2252631565
    9. # 高级发布确认 发布消息成功后将会触发回调方法
    10. publisher-confirm-type: correlated
    • NONE 值是禁用发布确认模式,是默认值
    • CORRELATED 值是发布消息成功到交换器后会触发回调方法
    • SIMPLE 值经测试有两种效果,其一效果和 CORRELATED 值一样会触发回调方法,其二在发布消息成功后使用 rabbitTemplate 调用 waitForConfirms 或 waitForConfirmsOrDie 方法等待 broker 节点返回发送结果,根据返回结果来判定下一步的逻辑,要注意的点是 waitForConfirmsOrDie 方法如果返回 false 则会关闭 channel,则接下来无法发送消息到 broker;

    添加配置类

    声明交换机和队列,并且将交换机和队列进行绑定:

    1. @Configuration
    2. public class ConfirmConfig {
    3. public static final String CONFIRM_EXCHANGE="confirm.exchange";
    4. public static final String CONFIRM_QUEUE="confirm.queue";
    5. public static final String ROUTING_KEY="key1";
    6. @Bean
    7. public DirectExchange confirmExchange(){
    8. return new DirectExchange(CONFIRM_EXCHANGE,false,false);
    9. }
    10. @Bean
    11. public Queue confirmQueue(){
    12. return QueueBuilder.durable(CONFIRM_QUEUE).build();
    13. }
    14. @Bean
    15. public Binding EAndQBind(@Qualifier("confirmExchange") DirectExchange exchange,@Qualifier("confirmQueue")Queue queue){
    16. return BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY);
    17. }
    18. }

    消息生产者

    也可以说是 Controller 层,在这里发送两条消息给两个交换机,其中一个交换机是我们设置好的,另一个交换机不存在;这样就可以清晰看出交换机应答效果。

    1. @Slf4j
    2. @RestController
    3. @RequestMapping("/ttl")
    4. public class SendMsgController {
    5. @Autowired
    6. private RabbitTemplate rabbitTemplate;
    7. //高级发布确认模式
    8. @GetMapping("/sendConfirmMsg/{message}")
    9. public void sendConfirmMsg(@PathVariable String message){
    10. log.info("发送一条时长为的消息给第一个队列内容是:{}",new Date().toString(),message);
    11. CorrelationData correlationData=new CorrelationData("1");
    12. correlationData.setReturnedMessage(new org.springframework.amqp.core.Message(message.getBytes()));
    13. rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE,ConfirmConfig.ROUTING_KEY,message,correlationData);
    14. //向一个不存在的交换机发送消息
    15. log.info("发送一条时长为的消息给第一个队列内容是:{}",new Date().toString(),message);
    16. CorrelationData correlationData2=new CorrelationData("2");
    17. correlationData2.setReturnedMessage(new org.springframework.amqp.core.Message(message.getBytes()));
    18. rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE+123,ConfirmConfig.ROUTING_KEY,message,correlationData2);
    19. }
    20. }

    消息消费者

    监听 confirm.queue 队列

    1. @Slf4j
    2. @Component
    3. public class ConfirmLetterQueue {
    4. @RabbitListener(queues = ConfirmConfig.CONFIRM_QUEUE)
    5. public void confirmConsumer(Message message, Channel channel){
    6. log.info("收到了消息:{}",new String(message.getBody()));
    7. }
    8. }

    消息生产者发布消息后的回调接口

    只要生产者发布消息,交换机不管是否收到消息,都会调用该类的 confirm 方法

    1. @Slf4j
    2. @Component
    3. public class MyCallBack implements RabbitTemplate.ConfirmCallback {
    4. @Autowired
    5. private RabbitTemplate rabbitTemplate;
    6. @PostConstruct
    7. public void init(){
    8. //注入
    9. rabbitTemplate.setConfirmCallback(this::confirm);
    10. }
    11. /*交换机确认回调
    12. 1.交换机收到了消息 触发回调
    13. 1.1 correlationData(我们在发消息的时候自己创建的) 消息的ID以及消息内容
    14. 1.2 ack 交换机收到消息 true
    15. 1.3 cause 交换机收到消息的原因 null
    16. ---------------------------------
    17. 2.交换机未收到消息 触发回调
    18. 2.1 correlationData 消息的ID以及消息内容
    19. 2.2 ack 交换机未收到消息 false
    20. 2.3 cause 失败原因
    21. */
    22. @Override
    23. public void confirm(CorrelationData correlationData, boolean ack, String cause) {
    24. if(ack){
    25. log.info("发送消息到交换机成功!消息体为:{}",new String(correlationData.getReturned().getMessage().getBody()));
    26. }else {
    27. log.info("发送消息到交换机失败!原因为:{}",cause.toString());
    28. }
    29. }
    30. }

    测试:

     效果很明显,我们配置的交换机成功收到消息并转发给队列;不存在的交换机没有接受到消息并作出反应。

     1.2回退消息并重发(队列的发布确认)

    在配置文件中开启消息回退功能

    1. server:
    2. port: 8888
    3. spring:
    4. rabbitmq:
    5. host: 192.168.163.133
    6. port: 5672
    7. username: 2252631565
    8. password: 2252631565
    9. # 高级发布确认 发布消息成功后将会触发回调方法
    10. publisher-confirm-type: correlated
    11. # 消息回退 当消息未路由至队列时触发
    12. publisher-returns: true

    修改回调接口

    实现 RabbitTemplate.ReturnsCallback 接口,并实现方法

    1. @Slf4j
    2. @Component
    3. public class MyCallBack implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnsCallback{
    4. @Autowired
    5. private RabbitTemplate rabbitTemplate;
    6. @PostConstruct
    7. public void init(){
    8. //注入
    9. rabbitTemplate.setConfirmCallback(this::confirm);
    10. rabbitTemplate.setReturnsCallback(this::returnedMessage);
    11. }
    12. /*交换机确认回调
    13. 1.交换机收到了消息 触发回调
    14. 1.1 correlationData(我们在发消息的时候自己创建的) 消息的ID以及消息内容
    15. 1.2 ack 交换机收到消息 true
    16. 1.3 cause 交换机收到消息的原因 null
    17. ---------------------------------
    18. 2.交换机未收到消息 触发回调
    19. 2.1 correlationData 消息的ID以及消息内容
    20. 2.2 ack 交换机未收到消息 false
    21. 2.3 cause 失败原因
    22. */
    23. @Override
    24. public void confirm(CorrelationData correlationData, boolean ack, String cause) {
    25. if(ack){
    26. log.info("时间:{}发送消息到交换机成功!",new Date());
    27. }else {
    28. log.info("发送消息到交换机失败!原因为:{}",cause.toString());
    29. }
    30. }
    31. //当消息未路由到队列时触发 只有失败时才触发 若消息发送至延迟队列则一定会触发回退 记得根据交换机名称排除延迟队列
    32. @Override
    33. public void returnedMessage(ReturnedMessage returned) {
    34. log.error("消息:'{}',被交换机:{}回退,回退原因为:{},routingKey为:{}"
    35. ,new String(returned.getMessage().getBody())
    36. ,returned.getExchange()
    37. ,returned.getReplyText()
    38. ,returned.getRoutingKey());
    39. //10s后消息重发
    40. try {
    41. Thread.sleep(10000);
    42. log.info("时间:{},生产者重新发消息",new Date());
    43. rabbitTemplate.convertAndSend(returned.getExchange(),ConfirmConfig.ROUTING_KEY,new String(returned.getMessage().getBody()));
    44. }catch (InterruptedException e) {
    45. throw new RuntimeException(e);
    46. }
    47. }
    48. }

    生产者:

    向交换机中发送消息,指定错误的routingkey,触发队列回退消息并重发消息。

    1. //高级发布确认模式
    2. @GetMapping("/sendConfirmMsg/{message}")
    3. public void sendConfirmMsg(@PathVariable String message){
    4. //向一个不存在的队列发送消息
    5. log.info("时间:{}生产者发送一条的消息给第一个队列内容是:{}",new Date().toString(),message);
    6. CorrelationData correlationData2=new CorrelationData("2");
    7. rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE,ConfirmConfig.ROUTING_KEY+123,message,correlationData2);
    8. }

    测试:

    回退未进入队列的消息并重新发送消息。 

    二、备份交换机

            什么是备份交换机呢?备份交换机可以理解为 RabbitMQ 中交换机的“备胎”,当我们为某一个交换机声明一个对应的备份交换机时,就是为它创建一个备胎,当交换机接收到一条不可路由消息时,将会把这条消息转发到备份交换机中,由备份交换机来进行转发和处理,通常备份交换机的类型为 Fanout (扇出),这样就能把所有消息都投递到与其绑定的队列中,然后我们在备份交换机下绑定一个队列,这样所有那些原交换机无法被路由的消息,就会都进 入这个队列了。当然,我们还可以建立一个报警队列,用独立的消费者来进行监测和报警并可以重发消息。

    实战

    需要一个备份交换机 backup.exchange,类型为 fanout,该交换机发送消息到队列 backup.queue 和 warning.queue。

     修改高级确认发布 配置类

    1. @Configuration
    2. public class ConfirmConfig {
    3. public static final String CONFIRM_EXCHANGE="confirm.exchange";
    4. public static final String CONFIRM_QUEUE="confirm.queue";
    5. public static final String ROUTING_KEY="key1";
    6. //备份交换机
    7. public static final String BACKUP_EXCHANGE="backup.exchange";
    8. //备份队列
    9. public static final String BACKUP_QUEUE="backup.queue";
    10. //报警队列
    11. public static final String WARNING_QUEUE="warning.queue";
    12. @Bean
    13. public DirectExchange confirmExchange(){
    14. //绑定确认交换机与备份交换机
    15. Map argument=new HashMap<>();
    16. argument.put("alternate-exchange",BACKUP_EXCHANGE);
    17. return ExchangeBuilder.directExchange(CONFIRM_EXCHANGE).withArguments(argument).build();
    18. }
    19. //备份交换机
    20. @Bean
    21. public FanoutExchange backupExchange(){
    22. return new FanoutExchange(BACKUP_EXCHANGE);
    23. }
    24. @Bean
    25. public Queue confirmQueue(){
    26. return QueueBuilder.durable(CONFIRM_QUEUE).build();
    27. }
    28. //备份队列
    29. @Bean
    30. public Queue backupQueue(){
    31. return QueueBuilder.durable(BACKUP_QUEUE).build();
    32. }
    33. //警告队列
    34. @Bean
    35. public Queue warningQueue(){
    36. return QueueBuilder.durable(WARNING_QUEUE).build();
    37. }
    38. @Bean
    39. public Binding EAndQBind(@Qualifier("confirmExchange") DirectExchange exchange,@Qualifier("confirmQueue")Queue queue){
    40. return BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY);
    41. }
    42. //绑定备份交换机与两个队列
    43. @Bean
    44. public Binding BAndBBing(@Qualifier("backupExchange") FanoutExchange exchange,@Qualifier("backupQueue")Queue queue){
    45. return BindingBuilder.bind(queue).to(exchange);
    46. }
    47. @Bean
    48. public Binding BAndWBing(@Qualifier("backupExchange") FanoutExchange exchange,@Qualifier("warningQueue")Queue queue){
    49. return BindingBuilder.bind(queue).to(exchange);
    50. }
    51. }

    生产者

            生产者发送两条消息 一个配置正确的路由,另一个是错误的路由。预期目标是正确路由正常接收消息,错误路由传输的信息由警告队列接收。

    1. //高级发布确认模式
    2. @GetMapping("/sendConfirmMsg/{message}")
    3. public void sendConfirmMsg(@PathVariable String message){
    4. log.info("时间:{}生产者发送两条消息队列内容是:{}",new Date().toString(),message);
    5. CorrelationData correlationData=new CorrelationData("1");
    6. rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE,ConfirmConfig.ROUTING_KEY,message,correlationData);
    7. //向一个不存在的队列发送消息
    8. CorrelationData correlationData2=new CorrelationData("2");
    9. rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE,ConfirmConfig.ROUTING_KEY+123,message,correlationData2);
    10. }

    报警消费者:

    接收不可路由的消息

    1. /**
    2. * 报警消费者
    3. */
    4. @Slf4j
    5. @Component
    6. public class WarningConsumer {
    7. //监听报警消息
    8. @RabbitListener(queues = ConfirmConfig.WARNING_QUEUE)
    9. public void receiveWarningMsg(Message message){
    10. String msg=new String(message.getBody());
    11. log.info("报警发现不可路由消息:{},重发消息",msg);
    12. }
    13. }

    测试:

             生产者发送两条消息 一个配置正确的路由,另一个是错误的路由。预期目标是正确路由正常接收消息,错误路由传输的信息由警告队列接收。

            在此案例中,也设置了消息回退的配置,但是没有触发消息回退。由此得出:备份交换机的优先级更高。

  • 相关阅读:
    4009. Problem D:走台阶问题
    【Git】window下大小写不敏感问题处理
    物理备份xtrabackup
    SwiftUI Spacer() onTapGesture 无法触发
    k8s-9.部署elk日志收集
    在 Ubuntu 20.04 上,将 Subversion 从默认的 1.13.0 降级到 1.9.7。 解决svn无法保存密码问题
    牛客网:NC26 括号生成
    家居服务小程序发展指南
    一起看看Python中的迭代器&生成器
    streamlit报错:AxiosError: Request failed with status code 403
  • 原文地址:https://blog.csdn.net/weixin_52536274/article/details/134456459