【尚硅谷 RabbitMQ】7、发布确认高级（SpringBoot版本）：回调接口、回退消息、备份交换机

已于 2023-01-07 19:54:43 修改
阅读量2.3k 收藏 3
点赞数 1
分类专栏： RabbitMQ # SpringBoot 文章标签： RabbitMQ 消息队列
于 2022-03-29 10:16:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tu_wer/article/details/123813997
版权

在生产环境中由于一些不明原因，导致 RabbitMQ 重启。在 RabbitMQ 重启期间生产者消息投递失败，导致消息丢失，需要手动处理和恢复。

如何才能进行 RabbitMQ 的消息可靠投递呢？特别是在这样比较极端的情况，RabbitMQ 集群不可用的时候，无法投递的消息该如何处理呢？

1、发布确认SpringBoot版本

1）确认机制方案

在这里插入图片描述

2）代码架构图

在这里插入图片描述

3）配置文件

spring:
  rabbitmq:
    host: 192.168.19.101
    port: 5672
    username: admin
    password: admin
    publisher-confirm-type: correlated

在这里插入图片描述

  • none 禁用发布确认模式，是默认值
  • correlated 发布消息成功，交换器会触发回调方法
  • simple 经测试有两种效果
    • 和correlated值一样会触发回调方法
    • 在发布消息成功后，使用 rabbitTemplate 调用 waitForConfirms 或 waitForConfirmsOrDiea 方法，等待 broker 节点返回发送结果，根据返回结果来判定下一步的逻辑，要注意的点是waitForConfirmsOrDiea 方法如果返回 false 则会 关闭channel，则接下来无法发送消息到 broker

4）配置类

package com.tuwer.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author 土味儿
 * Date 2022/3/28
 * @version 1.0
 * 高级确认发布配置类
 */
@Configuration
public class ConfirmConfig {
    /**
     * 交换机、队列及RoutingKey
     */
    public static final String CONFIRM_EXCHANGE_NAME = "confirm.exchange";
    public static final String CONFIRM_QUEUE_NAME = "confirm.queue";
    public static final String CONFIRM_ROUTING_KEY = "key1";

    /**
     * 获取确认交换机
     * @return
     */
    @Bean("confirmExchange")
    public DirectExchange getConfirmExchange(){
        return new DirectExchange(CONFIRM_EXCHANGE_NAME);
    }

    /**
     * 获取确认队列
     * @return
     */
    @Bean("confirmQueue")
    public Queue getConfirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE_NAME).build();
    }

    /**
     * 绑定
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding confirmQueueBindConfirmExchange(
            @Qualifier("confirmQueue") Queue queue,
            @Qualifier("confirmExchange") DirectExchange exchange
    ){
        return BindingBuilder.bind(queue).to(exchange).with(CONFIRM_ROUTING_KEY);
    }
}

5）生产者

package com.tuwer.controller;

import com.tuwer.config.ConfirmConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 土味儿
 * Date 2022/3/28
 * @version 1.0
 */
@Slf4j
@RestController
@RequestMapping("/confirm")
public class ConfirmProducerController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/sendMsg/{msg}")
    public String sendMsg(@PathVariable("msg") String msg) {
        // CorrelationData 供回退方法调用
        CorrelationData correlationData = new CorrelationData("1");
        rabbitTemplate.convertAndSend(
                ConfirmConfig.CONFIRM_EXCHANGE_NAME,
                ConfirmConfig.CONFIRM_ROUTING_KEY,
                msg,
                correlationData);

        log.info("消息：【" + msg + "】已发送！");
        return "OK!";
    }
}

6）回调接口

package com.tuwer.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * @author 土味儿
 * Date 2022/3/28
 * @version 1.0
 */
@Slf4j
@Component
public class MyCallBack implements RabbitTemplate.ConfirmCallback {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 把当前类注入到 RabbitTemplate
     * @PostConstruct 表示在执行当前类的构造时运行
     * 因为 ConfirmCallback接口是 RabbitTemplate的内部类
     */
    @PostConstruct
    public void init(){
        rabbitTemplate.setConfirmCallback(this);
    }
    /**
     * 交换机确认回调方法
     * @param correlationData 回调消息
     * @param ack 交换机是否确认收到了消息：true:收到了；false:没有收到
     * @param cause 没有收到消息的原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, @Nullable String cause) {
        // 消息ID
        String id = correlationData!=null ? correlationData.getId():"";
        if(ack){
            // 收到
            log.info("交换机收到了消息！ID = {}",id);
        }else{
            // 未收到
            log.info("交换机没有没有消息！ID = {}；原因：{}",id,cause);
        }
    }
}

在这里插入图片描述

7）消费者

package com.tuwer.consumer;

import com.tuwer.config.ConfirmConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @author 土味儿
 * Date 2022/3/28
 * @version 1.0
 */
@Slf4j
@Component
public class ConfirmQueueConsumer {
    /**
     * 监听确认队列
     * @param message
     */
    @RabbitListener(queues = ConfirmConfig.CONFIRM_QUEUE_NAME)
    public void receiveConfirmMsg(Message message){
        String msg = new String(message.getBody());
        log.info("接收到的消息：【{}】", msg);
    }
}

8）运行测试

  • 正常发送

在这里插入图片描述

  • 向不存在的交换机发送

在这里插入图片描述

在这里插入图片描述

  • 向不存在的RoutingKey发送

在这里插入图片描述

在这里插入图片描述

2、回退消息

在仅开启了生产者确认机制的情况下，交换机接收到消息后，会直接给消息生产者发送确认消息，如果发现该消息不可路由，那么消息会被直接丢弃，此时生产者是不知道消息被丢弃这个事件的。那么如何处理呢？

通过设置 mandatory 参数可以在当消息传递过程中不可达目的地时，将消息返回给生产者。

1）配置文件

spring:
  rabbitmq:
    # 省略...
    # 交换机接收确认
    publisher-confirm-type: correlated
    # 交换机回退消息
    publisher-returns: true

2）回退接口

在MyCallBack中添加回退方法

@Slf4j
@Component
public class MyCallBack implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnsCallback {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 把当前类注入到 RabbitTemplate
     *
     * @PostConstruct 表示在执行当前类的构造时运行
     * 因为 ConfirmCallback接口是 RabbitTemplate的内部类
     */
    @PostConstruct
    public void init() {
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
    }

    /**
     * 交换机确认回调方法
     * 省略...
     */

    /**
     * 消息回退回调方法
     * @param returnedMessage
     */
    @Override
    public void returnedMessage(ReturnedMessage returnedMessage) {
        log.error("消息{}，被交换机{}退回，退回的原因：{},路由Key：{}",
                new String(returnedMessage.getMessage().getBody())
                , returnedMessage.getExchange()
                , returnedMessage.getReplyText()
                , returnedMessage.getRoutingKey());
    }
}

在这里插入图片描述

在这里插入图片描述

3）生产者

在这里插入图片描述

4）运行测试

在这里插入图片描述

3、备份交换机

  • 有了mandatory 参数和回退消息，我们获得了对无法投递消息的感知能力，有机会在生产者的消息无法被投递时发现并处理。但有时候，并不知道该如何处理这些无法路由的消息，最多打个日志，然后触发报警，再来手动处理。而通过日志来处理这些无法路由的消息是很不优雅的做法，特别是当生产者所在的服务有多台机器的时候，手动复制日志会更加麻烦而且容易出错。而且设置mandatory参数会增加生产者的复杂性，需要添加处理这些被退回的消息的逻辑。

  • 如果既不想丢失消息，又不想增加生产者的复杂性，该怎么做呢？前面在设置死信队列的文章中，我们提到，可以为队列设置死信交换机来存储那些处理失败的消息，可是这些不可路由消息根本没有机会进入到队列，因此无法使用死信队列来保存消息。

  • 在RabbitMQ中，有一种备份交换机的机制存在，可以很好的应对这个问题。

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

1）代码架构图

在这里插入图片描述

2）修改配置类

  • 增加 备份交换机(fanout类型)、备份队列、报警队列
  • 备份队列 绑定 备份交换机
  • 报警队列 绑定 备份交换机
  • 修改确认交换机：增加参数 withArgument("alternate-exchange",BACKUP_EXCHANGE_NAME)
package com.tuwer.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author 土味儿
 * Date 2022/3/28
 * @version 1.0
 * 高级确认发布配置类
 */
@Configuration
public class ConfirmConfig {
    /**
     * 交换机、队列及RoutingKey
     */
    public static final String CONFIRM_EXCHANGE_NAME = "confirm.exchange";
    public static final String BACKUP_EXCHANGE_NAME = "backup.exchange";

    public static final String CONFIRM_QUEUE_NAME = "confirm.queue";
    public static final String BACKUP_QUEUE_NAME = "backup.queue";
    public static final String WARNING_QUEUE_NAME = "warning.queue";

    public static final String CONFIRM_ROUTING_KEY = "key1";

    /**
     * 获取确认交换机
     * @return
     */
    @Bean("confirmExchange")
    public DirectExchange getConfirmExchange(){
        //return new DirectExchange(CONFIRM_EXCHANGE_NAME);
        return ExchangeBuilder
                .directExchange(CONFIRM_EXCHANGE_NAME)
                .durable(true)
                .withArgument("alternate-exchange",BACKUP_EXCHANGE_NAME)
                .build();
    }

    /**
     * 备份交换机
     * 类型：fanout
     * @return
     */
    @Bean("backupExchange")
    public FanoutExchange getBackupExchange(){
        return new FanoutExchange(BACKUP_EXCHANGE_NAME);
    }

    /**
     * 获取确认队列
     * @return
     */
    @Bean("confirmQueue")
    public Queue getConfirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE_NAME).build();
    }

    /**
     * 获取备份队列
     * @return
     */
    @Bean("backupQueue")
    public Queue getBackupQueue(){
        return QueueBuilder.durable(BACKUP_QUEUE_NAME).build();
    }

    /**
     * 获取报警队列
     * @return
     */
    @Bean("warningQueue")
    public Queue getWarningQueue(){
        return QueueBuilder.durable(WARNING_QUEUE_NAME).build();
    }

    /**
     * 确认队列 绑定 确认交换机
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding confirmQueueBindConfirmExchange(
            @Qualifier("confirmQueue") Queue queue,
            @Qualifier("confirmExchange") DirectExchange exchange
    ){
        return BindingBuilder.bind(queue).to(exchange).with(CONFIRM_ROUTING_KEY);
    }

    /**
     * 备份队列 绑定 备份交换机
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding backupQueueBindBackupExchange(
            @Qualifier("backupQueue") Queue queue,
            @Qualifier("backupExchange") FanoutExchange exchange
    ){
        return BindingBuilder.bind(queue).to(exchange);
    }

    /**
     * 报警队列 绑定 备份交换机
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding warningQueueBindBackupExchange(
            @Qualifier("warningQueue") Queue queue,
            @Qualifier("backupExchange") FanoutExchange exchange
    ){
        return BindingBuilder.bind(queue).to(exchange);
    }
}

3）报警消费者

package com.tuwer.consumer;

import com.tuwer.config.ConfirmConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.time.LocalTime;

/**
 * @author 土味儿
 * Date 2022/3/28
 * @version 1.0
 */
@Slf4j
@Component
public class WarningConsumer {
    /**
     * 监听报警队列消息
     * @param message
     */
    @RabbitListener(queues = ConfirmConfig.WARNING_QUEUE_NAME)
    public void receiveWarningQueue(Message message){
        String msg = new String(message.getBody());
        log.info("接收到报警队列的消息：{}", msg);
    }
}

4）运行测试

在这里插入图片描述

在这里插入图片描述

  • mandatory参数与备份交换机可以一起使用
  • 如果两者同时开启，消息究竟何去何从？谁优先级高就走谁那里，经过上面结果显示： 备份交换机优先级高；当消息不能路由时，直接转到了备份交换机，而不是回退给生产者

4、实战原理图

在这里插入图片描述

土味儿~
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring Boot整合RabbitMq 重写confirm不生效
FX_XU的专栏
11-03 1466
Spring Boot整合RabbitMq 重写confirm不生效
RabbitMQ消息可靠投递机制:confirm方式 回调不成功解决方案
qq_45771848的博客
08-31 1494
rabbitMq消息可靠投递机制 confirm方式回调失败原因。
解决rabbitmq ConfirmCallback不回调的问题
qq_19289851的博客
03-03 5539
解决rabbitmq ConfirmCallback不回调的问题 问题描述 实现了RabbitTemplate.ConfirmCallback接口，并重写了confirm方法 配置了publisher-confirms: true 发送消息到RabbitMq，已经发送成功，也已经到队列中了，且状态为ready，但是并没有回调接口 解决办法 添加属性publisher-confirm-type: correlated spring.rabbitmq.publisher-confirm-type=cor
记一次 RabbitMq setConfirmCallback 没起作用的情况
weixin_44981329的博客
03-16 1110
所以在配置中加上了publisher-confirm-type: correlated，再次运行代码，发现可以正常进入到ConfirmCallback 中。消费者都已经成功消费了，但是没有打印进入setConfirmCallback。实现生产者投递消息到交换机的确认机制，以及消息由交换机投递到队列的错误返回机制。大家都知道是如下配置。自信满满的设置完成后想着运行下试试。至此问题结束，希望可以帮助到你。
RabbitMq（十三）消息发送确认与回调机制
liuhenghui5201的专栏
07-23 5579
在rabbitmq中如何确认消息发送到交换机上以及是否正常交换机转发到消息队列上，在rabbitmq上均有其确认实现接口。 confirm-callback ：消息确认机制，也就是消息是否正常发送到交换机的回调，内部可以实现正常与失败的区分处理。 return-callback：消息的失败回调处理，也就是消息通过交换机时没有正常转发到消息队列中时触发。 代码实现参考： pom文件 springboot的application.properties spring资源文件spring/spring-r
Rabbit回调接口与回退接口的使用
qq_24469795的博客
03-14 869
一、创建类并实现回调与回退接口 @Slf4j @Component public class MyCallBack implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnsCallback { } 实现 RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnsCallback中的接口 实现RabbitTemplate.ConfirmCallback接口 c
尚硅谷_消息中间件RabbitMQ_课件.docx
11-07
尚硅谷_消息中间件RabbitMQ_课件
springboot整合stream使用rabbitmq作为消息中间件
12-13
当我们谈论"SpringBoot整合stream使用rabbitmq作为消息中间件"时，我们涉及的关键技术点主要包括Spring Boot的Stream模块、RabbitMQ的使用以及它们如何协同工作来实现高效的微服务通信。 Spring Boot Stream模块是...
springboot + rabbitmq 如何实现消息确认机制(踩坑经验)
08-18
SpringBoot + RabbitMQ 实现消息确认机制的踩坑经验 SpringBoot 和 RabbitMQ 是当前流行的微服务架构中常用的技术栈，然而在实际开发中，消息确认机制的实现却是一个坑爹的点。今天，我将与大家分享小编在实际开发...
RabbitMQ （二）结合springboot实现消息重试.pdf
07-02
RabbitMQ （二）结合springboot实现消息重试.pdf
springboot-rabbitMQ-websocket:springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
05-27
5. **创建消息生产者**：编写服务或控制器中的方法，使用RabbitTemplate来发布消息到指定的交换机。 6. **创建消息消费者**：通过`@RabbitListener`注解，创建监听器以接收来自特定队列的消息。 接下来，我们要将...
rabbitmq消息可靠性之消息回调机制
qq_41992429的博客
01-12 2278
rabbitmq消息可靠性之消息回调机制
【RabbitMQ】RabbitMQ 消息的可靠性 —— 生产者和消费者消息的确认，消息的持久化以及消费失败的重试机制
最新发布
qq_61635026的博客
11-02 1万+
在现代分布式应用程序中，消息队列扮演了至关重要的角色，允许系统中的各个组件之间进行异步通信。这种通信模式提供了高度的灵活性和可伸缩性，但也引入了一系列的挑战，其中最重要的之一是消息的可靠性。首先让我们来了解一下，在消息队列中，消息从生产者发送到交换机，再到队列，最后到消费者，有哪些情况会导致消息的丢失？生产者发送的消息未送达交换机；消息到达交换机后未到达队列；MQ 宕机，队列中的消息会丢失；消费者接收到消息后未消费就宕机了。
RabbitMQ系列【7】消息可靠性之发布确认、退回机制
记录知识、锤炼自我
11-14 1657
发布=》交换机=》队列=》消费。如下图所示：消息发送了，但未正常到达交换机到达了交换机，但没有找到匹配的队列，消息丢失消息已投递，但未被消费者成功接收到消费者消费时，消息处理异常为了解决以上种种问题，因此发布者和消费者都需要一种用于传递和处理确认的机制。RabbitMQ提供了各种机制，首先是消息发布可靠性机制。消息发布可靠性机制是指消息发送方杜绝任何发送消息丢失或者投递失败场景，确保消息被正常投递到队列中，RabbitMQ提供了两种模式。确认模式（confirm）退回模式（return）
RabbitMQ 如何保证消息的可靠性以及解决幂等性
一个刚入行的新人猿
05-17 1830
1.RabbitMQ 消息发送机制 消息大致流程： 消息先到达交换机 然后根据指定的路由规则 由交换机将消息路由到不同Queue(队列)中，由不同的消费者去消费 所以要保证消息的可靠性，就是要保证： 消息成功的到达交换机 Exchange 消息成功的到达 Queue 如果能够确认这两步，则认为消息发送成功了。 如果这两步中任意一步骤出现了问题，那么消息就没有成功的投递。此时我们应该通过重试等方式去重新发送消息，多次重试之后，如果消息还是不能到达，则可能需要人工介入了。 经过上面的分析，要确保消息
RabbitMQ消息可靠性之生产者消息确认
豆恭梓的博客
07-28 150
每个RabbitTemplate只能配置一个ReturnCallback，因此需要在项目加载时（实现ApplicationContextAware接口）配置：// 获取RabbitTemplate RabbitTemplate rabbitTemplate = applicationContext . getBean(RabbitTemplate . class);
解决rabbitMQ消息发送成功，但ConfirmCallback的ack返回为false问题
dimtem的博客
02-28 3944
解决rabbitMQ消息发送成功，但ConfirmCallback的ack返回为false问题
@RabbitListener失效问题
qq_51682771的博客
11-19 572
添加@service。
SpringBoot + RabbitMQ自定义ConnectionFacotry后，配置发送确认回调无效
雨潇的专栏
05-30 4204
问题现象 由于项目需要连接到多个RabbitMQ实例或者一个实例的多个vhost上，需要自定义配置多个ConnectionFactory来区分连接，以达到可以消费或者向多个RabbitMQ实例/多个vhost发送消息。手动配置ConnectionFactory后，发现原来配置的发送确认回调无效了，ConnectionFactory的配置如下， /** * 自定义RabbitMQ不同实例/不同vhost的ConnectionFactory * @param rabbitProperties 配置文件中ra
在RabbitMQ中发布确认中，回退消息和备份交换机选择哪个
06-11
在RabbitMQ中，当发布确认模式（Publisher Confirm）开启后，可以选择回退消息（basic.nack）或者备份交换机（Alternate Exchange）来处理消息发布失败的情况。 回退消息是指当消息无法路由到任何一个队列时，将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

土味儿~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值