RabbitMQ——发布确认高级

最新推荐文章于 2024-03-02 13:36:12 发布
最新推荐文章于 2024-03-02 13:36:12 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： 小黄学RabbitMQ 文章标签： rabbitmq 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yellow_Star___/article/details/122617207
版权

发布确认高级

概念

在之前的学习中，我们学习到了单个确认、批量确认、异步确认三种确认方式，也通过实操来比较三种确认方式的性能，其中异步确认是性能最好的。

现在我们考虑以下这种情况，在生产者发送消息的过程中，可能会出现交换机宕机、队列宕机、或者两者一同宕机的情况。这时候消息就石沉大海了，在不适用集群的情况下，来看看如何解决这一问题。

想象一下，假设是小黄寄了一个快递出去，在运输过程中出现在某些状况导致我的快递丢失，这时候快递公司会发一条消息告诉我快递丢失，并与我协商处理方案

在这里插入图片描述

搭建模拟环境

首先我们根据上图来搭建这个例子

编写配置文件

@Configuration
public class ConfirmQueueConfig {
    //声明交换机名称
    public static String CONFIRM_EXCHANGE = "confirm_exchange";
    //声明队列名称
    public static String CONFIRM_QUEUE = "confirm_queue";
    //声明routingKey
    public static String CONFIRM_ROURING_KEY = "confirm_rouring_key";

    //声明交换机
    @Bean
    public DirectExchange confirmExchange(){
        return new DirectExchange(CONFIRM_EXCHANGE);
    }

    //声明队列
    @Bean
    public Queue confirmQueue(){
        return new Queue(CONFIRM_QUEUE);
    }

    //绑定交换机和队列
    @Bean
    public Binding confirmQueueBindingExchange(@Qualifier("confirmExchange") DirectExchange confirmExchange,
                                               @Qualifier("confirmQueue") Queue confirmQueue){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM_ROURING_KEY);
    }
}

编写生产者

@GetMapping("/sendConfirmMsg/{message}")
public void sendConfirmMsg(@PathVariable String message){
    log.info("生产者正在发送消息：{}" , message);
    rabbitTemplate.convertAndSend(ConfirmQueueConfig.CONFIRM_EXCHANGE,ConfirmQueueConfig.CONFIRM_ROURING_KEY,message);
}

编写消费者

@Slf4j
@Component
public class ConfirmQueueConsumer {
    @RabbitListener(queues = "confirm_queue")
    public void receiveMsg(Message message){
        log.info("消费者接收到消息:{}", new String(message.getBody()));
    }
}

处理交换机宕机问题

配置RabbitMQ

spring:
  rabbitmq:
    publisher-confirm-type: correlated  # 默认是none，禁止使用发布确认模式，simple单个确认模式

编写回调函数

@Slf4j
@Component
public class MyCallback implements RabbitTemplate.ConfirmCallback {
    @Autowired
    RabbitTemplate rabbitTemplate;

    //注入自定义回调函数
    @PostConstruct
    private void init(){
        rabbitTemplate.setConfirmCallback(this);
    }

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        //交换机的回调函数
        if (ack){
            //接收成功
            log.info("交换机成功接收到id为{}的消息",correlationData.getId());
        }else {
            //接受失败
            log.error("交换机未接收到id为{}的消息，失败原因：{}",correlationData.getId(),cause);
        }
    }
}

修改生产者代码

发送消息给一个不存在的虚拟机，看是否能回复生产者

@GetMapping("/sendConfirmMsg/{message}")
public void sendConfirmMsg(@PathVariable String message){
    log.info("生产者正在发送消息：{}" , message);
    CorrelationData correlationData1 = new CorrelationData("1");
    rabbitTemplate.convertAndSend(ConfirmQueueConfig.CONFIRM_EXCHANGE,ConfirmQueueConfig.CONFIRM_ROURING_KEY,message,correlationData1);

    CorrelationData correlationData2 = new CorrelationData("2");
    //模拟交换机宕机，随便搞一个不存在的交换机
    rabbitTemplate.convertAndSend(ConfirmQueueConfig.CONFIRM_EXCHANGE + "2",ConfirmQueueConfig.CONFIRM_ROURING_KEY,message,correlationData1);
}

测试

启动测试，可以看到控制台确实能收到失败的消息，到此我们就解决了交换机宕机的问题

在这里插入图片描述

处理队列宕机问题

配置RabbitMQ

spring:
  rabbitmq:
    publisher-returns: true

编写回调函数

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

    //注入自定义回调函数
    @PostConstruct
    private void init(){
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
    }

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        //交换机的回调函数
        if (ack){
            //接收成功
            log.info("交换机成功接收到id为{}的消息",correlationData.getId());
        }else {
            //接受失败
            log.error("交换机未接收到id为{}的消息，失败原因：{}",correlationData.getId(),cause);
        }
    }

    //当消息不可到达目的地时，回退
    @Override
    public void returnedMessage(ReturnedMessage returned) {
        String msg = new String(returned.getMessage().getBody());
        log.error("消息:{}被服务器退回，退回原因:{}, 交换机是:{}, 路由 key:{}",
                msg,returned.getReplyText(),returned.getExchange(),returned.getRoutingKey());
    }
}

修改生产者代码

@GetMapping("/sendConfirmMsg/{message}")
public void sendConfirmMsg(@PathVariable String message){
    log.info("生产者正在发送消息：{}" , message);
    CorrelationData correlationData1 = new CorrelationData("1");
    rabbitTemplate.convertAndSend(ConfirmQueueConfig.CONFIRM_EXCHANGE,ConfirmQueueConfig.CONFIRM_ROURING_KEY,message,correlationData1);

    CorrelationData correlationData2 = new CorrelationData("2");
    //模拟队列宕机，写一个不存在的routigKey
    rabbitTemplate.convertAndSend(ConfirmQueueConfig.CONFIRM_EXCHANGE,ConfirmQueueConfig.CONFIRM_ROURING_KEY + "2",message,correlationData2);
}

测试

观察控制台输出，可以发现由于队列找不到的消息返回到了生产者

在这里插入图片描述

备份交换机

队列宕机之后，我们也需要通知人员来进行处理，这时候就用到了备份交换机，我们设置当消息到达不了目的地时，转发到备份交换机，通过备份队列来保存数据，通过报警队列告诉报警消费者

在这里插入图片描述

修改配置文件

在原先的配置文件上，我们需要新增备份交换机、备份队列、报警队列

@Configuration
public class ConfirmQueueConfig {
    //声明交换机名称
    public static String CONFIRM_EXCHANGE = "confirm_exchange";
    //声明队列名称
    public static String CONFIRM_QUEUE = "confirm_queue";
    //声明routingKey
    public static String CONFIRM_ROURING_KEY = "confirm_rouring_key";

    //声明备份交换机名称
    public static String ALTERNATE_EXCHANGE = "alternate_exchange";
    //声明备份队列名称
    public static String ALTERNATE_QUEUE = "alternate_queue";
    //声明报警队列名称
    public static String WARNING_QUEUE = "warning_queue";

    //声明备份交换机
    @Bean
    public FanoutExchange alternateExchange(){
        return new FanoutExchange(ALTERNATE_EXCHANGE);
    }

    //声明备份队列
    @Bean
    public Queue alternateQueue(){
        return new Queue(ALTERNATE_QUEUE);
    }

    //声明报警队列
    @Bean
    public Queue warningQueue(){
        return new Queue(WARNING_QUEUE);
    }

    //绑定备份队列和备份交换机
    @Bean
    public Binding alternateQueueBindingAlternateExchange(@Qualifier("alternateQueue") Queue alternateQueue,
                                                          @Qualifier("alternateExchange") FanoutExchange alternateExchange){
        return BindingBuilder.bind(alternateQueue).to(alternateExchange);
    }

    //绑定报警队列和备份交换机
    @Bean
    public Binding warningQueueBindingAlternateExchange(@Qualifier("warningQueue") Queue warningQueue,
                                                          @Qualifier("alternateExchange") FanoutExchange alternateExchange){
        return BindingBuilder.bind(warningQueue).to(alternateExchange);
    }

    //声明交换机
    @Bean
    public DirectExchange confirmExchange(){
        ExchangeBuilder exchangeBuilder = ExchangeBuilder.directExchange(CONFIRM_EXCHANGE).withArgument("alternate-exchange", ALTERNATE_EXCHANGE);
        return (DirectExchange) exchangeBuilder.build();
    }

    //声明队列
    @Bean
    public Queue confirmQueue(){
        return new Queue(CONFIRM_QUEUE);
    }

    //绑定交换机和队列
    @Bean
    public Binding confirmQueueBindingExchange(@Qualifier("confirmExchange") DirectExchange confirmExchange,
                                               @Qualifier("confirmQueue") Queue confirmQueue){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM_ROURING_KEY);
    }
}

新增报警消费者

@Slf4j
@Component
public class WarningQueueConsumer {
    @RabbitListener(queues = "warning_queue")
    public void receiveMsg(Message message){
        log.error("报警发现不可路由消息:{}", new String(message.getBody()));
    }
}

测试

通过控制台输出，我们可以看到报警消费者确实接收到了报警消息。

这里需要注意的是：当消息回退和备份交换机同时存在时，备份交换机的优先级高

在这里插入图片描述

贼爱学习的小黄
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4321
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
RabbitMQ：实现消息确认与消息返回
kaven
02-16 5181
不了解RabbitMQ的消息确认与消息返回可以参考下面两篇博客： RabbitMQ：消息确认机制 RabbitMQ：Return消息机制 pom.xml： <?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:schemaLoca
RabbitMQ——发布确认模式
万里顾一程的博客
03-02 463
单条发布确认（Single Publisher Confirm）是最基本的确认模式，在发布一条消息后，等待服务器确认该消息是否成功接收。异步确认是一种更灵活的确认方式，通过回调函数处理消息的确认和未确认事件。缺点：当一批消息中有一条消息发送失败时，整个批量确认失败，可能需要重新发送整批消息且不知道是哪条消息失败。批量发布确认模式允许在一次性确认多个消息是否成功被服务器接收，这在大量消息的场景中可以提高效率。RabbitMQ 发布确认模式的三种形式：单条确认、批量确认和异步确认。
RabbitMQ高级
weixin_43682323的博客
01-04 110
路由模式交换机} /*** 定义一个队列} /*** 队列绑定到交换机//with中的参数是路由key,即队列的名字即可 return BindingBuilder . bind(queue()) . to(exchange()) . with("msg.direct");}广播模式交换机/*** 广播交换机** @return。
SpringBoot RabbitMQ 入门学习（详细）
qq_37280924的博客
05-25 1462
目录安装 RabbitMQ初始化 SpringBoot 项目导入依赖添加配置配置文件 application.yml添加配置类 RabbitMqConfig简单队列发送者消费者测试类测试的 Controller单元测试类运行路由（交换机）创建一个交换机（Exchange）交换机与队列的绑定Topic Exchange修改 `Sender` 类的 `send` 方法测试Headers Exchange 自定义规则Fanout Exchange 订阅模式创建订阅交换机消失丢失开启RabbitMQ的数据持久化参考
rabbitmq学习
superprintf的博客
05-12 560
文章目录基礎direct模式fanouttopicheader事務負載均衡消息确认堆积丢失重复消费 基礎 direct模式 生產端創建並綁定交換機和隊列，其中重點關注queue的名字，exchange的名字，routingKey的名字 @Bean public Queue rabbitmqDemoDirectQueue() { /** * 1、name: 队列名称 * 2、durable: 是否持久化 * 3、ex
MQ消息队列之——RabbitMQ
06-01
学习RabbitMQ的学习笔记
RabbitMQ高级特性
最新发布
04-05
RabbitMQ高级特性
rabbitmq高级集群搭建
08-09
rabbitmq高级集群搭建
rabbitMQ发布和订阅共7页.pdf.zip
10-30
rabbitMQ发布和订阅共7页.pdf.zip
rabbitmq发布订阅
07-11
看了一天官方文档，自己写了一个发布订阅，已经用于我们的公网环境。
SpringBoot整合RabbitMQ系列--绑定交换机与队列的方法
IT利刃出鞘的博客
05-28 4807
本文用实例介绍SpringBoot中RabbitMQ如何绑定交换机与队列。
消息中间件-RabbitMQ
m0_46250446的博客
06-07 164
rabbitmq
rabbitmq使用详解
love_yr的博客
12-17 2092
rabbitmq使用详解
面试官：你说你会RabbitMQ，那聊聊它的交换机
m0_70109670的博客
05-04 641
channel.basicAck(message.getMessageProperties().getDeliveryTag(),false); log.info(“消息已确认”); } } 这两段代码都很好理解，不再赘述。 其中发送消息的代码有三个参数，第一个参数是Exchange的名称，第二个参数是routingKey的名称，这个参数在扇形交换机里面用不到，在其他两个交换机类型里面会用到。 代码的准备到此结束，我们可以运行发送方法之后run一下了~ 项目启动后，我们可以先来观察一下队列与交换机的绑定关系
RabbitMQ消息持久化总结
weixiaohuai的博客
07-06 8709
一、简介 在RabbitMQ中，如果遇到RabbitMQ服务停止或者挂掉，那么我们的消息将会出现丢失的情况，为了在RabbitMQ服务重启的情况下，不丢失消息，我们可以将Exchange（交换机）、Queue（队列）与Message（消息）都设置为可持久化的（durable）。这样的话，能够保证绝大部分的消息不会被丢失，但是还有有一些小概率会发生消息丢失的情况。下面通过一个简单的示例总结在Rab...
Rabbitmq学习笔记(尚硅谷2021)
qq_26630243的博客
08-28 4771
rabbitmq学习笔记（尚硅谷）
Spring Boot RabbitMQ - 交换器
spring_root的博客
02-25 415
1fanout exchange 发送到该交换器的所有消息，会被路由到其绑定的所有队列。不处理路由键。你只需要简单的将队列绑定到交换机上。一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。Fanout交换机转发消息是最快的。 如图所示，所有发送到fanout exchange的消息都会路由到QUEUE-1和Q...
05：RabbitMQ高级（狂神说RabbitMQ）
qq_44858230的博客
03-16 1988
RabbitMQ高级 - 过期时间TTL https://www.bilibili.com/video/BV1dX4y1V73G?p=44 概述 过期时间 TTl表示可以对消息设置预期的时间，在这个时间内都可以被消费者接收获取；过了之后消息将自动被删除。RabbitMQ可以对消息和队列设置 TTL，目前有两种方法可以设置 第一种方法是通过队列属性设置，队列中所有消息都有相同的过期时间 第二种方法是对消息进行单独设置，每条消息 TTL可以不同 如果上述两种方法同时使用，则消息的过期时间以两者 TTL较小的
rabbitmq发布确认高级
04-03
RabbitMQ发布确认是一种机制，用于确保消息在发送到队列之前已经被确认并接收。这个机制可以避免消息的丢失或者重复发送，从而保证消息的可靠性。 在RabbitMQ中，有两种类型的发布确认：基础确认和事务确认。 基础确认是一种异步确认机制，它在消息发送到RabbitMQ之后，立即返回一个确认信息给客户端。客户端可以在确认信息返回之前继续进行其他操作，但是需要等待确认信息的到达。如果消息发送失败，服务器将会返回一个拒绝信息给客户端。 事务确认是一种同步确认机制，它在消息发送到RabbitMQ之前，将消息放入一个事务中，并在确认信息返回之前等待事务的提交。如果事务提交失败，服务器将会返回一个回滚信息给客户端。 对于高级发布确认，我们需要使用基础确认机制。在使用基础确认机制时，我们需要将信道设置为确认模式，并在消息发送后等待确认信息的到达。如果消息发送失败，我们可以根据返回的拒绝信息进行相应的处理。如果确认信息没有到达，我们可以使用超时机制进行处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值