Spring Boot 实现 RabbitMQ 延迟消费

已于 2023-09-25 09:11:50 修改
阅读量1.6k 收藏 6
点赞数
分类专栏： # RabbitMQ 文章标签： java-rabbitmq
于 2020-09-06 17:18:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bbj12345678/article/details/108433250
版权

为什么要使用延迟队列

需求场景：
一 第三方支付平台的支付连接都是有时效性，创建订单后，需要再一定的时间内支付完成

  1. 微信支付、支付宝支付等
  2. 也可以不关闭订单，做订单二次支付的操作，但业务链路会更加复杂
  3. 电商业务里面还会涉及到商品库存的锁定和释放

延迟消息有两种实现方案：

1，基于死信队列
2，基于延迟插件

一、基于死信实现延迟消息

使用RabbitMQ来实现延迟消息必须先了解RabbitMQ的两个概念：死信和死信Exchange

1、消息什么时候变为死信(dead-letter)

  1. 消息被否定接收，消费者使用basic.reject 或者 basic.nack并且requeue 重回队列属性设为false。
  2. 消息在队列里得时间超过了该消息设置的过期时间（TTL）。
  3. 消息队列到达了它的最大长度，之后再收到的消息。

2、 死信交换机 Dead Letter Exchanges

死信交换机就是一种普通的exchange，和创建其他exchange没有两样。

当一个消息在队列里变为死信时，它会被重新publish到另一个exchange交换机上，这个exchange就为DLX。因此我们只需要在声明正常的业务队列时添加一个可选的"x-dead-letter-exchange"参数，值为死信交换机，死信就会被rabbitmq重新publish到配置的这个交换机上，我们接着监听这个交换机就可以了。

3、代码实现

创建配置类

/**
 * 基于死信队列实现延迟消费 相关配置
 */
@Configuration
public class DeadLetterRabbitConfig {

    //死信交换机，队列，路由相关变量
    public static final String EXCHANGE_DLX = "exchange.dlx";
    public static final String ROUTING_DLX = "routing.dlx";
    public static final String QUEUE_DLX = "queue.dlx";

    //业务交换机，队列，路由相关配置
    public static final String EXCHANGE_DEMO = "exchange.demo";
    public static final String ROUTING_DEMO = "routing.demo";
    public static final String QUEUE_DEMO = "queue.demo";

    // 定义业务交换机
    @Bean(name = "demoExchange")
    public DirectExchange demoExchange(){
        return new DirectExchange(EXCHANGE_DEMO,true,false,null);
    }

    // 定义业务队列
    @Bean
    public Queue demoQueue(){
        //添加x-dead-letter-exchange，值为死信交换机
        //参数x-dead-letter-routing-key可以修改该死信的路由key，不设置则使用原消息的路由key
        Map<String,Object> map = new HashMap<>();
        map.put("x-dead-letter-exchange",EXCHANGE_DLX);
        map.put("x-dead-letter-routing-key",ROUTING_DLX);
        return new Queue(QUEUE_DEMO,true,false,false,map);
    }

    @Bean
    public Binding demoBind(){
        return BindingBuilder.bind(demoQueue()).to(demoExchange()).with(ROUTING_DEMO);
    }


    @Bean(name = "dlxExchange")
    public DirectExchange dlxExchange(){
        return new DirectExchange(EXCHANGE_DLX,true,false);
    }

    @Bean
    public Queue dlxQueue(){
        return new Queue(QUEUE_DLX,true,false,false);
    }

    @Bean
    public Binding dlkBind(){
        return BindingBuilder.bind(dlxQueue()).to(dlxExchange()).with(ROUTING_DLX);
    }

}

生产者发送消息

    @GetMapping("sendDeadLettle")
    @ApiOperation(value = "测试延迟消费-基于死信队列")
    @ApiOperationSupport(order = 7)
    public String sendDeadLettle(String message,int time) {
        //exchange和routingKey都为业务的就可以，只需要设置消息的过期时间
        rabbitTemplate.convertAndSend(DeadLetterRabbitConfig.EXCHANGE_DEMO, DeadLetterRabbitConfig.ROUTING_DEMO,message,
                new MessagePostProcessor() {
                    @Override
                    public Message postProcessMessage(Message message) throws AmqpException {
                        //设置消息的过期时间，是以毫秒为单位的
                        String ttl = String.valueOf(time*1000);
                        message.getMessageProperties().setExpiration(ttl);
                        return message;
                    }
                }
        );
        log.info("生产者发送死信消息, time: {},msg: {}",DateUtils.dateTimeNow("yyyy-MM-dd HH:mm:ss"),message);
        return "ok";
    }

 消费者

@Component
@Slf4j
public class DeadLetterConsumer {

    @RabbitListener(queues = DeadLetterRabbitConfig.QUEUE_DLX)
    public void process(Message message, Channel channel) {
        // 消息序号
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        String msg = new String(message.getBody(), StandardCharsets.UTF_8);
        try {
            channel.basicAck(deliveryTag,false);
        } catch (IOException e) {
            /**
             * TODO 消费者消费消息异常，手动否认信息，将消息退回到队列中
             * tag：消息序号
             * multiple：消息的标识，是否确认多条，false只确认当前一个消息收到，true确认所有consumer获得的消息（成功消费，消息从队列中删除
             * requeue：是否要退回到队列
             */
            try {
                channel.basicNack(deliveryTag, true, false);
            } catch (IOException ex) {
            }
        }
        log.info("DeadLetterConsumer收到消息, time: {}, msg: {} " ,DateUtils.dateTimeNow("yyyy-MM-dd HH:mm:ss") ,msg);
    }

}

启动项目，打开rabbitmq控制台，可以看到交换机和队列已经创建好

生产者发送死信消息, time: 2023-09-24 13:18:19,msg: A
 ------生产者发送消息至exchange成功,消息唯一标识: null, 确认状态: true, 造成原因: null-----
DeadLetterConsumer收到消息, time: 2023-09-24 13:04:57, msg: A

从控制台的输出来看，刚好10s后接收到消息 

4、死信队列的一个小注意点

当我往死信队列中发送两条不同过期时间的消息时，如果先发送的消息A的过期时间大于后发送的消息B的过期时间时，由于消息的顺序消费，消息B过期后并不会立即重新publish到死信交换机，而是会等到消息A过期后一起被消费。

依次发送两个请求,消息A先发送，过期时间30S，消息B后发送，过期时间10S,我们想要的结果应该是10S收到消息B，30S后收到消息A，但结果并不是,

消息A30S后被成功消费，紧接着消息B被消费。因此当我们使用死信队列时应该注意是否消息的过期时间都是一样的，比如订单超过10分钟未支付修改其状态。如果当一个队列各个消息的过期时间不一致时，使用死信队列就可能达不到延时的作用。这时候我们可以使用延时插件来实现这需求。

二、基于延迟插件实现

1、安装插件

RabbitMQ Delayed Message Plugin是一个rabbitmq的插件，所以使用前需要安装它，可以参考的GitHub地址：https://github.com/rabbitmq/rabbitmq-delayed-message-exchange

将插件文件复制到RabbitMQ安装目录的plugins目录下；

进入RabbitMQ安装目录的sbin目录下，使用如下命令启用延迟插件

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

启用插件成功后就可以看到如下信息，之后重新启动RabbitMQ服务即可

 2、代码实现

  1. 安装好插件后只需要声明一个类型type为"x-delayed-message"的exchange，并且在其可选参数下配置一个key为"x-delayed-typ"，值为交换机类型(topic/direct/fanout)的属性。
  2. 声明一个队列绑定到该交换机
  3. 在发送消息的时候消息的header里添加一个key为"x-delay",值为过期时间的属性,单位毫秒。
  4. 代码就在上面，配置类为DMP开头的，发送消息的方法为send2()。
  5. 启动后在rabbitmq控制台可以看到一个类型为x-delayed-message的交换机

/**
 * 基于插件实现延迟消费 相关配置
 */
@Configuration
public class DeadLetterRabbit2Config {

    public static final String EXCHANGE_DMP = "exchange.dmp";
    public static final String ROUTING_DMP = "routing.dmp";
    public static final String QUEUE_DMP = "queue.dmp";


    //1、声明一个类型为x-delayed-message的交换机
    //2、参数添加一个x-delayed-type值为交换机的类型用于路由key的映射
    @Bean
    public CustomExchange dmpExchange(){
        Map<String, Object> arguments = new HashMap<>(1);
        arguments.put("x-delayed-type", "direct");
        return new CustomExchange(EXCHANGE_DMP,"x-delayed-message",true,false,arguments);
    }

    @Bean
    public Queue dmpQueue(){
        return new Queue(QUEUE_DMP,true,false,false);
    }

    @Bean
    public Binding dmpBind(){
        return BindingBuilder.bind(dmpQueue()).to(dmpExchange()).with(ROUTING_DMP).noargs();
    }

}
    @GetMapping("sendDeadLettle2")
    @ApiOperation(value = "测试延迟消费-基于插件")
    @ApiOperationSupport(order = 8)
    public String sendDeadLettle2(String message,int time) {
        rabbitTemplate.setMandatory(Boolean.FALSE);
        rabbitTemplate.convertAndSend(DeadLetterRabbit2Config.EXCHANGE_DMP, DeadLetterRabbit2Config.ROUTING_DMP,message,
                new MessagePostProcessor() {
                    @Override
                    public Message postProcessMessage(Message message) throws AmqpException {
                        //使用延迟插件只需要在消息的header中添加x-delay属性，值为过期时间，单位毫秒
                        message.getMessageProperties().setHeader("x-delay",time*1000);
                        return message;
                    }
                }
        );
        log.info("生产者发送死信消息, time: {},msg: {}",DateUtils.dateTimeNow("yyyy-MM-dd HH:mm:ss"),message);
        return "ok";
    }
@Component
@Slf4j
public class DeadLetterConsumer2 {

    @RabbitListener(queues = DeadLetterRabbit2Config.QUEUE_DMP)
    public void process2(Message message, Channel channel) {
        // 消息序号
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        String msg = new String(message.getBody(), StandardCharsets.UTF_8);
        try {
            channel.basicAck(deliveryTag,false);
        } catch (IOException e) {
            /**
             * TODO 消费者消费消息异常，手动否认信息，将消息退回到队列中
             * tag：消息序号
             * multiple：消息的标识，是否确认多条，false只确认当前一个消息收到，true确认所有consumer获得的消息（成功消费，消息从队列中删除
             * requeue：是否要退回到队列
             */
            try {
                channel.basicNack(deliveryTag, true, false);
            } catch (IOException ex) {
            }
        }
        log.info("DeadLetterConsumer2收到消息, time: {}, msg: {} " ,DateUtils.dateTimeNow("yyyy-MM-dd HH:mm:ss") ,msg);
    }

}

现在不会出现死信队列出现的问题

3、延时插件小问题

RabbitMQ延迟队列消息路由失败（312 NO_ROUTE）原因及处理

原因：延迟插件不支持mandatory=true参数，如果启用会同时收到延迟消息和路由失败消息

解决方法

设置mandatory=false

三、两种实现方式对比

死信队列

死信队列是这样一个队列，如果消息发送到该队列并超过了设置的时间，就会被转发到设置好的处理超时消息的队列当中去，利用该特性可以实现延迟消息。

延迟插件

通过安装插件，自定义交换机，让交换机拥有延迟发送消息的能力，从而实现延迟消息。

结论

由于死信队列方式需要创建两个交换机（死信队列交换机+处理队列交换机）、两个队列（死信队列+处理队列），而延迟插件方式只需创建一个交换机和一个队列，所以后者使用起来更简单。

fastjson_
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring Boot 中使用 RabbitMQ 入门
想吃凤梨酥的博客
05-23 269
介绍与安装 RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。RabbitMQ官方地址：http://www.rabbitmq.com 原理 这个这篇文章说的很好RabbitMQ原理详解 下载 RabbitMQ由Erlang语言开发，需要安装与RabbitMQ版本对应的Erlang语言环境，具体的就不解释了，自行搜索教程。RabbitMQ官网下载地
Spring Boot中集成 RabbitMQ
Dong滴个Dong的博客
01-20 176
SpringBoot 集成 RabbitMQ <!-- 在 pom 文件中添加 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId>...
rabbitmq的延时消费，精准延时消费
qq_41625866的博客
01-23 5789
DLX + TTL 方式存在的时序问题 对于延迟队列不管是 AMQP 协议或者RabbitMQ本身是不支持的，之前有介绍过如何使用 RabbitMQ 死信队列（DLX） + TTL 的方式来模拟实现延迟队列，这也是通常的一种做法，可参见我的另一篇文章利用 RabbitMQ 死信队列和 TTL 实现定时任务。 今天我想说的是这种方式会存在一个时序问题，看下图： 左侧队列 queue1 分别两条消息 msg1、msg2 过期时间都为 1s，输出顺序为 msg1、msg2 是没问题的 ...
SpringBoot集成RocketMQ实现延时消费
热门推荐
m0_37999219的博客
06-14 1万+
运行项目需要具备环境，参考。
RabbitMQ 如何使用延迟队列
最新发布
NeedForSpeed
05-10 626
假设我们正在设计一个线上售卖电影票的系统，用户购票后有 15 分钟时间进行付款，如果用户在 15 分钟内未付款，订单将自动取消并释放电影票库存。这里，我们可以利用 RabbitMQ 的延迟队列机制，在用户购票时发送一条延迟消息到 RabbitMQ，并设定延迟时间为 15 分钟。如果用户未在 15 分钟内完成付款，延迟消息将被消费者接收并处理订单取消的逻辑。，可以基于消息属性设置延迟时间，在设定的延迟时间后，将消息发送到目标队列。类型的交换机，并设定延迟队列，用于处理延迟消息。
spring.rabbitmq.template.mandatory 和spring.rabbitmq.publisher-returns
Java旅途
06-09 2170
在SpringBoot的RabbitMQ配置中，有如下一项： spring.rabbitmq.template.mandatory = true 官方注释： Enable mandatory messages. If a mandatory message cannot be routed to a queue by the server, it will return an unroutable message with a Return method. 大意为：开启强制消息投递（mandator
RabbitMQ 实现支付延时订单管理
PengLes
09-06 2345
RabbitMQ 实现支付延时订单管理
延时队列实现实战：如何利用 RabbitMQ 实现延时队列，以满足特定延迟处理需求
pengyi123的博客
04-03 1281
实现延时队列，可以通过RabbitMQ的死信队列（Dead-letter queue）特性，“死信队列”是当消息过期，或者队列达到最大长度时，未消费的消息会被加入到死信队列。然后，我们可以对死信队列中的消息进行消费，完成类似“延时”的效果。当RabbitMQ检测到消费者（如一个TCP连接）异常断开，例如因为消费者主机崩溃或因为网络问题，它将关闭该消费者的连接，并将消费者未确认的任何消息重新放入队列。在RabbitMQ中，对消息的优先级的支持是通过队列来实现的。在声明队列的时候，可以通过。
Spring Boot与RabbitMQ结合实现延迟队列的示例
08-28
在Spring Boot中实现基于RabbitMQ的延迟队列需要进行初始化工程、配置RabbitMQ、发送消息、消费消息等步骤。首先需要添加RabbitMQ的依赖项，然后配置RabbitMQ的连接信息，接着发送消息到队列中，最后消费者消费消息...
Spring Boot RabbitMQ 延迟消息实现完整版示例
08-27
在本文中，我们将深入探讨如何在Spring Boot应用中利用RabbitMQ实现延迟消息功能。延迟消息是一种机制，允许消息在特定延迟时间后才被消费者处理，这对于处理如订单超时、定时任务等场景非常有用。这里我们将使用...
Spring Boot RabbitMQ 延迟消息实现完整版
09-10
Spring Boot 已经对RabbitMQ Client API进行了包装，使用起来简洁很多，下面详细介绍一下如何利用rabbitmq_delayed_message_exchange 插件和Spring Boot来实现延迟消息。
rabbitmq延迟插件.zip
09-12
通过以上步骤，我们就成功地在Spring Boot应用中集成了RabbitMQ延迟插件，实现了延迟消息的发送和接收。需要注意的是，延迟时间是以毫秒为单位的，所以如果你想要消息在1分钟后投递，你应该传递60000毫秒。此外，你...
Rabbitmq延迟队列实现定时任务的方法
08-27
RabbitMQ 延迟队列实现定时任务的方法 RabbitMQ 延迟队列是一种实现定时任务的方法，它可以帮助我们在指定的时间点执行某个任务。这种方法可以应用在很多场景中，例如：在电子商城中，需要在指定的时间点关闭订单、...
RabbitMQ如何实现延迟消息？_rabbitmq消息延时消费
2401_84182578的博客
04-12 332
基于RabbitMQ的死信队列，可以实现延迟消息，非常灵活的实现定时关单，并且借助RabbitMQ的集群扩展性，可以实现高可用，以及处理大并发量。但是，死信队列的实现方式存在一个问题，那就是可能造成队头阻塞，因为队列时先进先出的，而且每次只会判断队头的消息是否过期，那么，如果队头的消息时间很长，一直都不过期，那么就会阻塞整个队列，这时候即使排在它后面的消息过期了，那么也会被一直阻塞。RabbitMQ中是可以实现延迟消息的，一般有两种方式，分别是通过死信队列以及通过延迟消息插件来实现。
MQ延迟消费
fall_hat的博客
02-23 414
1
RabbitMQ整合SpringCloud
weixin_43710113的博客
12-09 311
RabbitMQ整合 SpringCloud实战 注意一点，在发送消息的时候对template进行配置mandatory=true保证监听有效 生产端还可以配置其他属性，比如发送重试，超时时间、次数、间隔等 消费端核心配置 首先配置手工确认模式，用于ACK的手工处理，这样我们可以保证消息的可靠性送达，或者在消费端消费失败的时候可以做到重回队列、根据业务记录日志等处理 可以设置消费端的监听个数和最大...
RocketMQ源码(24)—延时消息实现原理解析
终生学习践行者
03-27 2340
基于RocketMQ release-4.9.3，深入的介绍了DefaultMQPushConsumer延迟消息源码。
[RabbitMQ] 消息确认模式在SpringBoot中的使用
ABIGJUN的博客
06-23 2109
RabbitMQ有两种消息确认模式： ① 消息发送确认 ② 消息消费确认 首先说一下消息发送确认模式： 消息确认模式也可以细分为两种： 第一种publisher-confirms模式，该模式只关心消息有没有被传递到指定Exchang，而不关心消息有没有被路由到queues 第二种publisher-returns模式，该模式会在消息没有被路由到queues时将消息返回 ...
RabbitMQ（5）RabbitMQ之可靠性投递配置
RichardGeek的博客
11-20 1772
1. 概述 mandatory和immediate是AMQP协议中basic.publish方法中的两个标识位，它们都有当消息投递过程中不可达目的地时将消息返回给生产者的功能。 mandatory 当mandatory标志位设置为true时，如果exchange根据自身类型和消息routeKey无法找到一个符合条件的queue，那么会调用basic.return方法将消息返回给生产者（Basic.Return + Content-Header + Content-Body）；当mandatory设置为fa
发送rabbitmq延迟队列消息 走到RabbitTemplate.ReturnsCallback
06-13
下面是使用 Spring Boot 和 RabbitMQ 实现 RabbitMQ 延迟队列的步骤： 1. 在 RabbitMQ 中创建一个延迟队列，可以通过 RabbitMQ 的插件 rabbitmq_delayed_message_exchange 来实现。具体操作可以参考官方文档。 2. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值