SpringBoot整合RabbitMQ 消息可靠投递、手动ack、延迟队列、死信队列、消息幂等性保障、消息积压

已于 2022-10-21 13:34:53 修改
阅读量2.2k 收藏 20
点赞数
分类专栏： 消息队列 文章标签： rabbitmq 手动ack 延迟队列 死信队列 消息可靠投递
于 2022-07-03 23:58:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Extraordinarylife/article/details/125589893
版权

1、消息可靠投递

在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。

  • confirm 确认模式
  • return 退回模式

rabbitmq 整个消息投递的路径为：

  • producer—>rabbitmq broker—>exchange—>queue—>consumer

  • 消息从 producer 到 exchange 则会返回一个 confirmCallback 。

  • 消息从 exchange–>queue 投递失败则会返回一个 returnCallback 。

  • 将利用这两个 callback 控制消息的可靠性投递

因SpringBoot 整合RabbitMQ 当队列或交换机不存在是，自动创建，所以可靠性检测的一般是服务是否宕机。与消费者是否接收/确认消息无无关

1.1、SpringBoot整合

生产端

  • yaml

    spring:
  rabbitmq:
    host: 192.168.0.134
    port: 5672
    username: admin
    password: admin
    virtual-host: /admin
    # 开启publisher-confirm 有以下可选值
    # simple：同步等待confirm结果，直到超时
    # correlated：异步回调，定义ConfirmCallback。mq返回结果时会回调这个ConfirmCallback
    # NONE：默认不开启
    publisher-confirm-type: correlated
    # 开启publish-return功能。可以定义ReturnCallback
    # true：调用ReturnCallback
    # false：直接丢弃消息
    publisher-returns: true

  • 自定义Callback类

    
/**
 * 消息推送确认机制配置文件
 * @author codinganhour
 */
@Component
public class PublisherConfirmAndReturnConfig implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnsCallback {

    @Autowired
    RabbitTemplate rabbitTemplate;

    /**
     * 初始化方法
     */
    @PostConstruct
    public void initMethod() {
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
    }

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String s) {
        Integer receivedDelay = null;
        if(null != correlationData){
            correlationData.getReturned().getMessage().getMessageProperties().getReceivedDelay();
        }
        if (receivedDelay != null && receivedDelay > 0) {
            // 是一个延迟消息，忽略这个错误提示
            return;
        }
        if (ack) {
            System.out.println("消息已经送达Exchange，ack已发");
        } else {
            System.out.println("消息没有送达Exchange");
        }
    }

    @Override
    public void returnedMessage(ReturnedMessage returnedMessage) {
        System.out.println("消息没有送到队列中");
    }
}

2、手动ACK确认机制

在RabbitMQ中指代的是消费者收到消息后确认的一种行为，关注点在于消费者能否实际接收到MQ发送的消息。

  • 自动Ack时，消费者接收消息后立即ack，然后慢慢处理，重启消费者会丢失消息。
  • 手动Ack时，消费者接收消息后，消息状态为 Unacked,如果消费的时候没有手动ack，则mq中的消息总量Total不会减少。

RabbitMQ默认的消息确认机制是：自动确认的

队列分配消息给监听消费者时，该消息处于未确认状态，不会被删除；当接收到消费者的确认回复才会将消息移除。

其提供了三种确认方式：

  • 自动确认acknowledge=“none”：当消费者接收到消息的时候，就会自动给到RabbitMQ一个回执，告诉MQ我已经收到消息了，不在乎消费者接收到消息之后业务处理的成功与否。

  • 手动确认acknowledge=“manual”：当消费者收到消息后，不会立刻告诉RabbitMQ已经收到消息了，而是等待业务处理成功后，通过调用代码的方式手动向MQ确认消息已经收到。当业务处理失败，就可以做一些重试机制，甚至让MQ重新向消费者发送消息都是可以的。

  • 根据异常情况确认acknowledge=“auto”：该方式是通过抛出异常的类型，来做响应的处理（如重发、确认等）。这种方式比较麻烦。

1.1、SpringBoot 整合RabbitMQ ACK

消费端

manual方式
  • yaml配置文件
    spring:
  rabbitmq:
    host: 192.168.0.134
    port: 5672
    username: admin
    password: admin
    virtual-host: /admin
    listener:
      # 容器类型simple或direct 简单理解为一对一；direct理解为一对多个消费者
      simple:
        # ACK模式(none,auto,manual,默认为auto)
        acknowledge-mode: manual
        # 开启重试
        retry:
          # 是否开启重试机制
          enabled: true
  • 消费者

/**
 * @author
 */
@Slf4j
@Component
public class DirectManualListener {


    /**
     * 消息最大重试次数
     */
    private static final int MAX_RETRIES = 3;

    /**
     * 重试间隔(秒)
     */
    private static final long RETRY_INTERVAL = 5;

    /**
     * 手动进入死信队列
     * RabbitListener中的参数用于表示监听的是哪一个队列
     */
    @RabbitListener(queues = DirectManualConfig.DIRECT_QUEUE)
    public void manualListenerQueue(String message, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag) throws Exception {

        // 重试次数
        int retryCount = 0;
        boolean success = false;
        // 消费失败并且重试次数<=重试上限次数
        while (!success && retryCount < MAX_RETRIES) {
            retryCount++;
            // 具体业务逻辑
            System.out.println("处理业务逻辑");
            // 如果失败则重试
            if (!success) {
                String errorTip = "第" + retryCount + "次消费失败" +
                        ((retryCount < 3) ? "," + RETRY_INTERVAL + "s后重试" : ",进入死信队列");
                log.error(errorTip);
                Thread.sleep(RETRY_INTERVAL * 1000);
            }
        }
        if (success) {
            // 消费成功，确认
            channel.basicAck(deliveryTag, false);
            log.info("创建订单数据消费成功");
        } else {
            // requeue：false 手动拒绝，进入抛弃或进入死信队列
            channel.basicNack(deliveryTag, false, false);
            log.info("创建订单数据消费失败");
        }

    }
}
auto方式
  • yaml配置文件
    spring:
  rabbitmq:
    host: 192.168.0.134
    port: 5672
    username: admin
    password: admin
    virtual-host: /admin
    listener:
      simple:
        # ACK模式(none,auto,manual,默认为auto)
        acknowledge-mode: auto
        # 开启重试
        retry:
          # 是否开启重试机制
          enabled: true
          # 最大重试次数，默认3
          max-attempts: 5
          # 重试间隔(ms) 默认1秒
          initial-interval: 500
          # 重试因子，默认是1。本次推送时间间隔 = 上一次间隔时间 * multiplier
          multiplier: 2
          # 最大间隔时间(ms)，默认10秒
          maxInterval: 20000
  • 消费者

@Slf4j
@Component
public class DirectAutoListener {


    /**
     * auto手动抛出异常方式进入死信队列，yaml中max-attempts，initial-interval生效
     * RabbitListener中的参数用于表示监听的是哪一个队列
     */
    @RabbitListener(queues = DirectManualConfig.DIRECT_QUEUE)
    public void autoListenerQueue(String message, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag) throws Exception {
        log.info("消息信息："+message+"；消息deliveryTag="+deliveryTag);
        Thread.sleep(1000);
        if(deliveryTag != 8){
            throw new RuntimeException("操作异常");
        }else{
            log.info("消息Ack deliveryTag="+deliveryTag);
            channel.basicAck(deliveryTag, false);
        }
    }
}

3、延迟队列

延迟队列，即消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费。

场景：

  1. 下单后，30分钟未支付，取消订单，回滚库存。

  2. 新用户注册成功7天后，发送短信问候。

实现方式：

  1. 定时器
    缺点：触发时，会扫描数据库，难以精确定位触发时间，数据量大时数据库承受压力过大；

  2. 延迟队列（TTL+死信队列组合实现延迟队列的效果）
    精确触发，触发时只查询单一数据即可
    在这里插入图片描述

延迟队列
在这里插入图片描述


/**
 * 延迟队列
 * @author
 */
@Slf4j
@Configuration
public class DirectTtlConfig {

    /**
     * direct路由模式-交换机
     */
    public static final String  DIRECT_EXCHANGE = "direct_ttl_exchange";
    /**
     * direct路由模式-队列
     */
    public static final String DIRECT_QUEUE = "direct_ttl_queue";
    /**
     * direct路由模式-路由键
     */
    public static final String DIRECT_ROUTING = "direct.ttl.routing";


    /**
     * direct路由模式-死信交换机
     */
    public static final String  DIRECT_DLX_EXCHANGE = "direct_ttl_dlx_exchange";
    /**
     * direct路由模式-死信队列
     */
    public static final String DIRECT_DLX_QUEUE = "direct_ttl_dlx_queue";
    /**
     * direct路由模式-路由键
     */
    public static final String DIRECT_DLX_ROUTING = "direct.ttl.dlx.routing";

    /**
     * 1、声明交换机
     * direct路由模式，默认持久化，非自动删除
     * @return
     */
    @Bean(DIRECT_EXCHANGE)
    public Exchange directTtlExchange(){

        return ExchangeBuilder.directExchange(DIRECT_EXCHANGE).build();
    }

    /**
     * 2、声明队列
     * direct路由模式
     * @return
     */
    @Bean(DIRECT_QUEUE)
    public Queue directTtlQueue(){
        // ttl：延迟队列时间，超时为消费则进入死信队列中
        // deadLetterExchange：绑定死信交换机
        // deadLetterRoutingKey：绑定死信路由
        return QueueBuilder.durable(DIRECT_QUEUE).ttl(1000).deadLetterExchange(DIRECT_DLX_EXCHANGE).deadLetterRoutingKey(DIRECT_DLX_ROUTING).build();
    }

    /**
     * 3、队列与交换机进行绑定
     * direct路由模式
     * @param queue @Qualifier 将 value 对应的bean 注入到参数中
     * @param exchange @Qualifier 将 value 对应的bean 注入到参数中
     * @return
     */
    @Bean
    public Binding directTtlQueueExchange(@Qualifier(DIRECT_QUEUE) Queue queue, @Qualifier(DIRECT_EXCHANGE) Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(DIRECT_ROUTING).noargs();
    }



    /**
     * 1、声明死信交换机
     * direct路由模式，默认持久化，非自动删除
     * @return
     */
    @Bean(DIRECT_DLX_EXCHANGE)
    public Exchange directDlxExchange(){

        return ExchangeBuilder.directExchange(DIRECT_DLX_EXCHANGE).build();
    }

    /**
     * 2、声明死信队列
     * direct路由模式
     * @return
     */
    @Bean(DIRECT_DLX_QUEUE)
    public Queue directDlxQueue(){
        return QueueBuilder.durable(DIRECT_DLX_QUEUE).build();
    }

    /**
     * 3、死信队列与死信交换机进行绑定
     * direct路由模式
     * @param queue @Qualifier 将 value 对应的bean 注入到参数中
     * @param exchange @Qualifier 将 value 对应的bean 注入到参数中
     * @return
     */
    @Bean
    public Binding directDlxQueueExchange(@Qualifier(DIRECT_DLX_QUEUE) Queue queue, @Qualifier(DIRECT_DLX_EXCHANGE) Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(DIRECT_DLX_ROUTING).noargs();
    }
}

消费者只需要监听死信队列中消息即可

4、死信队列

死信队列，英文缩写：DLX 。Dead Letter Exchange（死信交换机），当消息成为Dead message后，可以被重新发送到另一个交换机，这个交换机就是DLX。
在这里插入图片描述
死信的三种情况：

  1. 队列消息长度到达限制；

  2. 消费者拒接消费消息，basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false；（手动ack（auto,manual）都可以触发）

  3. 原队列存在消息过期设置，消息到达超时时间未被消费；

死信队列与延期队列实现方式一致，只是会监听2个消费者，正常队列采用ack（auto,manual）触发是否进入死信队列

QueueBuilder.durable(DIRECT_QUEUE).maxLength()：队列中等待消费的数量大于maxLength的数量就会进入死信队列

5、消息幂等性保障

幂等性指一次和多次请求某一个资源，对于资源本身应该具有同样的结果。也就是说，其任意多次执行对资源本身所产生的影响均与一次执行的影响相同。

在MQ中指，消费多条相同的消息，得到与消费该消息一次相同的结果。

处理方式

  • 传递消息唯一值记录数据库中或者redis中，消费时判断，防止重复消费

  • 更新数据库时可以采用乐观锁方式，关键字段值发生变化则不消费

6、消息积压

  • 消费者宕机积压
  • 消费者消费能力不足积压
  • 发送者发流量太大

解决方案:上线更多的消费者,进行正常消费上线专门的队列消费服务,将消息先批量取出来,记录数据库,再慢慢处理

CodingAnHour
关注
专栏目录
rabbitmq+springboot实现幂等性操作
weixin_43360488的博客
09-03 1425
举个例子：一个消息M发送到了消息中间件，消息投递到了消费程序A，A接受到了消息，然后进行消费，但在消费到一半的时候程序重启了，这时候这个消息并没有标记为消费成功，这个消息还会继续投递给这个消费者，直到其消费成功了，消息中间件才会停止投递。我们利用消息id来判断消息是否已经消费过，如果该信息被消费过，那么消息表中已经 会有一条数据，由于消费时会先执行插入操作，此时会因为主键冲突无法重复插入，我们就利用这个原理来进行幂等的控制,消息内容可以用json格式来进行传输的。1.开启手动ack配置。
rabbitmq幂等性，优先级队列，惰性队列
白鸽
07-15 432
14、RabbitMQ幂等性 用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用。 举个最简单的例子，那就是支付，用户购买商品后支付，支付扣款成功，但是返回结果的时候网络异常， 此时钱已经扣了，用户再次点击按钮，此时会进行第二次扣款，返回结果成功，用户查询余额发现多扣钱了，流水记录也变成了两条。在以前的单应用系统中，我们只需要把数据操作放入事务中即可，发生错误立即回滚，但是再响应客户端的时候也有可能出现网络中断或者异常等等 1、消息重复消费 消费者在消费 MQ 中的消息
SpringBoot优雅的封装不同研发环境下（环境隔离）RocketMq自动ack和手动ack
最新发布
qq_37557563的博客
08-12 1107
SpringBoot优雅的封装不同研发环境下（环境隔离）RocketMq自动ack和手动ack,并提供具体示例，亲测有效
SpringBoot集成RabbitMQ消息队列搭建与ACK消息确认入门
goldDaNiu的博客
11-23 817
1.Windows下安装RabbitMQ的步骤详解+图解（erlang+RabbitMQ） 2.SpringBoot集成RabbitMQ参考文章 1.RabbitMQ介绍 RabbitMQ是实现AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。RabbitMQ主要是为了实现系统之间的双向解耦而实现的。当生...
Springboot整合RabbitMQ Ack
Nov17的博客
03-08 875
Springboot整合RabbitMQ Ack 一、前言 ack指Acknowledge，确认。 表示消费端收到消息后的确认方式。 有三种确认方式： 自动确认：acknowledge=“none” 手动确认：acknowledge=“manual” 根据异常情况确认：acknowledge=“auto”，（这种方式使用麻烦，不作讲解） 其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。但是在实际业务处理
RabbitMQ模式，RabbitMQ和springboot整合，RabbitMQ全链路消息不丢失解决
aikui8441的博客
07-01 327
一，RabbitMQ简介 　　RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。 　　优点：跨语言，高并发。 二，实际项目中作用 （一）任务异步处理 场景：用户下单后，根据订单信息进行减库存...
SpringBoot整合Rabbitmq之消息的确认机制
桐花思雨
09-24 1579
这里写目录标题消息发送确认配置文件消息确认配置类消息找不到交换机消息到了交换机，找不到队列消息啥都找不到消息推送成功 本篇文章是继 springboot整合rabbitmq（一） 的续篇 消息发送确认 生产者发送消息，先将消息发送到 Exchange，然后由 Exchange 再路由到 Queue，这中间就需要确认两个事情 确认消息是否成功发送到 Exchange 确认消息是否从 Exchange 成功路由到 Queue spring 提供了两个回调函数来处理这两种消息发送确认 配置文件 server.
RabbitMQ延时队列及消息可靠性
MostSnails的博客
10-01 850
RabbitMQ延时队列及消息可靠性
RabbitMQ实现消息可靠投递
baobao的博客
07-08 1242
本文从本人博客搬运，原文格式更加美观，可以移步原文阅读：RabbitMQ实现消息可靠投递 实际开发中，我们经常需要保证消息由生产者发送到消费者接收并消费的整个过程中，消息不丢失，这就需要在RabbitMQ中实现消息的可靠投递。主要包含以下两部分： 发送端可靠性：指生产者发送消息到RabbitMQ Broker这个过程中保证消息不丢失 接收端可靠性：指RabbitMQ Broker将消息发送给消费者并且消费者正确处理消息的这个过程中保证消息不丢失 发送端可靠性 发送端可靠性主要包含3个方面： 消息抵达交
Spring Boot学习 RabbitMQ 消息队列(3) 延时队列的介绍和使用 保证消息可靠性的方法 解决 消息丢失 消息重复 消息积压
NeverGiveUp
09-21 318
Spring Boot学习 RabbitMQ 消息队列 基本概念 web端操作 SpringBoot整合 4.延时队列 实现定时任务 设置队列TTL的实现方式: 此次实现方式:使用同一个交换机的不同路由键实现 代码实现: 4.1 创建组件 package com.rwp.gulimail.order.config; import org.springframework.amqp.core.Binding; import org.springframework.amqp.core.Exch
消息队列-RabbitMQ
Roc的博客
07-16 1263
延迟队列是一种消息队列，它允许消息在被发送后延迟一定时间才被消费者处理。这意味着消息可以设定一个未来的时间点进行投递，直到达到指定的延迟时间后，消息才会被转移到另一个队列中供消费者消费。延迟队列常用于实现需要延时处理的任务，如定时任务、延迟通知等。优先级队列是一种支持按元素优先级顺序处理消息的队列。在这种队列中，每个消息被赋予一个优先级，高优先级的消息会先于低优先级的消息被消费处理，无论它们的到达顺序如何。优先级队列用于实现重要任务的优先处理等场景。
SpringBoot集成RabbitMq 手动ACK
weixin_45724872的博客
08-12 2302
之前一直是自动ACK，现在需要用到手动ACK； 但是我在网上找了一阵子，感觉都是比较旧的，我用的时候出一些奇奇怪怪的情况； 我自己摸索了一阵子，发现按如下方式是可以完成手动ACK的； 因为我目前用到的是fanout模式下的手动ACK； 因此我就以fanout模式为例子； 一、yml的配置 spring: rabbitmq: host: 127.0.0.1 port: 5672 username: msg password: msg virtual-host: t
springboot：整合rabbitmq之消息确认机制ack
拒绝熬夜啊的博客
06-14 1153
springboot：整合rabbitmq之消息确认机制ack
base rabbitmq springboot+rabbitmq 消息幂等性
qq_35573689的博客
02-24 233
direct one2many 的情况下，发送和消费的情况如下： 发送的消息是 one2many====>0 第1接受者接收到的额消息是one2many====>0 发送的消息是 one2many====>1 第2接受者接收到的额消息是one2many====>1 发送的消息是 one2many====>2 第3接受者接收到的额消息是one2many====...
SpringBoot+RabbitMQ 实现手动消息确认（ACK）
芋艿V
09-04 3487
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 10:33更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 E...
Springboot整合RabbitMQ手动ACK
菜鸟逆袭之路
04-05 5923
rabbitmq手动ack
Springboot2整合Rabbitmq消息确认机制、幂等性、重试机制
小猪呀的博客
07-08 1831
1.消息确认机制 友情提示该文章是跟着上一篇文章继续的，连接:https://blog.csdn.net/qq_41085151/article/details/107102962 问题1：如果在发送消息的时候，消费者出现了异常，那么你监听的消息就会一直循环消费。比如 一.提供者： @Component public class HelloProvider{ @Autowired private RabbitTemplate rabbitTemplate1; publi
springboot + rabbitmq ack
JustHaveTry的专栏
07-01 744
springboot + rabbitmq 消费者消息确认 （Ack） 开启消息确认 spring.rabbitmq.listener.direct.acknowledge-mode=manual spring.rabbitmq.listener.simple.acknowledge-mode=manual 消费者 @Component public class RabbitMqComponent...
springboot + rabbitmq发送邮件(保证消息100%投递成功并被消费)
weixin_30900589的博客
07-19 993
前言: RabbitMQ相关知识请参考: https://www.jianshu.com/p/cc3d2017e7b3 Linux安装RabbitMQ请参考: https://www.jianshu.com/p/ee9f7594212b Windows安装RabbitMQ请参考: https://www.jianshu.com/p/c7726ba4b046 一、先扔一张图 说明: 本文涵盖...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值