RabbitMQ 之 发布确认

最新推荐文章于 2024-07-02 15:02:43 发布
最新推荐文章于 2024-07-02 15:02:43 发布
阅读量655 收藏
点赞数
分类专栏： RabbitMQ 文章标签： java-rabbitmq rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42926863/article/details/126901255
版权

RabbitMQ 之 发布确认


在生产环境中由于一些不明原因，导致 RabbitMQ 重启，在RabbitMQ 重启期间生产者消息投递失败，导致消息丢失，需要手动处理和恢复。于是，我们开始思考，如何才能进行 RabbitMQ 的消息可靠投递呢？特别是在这样比较极端的情况，RabbitMQ 集群不可用的时候，无法投递的消息如何处理？

1.发布确认（springboot 版本）

1.1 确认机制方案

在这里插入图片描述

1.2 代码架构图

在这里插入图片描述

1.3 配置文件

在配置文件当中需要添加

spring.rabbitmq.publisher-confirm-type=correlated
  • NONE：禁用发布确认模式
  • CORRELATED：发布消息成功到交换器后会触发回调方法
  • SIMPLE：两种效果，其一，效果和 CORRELATED 值一样会触发回调方法；其二，在发布消息成功后使用 rabbitTemplate 调用 waitForConfirms 或 waitForConfirmsOrDie 方法等待 broker 节点返回发送结果，根据返回结果来判定下一步的逻辑，最要注意的是，waitForConfirmsOrDie 方法如果返回 false 则会关闭 channel，则接下来无法发送消息到 broker。
  • 在这里插入图片描述

1.4 添加配置类

package com.wpp.rabbitmq_csdn.publisherconfirm;

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 wpp
 * @Date 2022/09/17/10:08
 * @Description
 */
@Configuration
public class ConfirmConfig {

    public static final String CONFIRM_EXCHANGE_NAME = "confirm.exchange";
    public static final String CONFIRM_QUEUE_NAME = "confirm.queue";

    // 声明业务 Exchange
    @Bean("confirmExchange")
    public DirectExchange confirmExchange(){
        return new DirectExchange(CONFIRM_EXCHANGE_NAME);
    }

    //声明确认队列
    @Bean("confirmQueue")
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE_NAME).build();
    }

    // 声明绑定关系
    @Bean
    public Binding queueBinding(@Qualifier("confirmQueue") Queue queue,@Qualifier("confirmExchange") DirectExchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("key1");
    }


}

1.5 消息生产者

package com.wpp.rabbitmq_csdn.publisherconfirm;

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.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author wpp
 * @Date 2022/09/17/11:17
 * @Description
 */
@RestController
@Slf4j
public class Producer {
    public static final String CONFIRM_EXCHANGE_NAME = "confirm.exchange";

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("sendConfirmMessage/{message}")
    public void sendConfirmMessage(@PathVariable String message){
        // 指定消息 id 为 1
        CorrelationData correlationData1 = new CorrelationData("1");
        String routingKey1 = "key1";
        rabbitTemplate.convertAndSend(CONFIRM_EXCHANGE_NAME,routingKey1,message + routingKey1,correlationData1);

        CorrelationData correlationData2 = new CorrelationData("2");
        String routingKey2 = "key2";
        rabbitTemplate.convertAndSend(CONFIRM_EXCHANGE_NAME,routingKey2,message + routingKey2,correlationData2);

        log.info("发送消息内容：{}",message);

    }

}

1.6 回调接口

package com.wpp.rabbitmq_csdn.publisherconfirm;

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.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * @Author wpp
 * @Date 2022/09/17/11:19
 * @Description
 */
@Component
@Slf4j
public class MyCallBack implements RabbitTemplate.ConfirmCallback {

    @Autowired
    private RabbitTemplate rabbitTemplate;


    // 设置 rabbitTemplate 的回调对象
    @PostConstruct
    public void init(){
        rabbitTemplate.setConfirmCallback(this);
    }

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        String id = correlationData != null?correlationData.getId():"";
        if(ack){
            log.info("交换机已经收到id为：{}的消息",id);
        }else {
            log.info("交换机还未收到 id为：{}的消息，由于原因：{}",id,cause);
        }
    }
}

1.7 消息消费者

package com.wpp.rabbitmq_csdn.publisherconfirm;

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

/**
 * @Author wpp
 * @Date 2022/09/17/13:42
 * @Description
 */
@Component
@Slf4j
public class ConfirmConsumer {

    public static final String CONFIRM_QUEUE_NAME = "confirm.queue";

    @RabbitListener(queues = CONFIRM_QUEUE_NAME)
    public void receiveMsg(Message message){
        String msg = new String(message.getBody());
        log.info("接收到队列 confirm.queue 消息：{}",msg);
    }

}

1.8 结果分析

在这里插入图片描述
可以看到，RoutingKey 为“key1”和“key2”的两条消息都被交换机成功接收，也收到了确认回调（暂时还不知道如何模拟交换机接收不到消息￣□￣｜｜），因为第二条信息的 RoutingKey 与队列的 BindingKey 不一致，也没有其它队列能接收这个消息，所以第二条消息被直接丢弃了。

现在我们可以确保生产者到交换机之间的消息投递成功与否，那么交换机与队列之间怎么确保呢？比如：RoutingKey 为 key2 的消息，我们的生产者根本不知道此消息被丢弃了。

2. 回退消息

2.1 Mandatory 参数

在仅开启了生产者确认机制的情况下，交换机接收消息后，会直接给消息生产者发送确认消息，如果发现该消息不可路由，那么会被直接丢弃，此时生产者是不知道消息被丢弃这个事件的。那么如何让无法被路由的消息也帮我处理一下呢？起码通知我一声，我好自己处理啊。通过设置 mandatory 参数可以在消息传递过程中不可达目的的时候将消息返回给生产者。

2.2 消息生产者代码

加上以下代码：
在这里插入图片描述

2.3 回调接口

package com.wpp.rabbitmq_csdn.publisherconfirm;

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

import javax.annotation.PostConstruct;

/**
 * @Author wpp
 * @Date 2022/09/17/11:19
 * @Description
 */
@Component
@Slf4j
public class MyCallBack implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnCallback {

    @Autowired
    private RabbitTemplate rabbitTemplate;


    // 设置 rabbitTemplate 的回调对象
    @PostConstruct
    public void init(){
        rabbitTemplate.setConfirmCallback(this::confirm);
        rabbitTemplate.setReturnCallback(this::returnedMessage);
    }

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        String id = correlationData != null?correlationData.getId():"";
        if(ack){
            log.info("交换机已经收到id为：{}的消息",id);
        }else {
            log.info("交换机还未收到 id为：{}的消息，由于原因：{}",id,cause);
        }
    }

    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        log.error("消息{}，被交换机{}退回，退回原因：{}，RoutingKey：{}",new String(message.getBody()),exchange,replyText,routingKey);
    }
}

2.4 结果分析

在这里插入图片描述

3. 备份交换机

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

如果既不想丢失消息又不想增加生产者的复杂性，该怎么做呢？

前面在设置死信队列的文章中我们提到，可以为队列设置死信交换机来存储那些处理失败的消息，可是这些不可路由消息根本没机会进入到队列，因此无法使用死信队列来保存消息。在 RabbitMQ 中，有一种备份交换机的机制存在，可以很好的应对这个问题。

什么是备份交换机呢？

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

3.1 代码架构图

在这里插入图片描述

3.2 修改配置类

package com.wpp.rabbitmq_csdn.publisherconfirm;

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 wpp
 * @Date 2022/09/17/10:08
 * @Description
 */
@Configuration
public class ConfirmConfig {

    public static final String CONFIRM_EXCHANGE_NAME = "confirm.exchange";
    public static final String CONFIRM_QUEUE_NAME = "confirm.queue";

    public static final String BACKUP_EXCHANGE_NAME = "backup.queue";
    public static final String BACKUP_QUEUE_NAME = "back.queue";
    public static final String WARNING_QUEUE_NAME = "warning.queue";

    // 声明备份交换机
    @Bean("backupExchange")
    public FanoutExchange backupExchange(){
        return new FanoutExchange(BACKUP_EXCHANGE_NAME);
    }

    // 声明确认 Exchange
    @Bean("confirmExchange")
    public DirectExchange confirmExchange(){
        ExchangeBuilder exchangeBuilder = ExchangeBuilder.directExchange(CONFIRM_EXCHANGE_NAME)
                .durable(true).withArgument("alternate-exchange",BACKUP_EXCHANGE_NAME);
        return (DirectExchange) exchangeBuilder.build();
    }

    //声明确认队列
    @Bean("confirmQueue")
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE_NAME).build();
    }

    // 声明绑定关系
    @Bean
    public Binding queueBinding(@Qualifier("confirmQueue") Queue queue,@Qualifier("confirmExchange") DirectExchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("key1");
    }

    //声明警告队列
    @Bean("warningQueue")
    public Queue warningQueue(){
        return QueueBuilder.durable(WARNING_QUEUE_NAME).build();
    }

    // 声明警告队列绑定关系
    @Bean
    public Binding warningBinding(@Qualifier("warningQueue") Queue queue,@Qualifier("backupExchange") FanoutExchange backupExchange){
        return BindingBuilder.bind(queue).to(backupExchange);
    }

    // 声明备份队列
    @Bean("backupQueue")
    public Queue backQueue(){
        return QueueBuilder.durable(BACKUP_QUEUE_NAME).build();
    }

    //声明 备份队列绑定关系
    @Bean
    public Binding backupBinding(@Qualifier("backupQueue") Queue queue,@Qualifier("backupExchange") FanoutExchange backupExchange){
        return BindingBuilder.bind(queue).to(backupExchange);
    }


}

3.3 报警消费者

package com.wpp.rabbitmq_csdn.publisherconfirm;

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

/**
 * @Author wpp
 * @Date 2022/09/17/13:42
 * @Description
 */
@Component
@Slf4j
public class WarningConsumer {

    public static final String WARNING_QUEUE_NAME = "warning.queue";

    @RabbitListener(queues = WARNING_QUEUE_NAME)
    public void receiveMsg(Message message){
        String msg = new String(message.getBody());
        log.info("报警队列发现不可路由消息：{}",msg);
    }

}

3.4 测试注意事项

重启项目的时候需要把原来的 confirm.exchange 删除因为我们修改了其绑定属性，不然报错。

3.5 结果分析

在这里插入图片描述
mandatory 参数与备份交换机可以一起使用，如果两者同时开启，消息究竟何去何从？谁优先级高？经过上面结果显示，答案是备份交换机优先级高。

$驽马十驾$
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot整合RabbitMq 重写confirm不生效
FX_XU的专栏
11-03 1488
Spring Boot整合RabbitMq 重写confirm不生效
【尚硅谷 RabbitMQ】7、发布确认高级（SpringBoot版本）：回调接口、回退消息、备份交换机
土味儿
03-29 2342
在生产环境中由于一些不明原因，导致 RabbitMQ 重启。在 RabbitMQ 重启期间生产者消息投递失败，导致消息丢失，需要手动处理和恢复。 如何才能进行 RabbitMQ 的消息可靠投递呢？特别是在这样比较极端的情况，RabbitMQ 集群不可用的时候，无法投递的消息该如何处理呢？ 1、发布确认SpringBoot版本 1）确认机制方案 2）代码架构图 3）配置文件 spring: rabbitmq: host: 192.168.19.101 port: 5672 us
RabbitMq 消息确认和退回机制
最新发布
szchen2的博客
07-02 504
生产者将信道设置成 confirm 模式，一旦信道进入 confirm 模式，所有在该信道上面发布的消息都将会被指派一个唯一的 ID (从 1 开始)，一旦消息被投递到所有匹配的队列之后，broker 就会发送一个确认给生产者 (包含消息的唯一 ID)，这就使得生产者知道消息已经正确到达目的队列了，（单个），broker 回传给生产者的确认消息中 delivery-tag 域包含了确认消息的序列号。
CLR触发器通过RabbitMQ发布消息
weixin_30301183的博客
12-19 248
1.运行Visual Studio .Net。创建一个新的类库项目 这里选择.NET Framework3.5，因为我们的SQL SERVER 版本是2008，SQL SERVER 2008支持.NET Framework最高的版本就是3.5。 2.将Class1.cs文件中的类名更改为RabbitMQ_Sql 3.制作并生成dll文件 我们需要先导入Rabbit...
记一次 RabbitMq setConfirmCallback 没起作用的情况
weixin_44981329的博客
03-16 1163
所以在配置中加上了publisher-confirm-type: correlated，再次运行代码，发现可以正常进入到ConfirmCallback 中。消费者都已经成功消费了，但是没有打印进入setConfirmCallback。实现生产者投递消息到交换机的确认机制，以及消息由交换机投递到队列的错误返回机制。大家都知道是如下配置。自信满满的设置完成后想着运行下试试。至此问题结束，希望可以帮助到你。
RabbitMQ消息可靠投递机制:confirm方式 回调不成功解决方案
qq_45771848的博客
08-31 1517
rabbitMq消息可靠投递机制 confirm方式回调失败原因。
rabbitmq发布订阅
07-11
【标题】：“rabbitmq发布订阅”是分布式消息传递中的一个重要概念，它允许生产者发送消息到RabbitMQ服务器，而多个消费者可以订阅这些消息并进行处理。RabbitMQ是一个开源的消息代理和队列服务器，使用AMQP...
tp6使用rabbitmq
09-22
当消息被正确处理后，消费者需要发送一个确认信号给RabbitMQ，否则消息将被重新投递。同时，应妥善处理异常，避免因为错误导致消息丢失。 9. **队列监控**：通过RabbitMQ的管理界面或者第三方工具，可以实时监控...
消息队列(MQ)之RabbitMQ
10-07
RabbitMQ提供了一套完整的消息处理机制，包括消息确认、持久化等，确保消息的可靠传递。 4. **RabbitMQ的应用场景** - **任务调度**：如定时任务、批量处理等，消息队列可以将任务异步处理，避免阻塞主线程。 - *...
Delphi-RabbitMQ.zip
12-01
// 如果不需要重新处理，确认消息已被消费 Channel.BasicAck(DeliveryTag, false); end; ``` 以上就是使用Delphi与RabbitMQ集成的基本步骤。你可以根据实际需求调整这些代码，例如添加错误处理、使用不同的交换机...
Java rabbitMQ源码
11-06
6. **工作模式**：RabbitMQ支持多种工作模式，如发布/订阅、直接、主题、头部和扇出等。在Java代码中，通过选择不同的交换机类型和绑定键，可以实现这些模式。 7. **消息确认机制**：RabbitMQ支持消息确认，允许...
RabbitMQ消息可靠性之生产者消息确认
豆恭梓的博客
07-28 157
每个RabbitTemplate只能配置一个ReturnCallback，因此需要在项目加载时（实现ApplicationContextAware接口）配置：// 获取RabbitTemplate RabbitTemplate rabbitTemplate = applicationContext . getBean(RabbitTemplate . class);
Rabbitmq手动未确认解决方案
qq_44331428的博客
09-06 2564
通过配置死信队列，可以让未正确处理的消息暂存到另一个队列中，处理死信队列的消息一般有两种方式
RabbitMq（十三）消息发送确认与回调机制
liuhenghui5201的专栏
07-23 5621
在rabbitmq中如何确认消息发送到交换机上以及是否正常交换机转发到消息队列上，在rabbitmq上均有其确认实现接口。 confirm-callback ：消息确认机制，也就是消息是否正常发送到交换机的回调，内部可以实现正常与失败的区分处理。 return-callback：消息的失败回调处理，也就是消息通过交换机时没有正常转发到消息队列中时触发。 代码实现参考： pom文件 springboot的application.properties spring资源文件spring/spring-r
RabbitMq的http API调用
热门推荐
u013488838的专栏
03-01 1万+
最近做项目需要对rabbit消息队列进行有效验证查看了文档发现之后http的api能够验证先对api进行讲解在下面添加调用demo1.获取所有队列http://server:port/api/queues返回json字符串,需要认证 在demo中替换账号密码即可2.获取指定队列信息http://server:port/api/queues/vhost/name刚开始没有注意文档直接使用此路径去调用...
RabbitMQ 的重要概念（术语）
彳亍
08-24 453
1. 简介 MQ（Message Queue）消息队列是一种应用程序对应用程序的通信方法，应用程序通过读（出队）写（入队）队列的消息（针对应用程序的数据）进行通信。 MQ是消费者-生产者模型的典型代表，生产者往消息队列中不断写入消息，而消费者则可以读取或者订阅队列中的消息，并进行消息处理。 消息队列中间件是分布式系统中非常重要的组件，可适用于异步处理、应用解耦、流量削锋、消息通讯、日志处理等场景，实现高性能、高可用、可伸缩和最终一致性架构，是大型分布式系统中不可缺少的中间件。 比较常用的消息队列中间
RabbitMQ未确认消息处理
MRGCODING
09-28 1263
需要注意的是，两个回调处理的均为当前该回调的处理范围，成功的处理成功的，失败的处理失败的。实际如何用，可参考尚硅谷P37尚硅谷2021新版RabbitMQ教程丨快速掌握MQ消息中间件_哔哩哔哩_bilibili SortedSet<Long> confirmSet = Collections.synchronizedSortedSet(new TreeSet<Long>()); channel.confirmSelect(); channel.addConfir...
Rabbit回调接口与回退接口的使用
qq_24469795的博客
03-14 880
一、创建类并实现回调与回退接口 @Slf4j @Component public class MyCallBack implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnsCallback { } 实现 RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnsCallback中的接口 实现RabbitTemplate.ConfirmCallback接口 c
rabbitMQ消息队列中发布确认中的确认以及回退回调的实现
qmxqing的博客
09-03 1005
在发布确认回调实现类中 package com.it.springbootrabbitmq.callback; import lombok.extern.slf4j.Slf4j; import org.springframework.amqp.rabbit.connection.CorrelationData; import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.beans.facto
rabbitmq异步发布确认
03-21
可以使用RabbitMQ的Confirm模式来实现异步发布确认。在这种模式下，生产者将消息发送到RabbitMQ服务器，并等待服务器确认。如果服务器成功接收到消息，则会发送一个确认消息给生产者。如果服务器无法接收到消息，则会发送一个拒绝消息给生产者。生产者可以根据这些消息来确定是否需要重新发送消息。以下是使用RabbitMQ的Confirm模式实现异步发布确认的示例代码： ```python import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() # 开启Confirm模式 channel.confirm_delivery() # 发布消息 message = 'Hello, RabbitMQ!' if channel.basic_publish(exchange='my_exchange', routing_key='my_routing_key', body=message): print('Message published successfully.') else: print('Message failed to publish.') # 等待确认消息 if channel.waitForConfirms(): print('Message confirmed.') else: print('Message not confirmed.') connection.close() ``` 在上面的代码中，我们首先使用`channel.confirm_delivery()`方法开启Confirm模式。然后，我们使用`channel.basic_publish()`方法发布消息，并检查是否成功发布。最后，我们使用`channel.waitForConfirms()`方法等待确认消息，并根据返回值确定是否成功确认。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值