RabbitMQ实现延时消息的两种方法

最新推荐文章于 2024-09-21 11:31:16 发布
置顶 最新推荐文章于 2024-09-21 11:31:16 发布
阅读量5.7k 收藏 17
点赞数 7
分类专栏： 中间件 文章标签： rabbitmq 队列 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lan_kang/article/details/111305624
版权

文章目录

RabbitMQ实现延时消息的两种方法

1、死信队列

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

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

1.2死信队列的原理

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

1.3 代码实现

  1. 引入amqp依赖
  2. 声明交换机，队列
package com.lank.demo.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;

/**
 * @author lank
 * @since 2020/12/14 10:44
 */
@Configuration
public class RabbitmqConfig {

    //死信交换机，队列，路由相关配置
    public static final String DLK_EXCHANGE = "dlk.exchange";
    public static final String DLK_ROUTEKEY = "dlk.routeKey";
    public static final String DLK_QUEUE = "dlk.queue";

    //业务交换机，队列，路由相关配置
    public static final String DEMO_EXCHANGE = "demo.exchange";
    public static final String DEMO_QUEUE = "demo.queue";
    public static final String DEMO_ROUTEKEY = "demo.routeKey";

    //延时插件DelayedMessagePlugin的交换机，队列，路由相关配置
    public static final String DMP_EXCHANGE = "dmp.exchange";
    public static final String DMP_ROUTEKEY = "dmp.routeKey";
    public static final String DMP_QUEUE = "dmp.queue";

    @Bean
    public DirectExchange demoExchange(){
        return new DirectExchange(DEMO_EXCHANGE,true,false);
    }

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

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

    @Bean
    public DirectExchange dlkExchange(){
        return new DirectExchange(DLK_EXCHANGE,true,false);
    }

    @Bean
    public Queue dlkQueue(){
        return new Queue(DLK_QUEUE,true,false,false);
    }

    @Bean
    public Binding dlkBind(){
        return BindingBuilder.bind(dlkQueue()).to(dlkExchange()).with(DLK_ROUTEKEY);
    }


    //延迟插件使用
    //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(DMP_EXCHANGE,"x-delayed-message",true,false,arguments);
    }

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

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

}
  1. 声明一个类用于发送带过期时间的消息
package com.lank.demo.rabbitmq;

import com.lank.demo.config.RabbitmqConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author lank
 * @since 2020/12/14 10:33
 */
@Component
@Slf4j
public class MessageSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    //使用死信队列发送消息方法封装
    public void send(String message,Integer time){
        String ttl = String.valueOf(time*1000);
        //exchange和routingKey都为业务的就可以，只需要设置消息的过期时间
        rabbitTemplate.convertAndSend(RabbitmqConfig.DEMO_EXCHANGE, RabbitmqConfig.DEMO_ROUTEKEY,message, new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //设置消息的过期时间，是以毫秒为单位的
                message.getMessageProperties().setExpiration(ttl);
                return message;
            }
        });
        log.info("使用死信队列消息:{}发送成功,过期时间:{}秒。",message,time);
    }

    //使用延迟插件发送消息方法封装
    public void send2(String message,Integer time){
        rabbitTemplate.convertAndSend(RabbitmqConfig.DMP_EXCHANGE, RabbitmqConfig.DMP_ROUTEKEY,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("使用延迟插件发送消息:{}发送成功,过期时间:{}秒。",message,time);
    }
}
  1. 编写一个类用于消费消息
package com.lank.demo.rabbitmq;

import com.lank.demo.config.RabbitmqConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @author lank
 * @since 2020/12/15 15:57
 */

@Component
@Slf4j
public class MessageReceiver {

    @RabbitHandler
    @RabbitListener(queues = RabbitmqConfig.DLK_QUEUE)
    public void onMessage(Message message){
        log.info("使用死信队列，收到消息:{}",new String(message.getBody()));
    }

    @RabbitHandler
    @RabbitListener(queues = RabbitmqConfig.DMP_QUEUE)
    public void onMessage2(Message message){
        log.info("使用延迟插件，收到消息:{}",new String(message.getBody()));
    }
}
  1. 编写Controller调用发送消息方法测试结果
package com.lank.demo.controller;
import com.lank.demo.rabbitmq.MessageSender;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author lank
 * @since 2020/12/14 17:05
 */
@RestController
public class MessageController {

    @Autowired
    public MessageSender messageSender;

    //死信队列controller
    @GetMapping("/send")
    public String send(@RequestParam String msg,Integer time){
        messageSender.send(msg,time);
        return "ok";
    }

    //延迟插件controller
    @GetMapping("/send2")
    public String sendByPlugin(@RequestParam String msg,Integer time){
        messageSender.send2(msg,time);
        return "ok";
    }

}
  1. 配置文件application.properties
server.port=4399
#virtual-host使用默认的/就好，如果需要/demo需自己在控制台添加
spring.rabbitmq.virtual-host=/demo
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
  1. 启动项目，打开rabbitmq控制台，可以看到交换机和队列已经创建好。
    image
    rabbitmq2
  2. 在浏览器中请求http://localhost:4399/send?msg=hello&time=5，从控制台的输出来看，刚好5s后接收到消息。
2020-12-16 22:47:28.071  INFO 13304 --- [nio-4399-exec-1] c.l.rabbitmqdlk.rabbitmq.MessageSender   : 使用死信队列消息:hello发送成功,过期时间:5秒。
2020-12-16 22:47:33.145  INFO 13304 --- [ntContainer#0-1] c.l.r.rabbitmq.MessageReceiver           : 使用死信队列，收到消息:hello

1.4死信队列的一个小注意点

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

依次发送两个请求http://localhost:4399/send?msg=消息A&time=30和http://localhost:4399/send?msg=消息B&time=10,消息A先发送，过期时间30S，消息B后发送，过期时间10S,我们想要的结果应该是10S收到消息B，30S后收到消息A，但结果并不是,控制台输出如下：

2020-12-16 22:54:47.339  INFO 13304 --- [nio-4399-exec-5] c.l.rabbitmqdlk.rabbitmq.MessageSender   : 使用死信队列消息:消息A发送成功,过期时间:30秒。
2020-12-16 22:54:54.278  INFO 13304 --- [nio-4399-exec-6] c.l.rabbitmqdlk.rabbitmq.MessageSender   : 使用死信队列消息:消息B发送成功,过期时间:10秒。
2020-12-16 22:55:17.356  INFO 13304 --- [ntContainer#0-1] c.l.r.rabbitmq.MessageReceiver           : 使用死信队列，收到消息:消息A
2020-12-16 22:55:17.357  INFO 13304 --- [ntContainer#0-1] c.l.r.rabbitmq.MessageReceiver           : 使用死信队列，收到消息:消息B

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

2 、延时插件

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

2.1如何实现

  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的交换机。
    rabbitmq3
    rabbitmq4
  6. 继续在浏览器中发送两个请求http://localhost:4399/send2?msg=消息A&time=30和http://localhost:4399/send2?msg=消息B&time=10,控制台输出如下，不会出现死信队列出现的问题:
2020-12-16 23:31:19.819  INFO 13304 --- [nio-4399-exec-9] c.l.rabbitmqdlk.rabbitmq.MessageSender   : 使用延迟插件发送消息:消息A发送成功,过期时间:30秒。
2020-12-16 23:31:27.673  INFO 13304 --- [io-4399-exec-10] c.l.rabbitmqdlk.rabbitmq.MessageSender   : 使用延迟插件发送消息:消息B发送成功,过期时间:10秒。
2020-12-16 23:31:37.833  INFO 13304 --- [ntContainer#1-1] c.l.r.rabbitmq.MessageReceiver           : 使用延迟插件，收到消息:消息B
2020-12-16 23:31:49.917  INFO 13304 --- [ntContainer#1-1] c.l.r.rabbitmq.MessageReceiver           : 使用延迟插件，收到消息:消息A

死信交换机官网介绍:https://www.rabbitmq.com/dlx.html
延时插件GitHub:https://github.com/rabbitmq/rabbitmq-delayed-message-exchange

JavaLank
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
RabbitMQ延迟消息：死信队列 | 延迟插件 | 二合一用法+踩坑手记+最佳使用心得
「 虚幻私塾」
07-31 1151
RabbitMQ消息丢失|消息重复|消息积压的原因+解决方案+网上学不到的使用心得很多人加了我好友，说很喜欢这篇文章，也问了我一些问题。因为最近工作比较忙，隔了一段时间没写，忙完后专门花时间把RabbitMQ剩下的一个重要技术点通过案例的方式整理出来，就是延迟消息的用法。延迟消息含义不解释了，就是字面意思。用法一共两种方式，死信队列和延迟插件，两种各有利弊，我会一一陈述并给出最佳用法。总结下来就以下几点1）、不管用不用，在安装RabbitMQ时就顺便把延迟插件也装上；推荐吧~我。...
Delayed Message 插件实现 RabbitMQ 延迟队列
Docker的专栏
04-14 976
延迟队列是为了存放那些延迟执行的消息，待消息过期之后消费端从队列里拿出来执行。DLX + TTL 方式存在的时序问题对于延迟队列不管是 AMQP 协议或者 RabbitMQ 本身是不支...
RabbitMQ中如何实现消息的延时发送？
最新发布
qq_33240556的博客
09-21 765
以上介绍的方法各有优缺点，选择哪种方法取决于具体的应用场景和技术要求。例如，使用TTL结合死信队列的方法可以在不改变现有架构的基础上实现延时发送；使用Timer或Sleep机制简单易行，但可能会影响性能；使用第三方插件或扩展则可以提供更专业的解决方案。在实际应用中，可以根据项目的需求和技术栈选择最合适的方法。
RabbitMQ---延迟消息
Mai_Jun_Hao的博客
01-23 6413
主要分析RabbitMQ延迟消息的实现方式，延迟队列使用消息过期时间及死信队列实现，延迟消息插件较上面的方法更便捷
微服务—RabbitMQ高级（延迟消息）
向上的咸鱼blueblue的博客
02-20 1049
本文详细讨论了RabbitMQ中实现延迟消息的两种方案
RabbitMQ实现消息队列延迟功能
pan_junbiao的博客
01-16 7965
要实现延迟功能，一般使用RabbitMQ 的消息队列延迟功能，即采用官方提供的插件 “rabbitmq_delayed_message_exchange” 来实现。但RabbitMQ 版本必须是 3.5.8 以上才支持该插件，否则得用其“死信”功能。 1、安装RabbitMQ延迟插件 （1）检查插件 使用 rabbitmq-plugins list命令用于查看RabbitMQ安装的插件。 打开一个新的cmd窗口（按快捷键“Win+R”，输入“cmd”）。 运行命令：rabbitmq-plug...
Rabbitmq延迟消息
Knight
08-14 1166
只是在某一个设置Dead Letter Exchange的队列中有消息过期了，会自动触发消息的转发，发送到Dead Letter Exchange中去。对队列设置就是队列没有消费者连着的保留时间，也可以对每一个单独的消息做单独的设置。我们创建一个队列queue.temp，在Arguments 中添加x-message-ttl 为5000 （单位是毫秒），那所在压在这个队列的消息在5秒后会消失。一个消息在满足如下条件下，会进死信路由，记住这里是路由而不是队列，一个路由可以对应很多队列。如何保证消息幂等性？
SpringBoot整合RabbitMQ实现延时队列
PGL2009的博客
12-12 2317
组件的版本 SpringBoot : V2.5.5 RabbitMQ: 3.9.9 延时队列 延时队列的典型应用场景，例如购买火车票，下单占座后20分钟内未支付的订单会被强制取消，避免在余票紧张的情况下，车票一直被占用，其他人无法购买。还有电商平台，客户下单后，订单进入购物车，如果购物车内的订单超过特定时间未支付，则会失效，回滚库存。 RabbitMQ实现延时队列 利用 RabbitMQ 做延时队列是比较常见的一种方式，而实际上RabbitMQ 自身并没有直接支持提供延迟队列功能，而是通过 RabbitMQ
RabbitMQ 延时消息实现方式
web15085599741的博客
07-29 1128
先声明一个消费队列queue_dlx，用来接收死信消息，并提供消费；然后声明一个死信exchange_dlx,绑定queue_dlx，接收消息后路由至queue_dlx；声明一个延迟队列，queue_delay,用来接收业务消息，但不提供消费，等待消息死亡后转至死信exchange。（即延迟）声明一个exchange，由业务发送消息到exchange，然后转至queue_delay.一个消息的流程大概是RabbitMQ实现固定延时等级的延时消息。...
rabbitmq-delayed-message-exchange:RabbitMQ 的延迟消息传递
08-04
RabbitMQ 延迟消息插件 这个插件为 RabbitMQ 添加了延迟消息（或预定消息）。 用户可以声明类型为x-delayed-message的交换，然后发布带有自定义标头x-delay消息，以毫秒为单位表示消息的延迟时间。 消息将在x-delay毫秒后传递到相应的队列。 支持的 RabbitMQ 版本 此插件的最新版本针对 RabbitMQ 3.8.x。 较早的系列。 支持的 Erlang/OTP 版本 此插件，与 RabbitMQ 3.8.16+ 相同。 项目成熟度 这个插件被认为是实验性的，但相当稳定，只要用户意识到它的局限性，就可能适合生产使用。 它存在一些问题，并且在其存在的大约 18 个月内修复了一个基本问题。 众所周知，它对某些用户来说工作得相当好。 它还具有已知的限制（请参阅下面的一节），包括与延迟和消息的复制以及延迟消息的数量相关的限制。 Pivotal 目前还
springboot整合RabbitMQ实现延时队列的两种方式 教程及源码
06-29
springboot整合RabbitMQ实现延时队列的两种方式 教程及源码。参考博客：https://blog.csdn.net/qq_29914837/article/details/94070677
RabbitMQ延迟消息
qq1157255405的博客
02-17 2060
第二种 假设第一条消息的过期时间为30s 第二条消息为10s 但是因为实现方式问题, 队列为先进先出 ,所以只有第一条30s消费完后才会消费10s的消息 所以是满足不了场景。原理: 发送带有过期时间的消息到正常队列中,但是没有消费者,不进行消费,等待消息超时后会被自动投放到死信队列中,消费者直接消费死信队列中的消息。1.创建正常的交换机和队列,死信交换机和死信队列, 队列绑定死信交换机和死信routing-key。第一种方法是通过队列属性设置，队列中所有消息都有相同的过期时间。3.监听死信队列中的消息。
RabbitMQ之延迟消息
浩泽学编程的博客
11-27 1442
死信交换机、延迟消息、死信交换机实现延迟消息、插件实现延迟消息
RabbitMQ之延迟队列
CSDN_LiMingfly的博客
05-01 1204
RabbitMQ 提供了过期时间 TTL 机制，可以设置消息在队列中的存活时长。在消息到达过期时间时，会从当前队列中删除，并被 RabbitMQ 自动转发到对应的死信队列中。延迟消息就是指当消息被发送以后，并不想让消费者立即拿到消息，而是等待指定时间后，消费者才拿到这个消息进行消费。2:利用 RabbitMQ 中的插件 x-delay-message。然后再来消费该死信队列，这样就可以实现一个延迟队列的效果。失败重试：业务操作失败后，间隔一定的时间进行失败重试。此种方式需要安装mq的延迟第一列插件。
一起来学SpringBoot | 第十三篇：RabbitMQ延迟队列
唐亚峰
05-31 3870
SpringBoot 是为了简化 Spring 应用的创建、运行、调试、部署等一系列问题而诞生的产物，自动装配的特性让我们可以更好的关注业务本身而不是外部的XML配置，我们只需遵循规范，引入相关的依赖就可以轻易的搭建出一个 WEB 工程 初探RabbitMQ消息队列中介绍了RabbitMQ的简单用法，顺带提及了下延迟队列的作用。所谓延时消息就是指当消息被发送以后，并不想让消费者立即拿到消...
RabbitMQ延迟消息基于插件x-delayed-message
limpiditysky的博客
02-28 6617
下载插件 地址：https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/tags 下载的插件放到rabbitmq安装目录的plugins里面，重启rabbitmq就可以了。 声明交换机和队列 import org.springframework.amqp.core.Binding; import org.springframework.amqp.core.BindingBuilder; import org.springframework
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值