RabbitMQ——延迟队列

最新推荐文章于 2024-05-01 10:42:04 发布
最新推荐文章于 2024-05-01 10:42:04 发布
阅读量2.6k 收藏 2
点赞数
分类专栏： 消息队列 文章标签： rabbitmq java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44289860/article/details/123392882
版权

1. 延迟队列

1.1 概念

延迟队列内部是有序的，其中的元素是希望在指定时间到了之后取出或者处理，总之就是用来存放需要在指定时间被处理的元素的队列。

1.2 使用场景

用来在一定时间间隔内对相应的事件做出提醒或者操作。

1.3 整合SpringBoot

正常新建SpringBoot项目即可。SpringBoot版本为2.5.6，如果版本过高与Swagger2版本相差过大就会抛出异常。
添加依赖：

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.5.6</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.78</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

新增Swagger配置类：

/**
 * @Description swagger配置类
 * @date 2022/3/10 9:39
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket webApiConfig(){
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("webApi")
                .apiInfo(webApiInfo())
                .select()
                .build();
    }

    private ApiInfo webApiInfo(){
        return new ApiInfoBuilder()
                .title("RabbitMQ接口文档")
                .description("RabbitMQ文档接口定义")
                .version("1.0")
                .contact(new Contact("RabbitMQ","https://www.baidu.com"
                        ,"baidu@qq.com"))
                .build();
    }
}

配置文件：

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

1.4 延迟队列实战

1.4.1 图示

在这里插入图片描述

  1. P：生产者；
  2. X：普通交换机；
  3. Y：延迟交换机；
  4. QA：延迟10s普通队列；
  5. QB：延迟40s普通队列；
  6. QD：死信队列；
  7. C：消费者。
1.4.2 队列配置

主要是基于SpringBoot方式将队列交换机RotingKey等绑定起来。

/**
 * @Description ttl 队列配置文件
 * @date 2022/3/10 9:53
 */
@Configuration
public class TtlQueueConfig {

    // 普通交换机
    private static final String X_EXCHANGE = "X";

    // 死信交换机
    private static final String DEAD_LETTER_Y_EXCHANGE = "Y";

    // 普通队列
    private static final String QUEUE_A = "QA";
    private static final String QUEUE_B = "QB";

    // 死信队列
    private static final String DEAD_LETTER_QUEUE_D = "QD";

    // 设置普通交换机
    @Bean("xExchange")
    public DirectExchange xExchange(){
        return new DirectExchange(X_EXCHANGE);
    }

    // 设置死信交换机
    @Bean("yExchange")
    public DirectExchange yExchange(){
        return new DirectExchange(DEAD_LETTER_Y_EXCHANGE);
    }

    // 设置普通队列
    @Bean("queueA")
    public Queue aQueue(){
        Map<String ,Object> argument = new HashMap<>();
        // 设置死信交换机
        argument.put("x-dead-letter-exchange",DEAD_LETTER_Y_EXCHANGE);
        // 设置死信RoutingKey
        argument.put("x-dead-letter-routing-key","YD");
        // 设置过期时间
        argument.put("x-message-ttl",10000);
        return QueueBuilder.durable(QUEUE_A).withArguments(argument).build();
    }

    @Bean("queueB")
    public Queue bQueue(){
        Map<String ,Object> argument = new HashMap<>();
        // 设置死信交换机
        argument.put("x-dead-letter-exchange",DEAD_LETTER_Y_EXCHANGE);
        // 设置死信RoutingKey
        argument.put("x-dead-letter-routing-key","YD");
        // 设置过期时间
        argument.put("x-message-ttl",40000);
        return QueueBuilder.durable(QUEUE_B).withArguments(argument).build();
    }


    // 设置死信队列
    @Bean("queueD")
    public Queue dQueue(){
        return QueueBuilder.durable(DEAD_LETTER_QUEUE_D).build();
    }

    /**
     * 队列A绑定交换机X
     * @return
     */
    @Bean
    public Binding queueABindingX(@Qualifier("queueA") Queue queueA,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueA).to(xExchange).with("XA");
    }

    /**
     * 队列B绑定交换机X
     * @return
     */
    @Bean
    public Binding queueBBindingX(@Qualifier("queueB") Queue queueB,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueB).to(xExchange).with("XB");
    }

    /**
     * 队列D绑定交换机Y
     * @return
     */
    @Bean
    public Binding queueDBindingY(@Qualifier("queueD") Queue queueD,
                                  @Qualifier("yExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueD).to(xExchange).with("YD");
    }

}
1.4.3 控制器模拟生产者发送消息
/**
 * @Description 接收消息控制器
 * @date 2022/3/10 10:49
 */
@Slf4j
@RestController
@RequestMapping("/ttl")
public class SendMessageController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/sendMsg/{message}")
    public void sendMsg(@PathVariable String message){
        log.info("当前时间：{}，发送一条信息给TTL队列：{}",new Date().toString(),message);
        // 执行发送消息到X交换机RoutingKey为XA，XB
        rabbitTemplate.convertAndSend("X","XA","消息来自TTL为10s的队列" + message);
        rabbitTemplate.convertAndSend("X","XB","消息来自TTL为40s的队列" + message);
    }

}
1.4.4 消费者
/**
 * @Description 接收死信队列消费者
 * @date 2022/3/10 15:29
 */
@Slf4j
@Component
public class DeadLetterConsumer {


    // 声明队列监听器，监听死信队列QD
    @RabbitListener(queues = "QD")
    public void receiveD(Message message, Channel channel){
        String msg = new String(message.getBody());
        log.info("当前时间：{},收到来自死信队列消息：{}",new Date().toString(),msg);
    }

}
1.4.5 测试和结果

测试方式：访问http://localhost:8088/ttl/sendMsg/测试，访问了这个界面之后控制器会发送一条消息到正常的交换机中，等待10/40秒后会进入死信队列由消费者接收。
在这里插入图片描述

1.5 优化延迟队列

上方设计中，每新增一个时间需求就需要新增一个队列，这样会占有较多的资源，并且不便于管理。

1.5.1 图示

在这里插入图片描述
优化思路：在原先项目的基础上新增一个先不对时间进行限制队列QC，QC的时间限制在生产者发送消息的时候指定。

1.5.2 队列配置

在原先的配置基础上进行修改，新增队列QC，并且绑定它和交换机X，Y的关系。

声明队列：

private static final String QUEUE_C = "QC";

配置队列：

  public Queue cQueue(){
        Map<String ,Object> argument = new HashMap<>();
        // 设置死信交换机
        argument.put("x-dead-letter-exchange",DEAD_LETTER_Y_EXCHANGE);
        // 设置死信RoutingKey
        argument.put("x-dead-letter-routing-key","YD");
        return QueueBuilder.durable(QUEUE_C).withArguments(argument).build();
    }

绑定交换机：

/**
     * 队列C绑定交换机X
     * @return
     */
    @Bean
    public Binding queueCBindingX(@Qualifier("queueC") Queue queueC,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueC).to(xExchange).with("XC");
    }
1.5.3 新增控制器方法
/**
     * 发送过期时间和消息
     * @param time 过期时间，单位毫秒
     * @param message 消息
     */
    @GetMapping("/sendTimeAndMsg/{time}/{message}")
    public void sendTimeAndMsg(@PathVariable String time,@PathVariable String message){
        log.info("当前时间：{}，发送一条延迟{}毫秒的信息给TTL队列：{}",new Date().toString(),time,message);
        rabbitTemplate.convertAndSend("X",
                "XC",
                "来自交换机X延迟为" + time +"毫秒的消息：" + message,
                msg -> {
                    //  设置时间
                    msg.getMessageProperties().setExpiration(time);
                    return msg;
                }) ;

    }
1.5.4 测试

依次访问：
http://localhost:8088/ttl/sendTimeAndMsg/20000/20sMessage，
http://localhost:8088/ttl/sendTimeAndMsg/2000/2sMessage

按照上方的延迟时间，如果相隔的时间不超过20秒，应该是先收到延迟为2秒的消息。在这里插入图片描述但是显然并不是按照两秒的时间来进行接收的。这就引出了一个新的问题：RabbitMQ只会检测第一个消息是否过期，只要第一条没有到期后面的也不会优先得到执行。

1.6 基于插件延迟队列

1.6.1 优势

在使用插件之前：
使用了插件之后：
在这里插入图片描述
也就是说消息停留在生产者将消息发送给交换机之后，等停留的时间过了之后，交换机才会将消息发给队列，并且只需要一个队列和一个交换机即可完成。

1.6.2 安装插件

下载插件：https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases

下载之后的ez文件复制到RabbitMQ安装目录下的plugins文件夹下，然后使用cmd进入到RabbitMQ安装目录下的sbin文件夹下运行：

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

如图：
在这里插入图片描述
然后进入到web端，随便新增一个交换机，可以看到下拉框中多了一个x-delayed-message选项：
在这里插入图片描述
这里就表示安装完成了。

1.6.3 实战
1.6.3.1 图示

直接将消息发送给交换机，交换机等待相应时间之后再发给队列。
在这里插入图片描述

1.6.3.2 配置类
/**
 * @Description 延迟队列配置类
 * @date 2022/3/10 19:18
 */
@Configuration
public class DelayedQueueConf {

    // 交换机
    private static final String DELAYED_EXCHANGE = "delayed.exchange";

    // 队列
    private static final String DELAYED_QUEUE = "delayed.queue";

    // rotingKey
    private static final String DELAYED_ROUTING_KEY = "delayed.routingKey";

    /**
     * 注入队列
     * @return
     */
    @Bean("delayQueue")
    public Queue delayedQueue(){
        return new Queue(DELAYED_QUEUE);
    }


    /**
     * 注入交换机
     * @return
     */
    @Bean
    public CustomExchange delayedExchange(){
        Map<String ,Object> args = new HashMap<>();
        // 延迟类型
        args.put("x-delayed-type","direct");
        /**
         *      1. 名称
         *      2. 类型
         *      3. 是否持久化
         *      4. 是否自动删除
         *      5. 其他参数
         */
        return new CustomExchange(DELAYED_EXCHANGE,"x-delayed-message",
                false,false,args);
    }

    /**
     * 绑定延迟队列和交换机，routingKey
     * @param queue 队列
     * @param customExchange 交换机
     * @return
     */
    @Bean
    public Binding delayQueueBindingDelayExchange(@Qualifier("delayQueue") Queue queue,
                                                  @Qualifier("delayedExchange") CustomExchange customExchange){
        return BindingBuilder.bind(queue).to(customExchange).with(DELAYED_ROUTING_KEY).noargs();
    }

}
1.6.3.4 生产者控制器
    /**
     * 基于插件的延迟队列
     * @param time 延迟时间 , 单位毫秒
     * @param message 消息内容
     */
    @GetMapping("/sendTimeAndMsgByPlugins/{time}/{message}")
    public void sendTimeAndMsgByPlugins(@PathVariable Integer time,@PathVariable String message){
        log.info("当前时间：{}，发送一条延迟{}毫秒的信息给延迟队列：{}",new Date().toString(),time,message);
        rabbitTemplate.convertAndSend("delayed.exchange",
                "delayed.routingKey",message,
                msg -> {
                    msg.getMessageProperties().setDelay(time);
                    return msg;
        });
    }
1.6.3.5 消费者监听
/**
 * @Description 延迟队列消费者——基于插件
 * @date 2022/3/10 19:34
 */
@Slf4j
@Component
public class DelayQueueConsumer {


    // 声明队列监听器，监听死信队列QD
    @RabbitListener(queues = "delayed.queue")
    public void receiveD(Message message){
        String msg = new String(message.getBody());
        log.info("当前时间：{},收到来自死信队列消息：{}",new Date().toString(),msg);
    }

}
1.6.4 测试

依次访问：
http://localhost:8088/ttl/sendTimeAndMsgByPlugins/20000/20sMessage，
http://localhost:8088/ttl/sendTimeAndMsgByPlugins/2000/2sMessage
出现如下结果，之前出现死信的情况消失了。
在这里插入图片描述

江海i
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ系列（18）--RabbitMQ基于插件实现延迟队列
m0_64284147的博客
07-06 8622
2、下载rabbitmq_delayer_message_exchange插件（注：RabbitMQ是什么版本的，下载的插件就得是什么版本的，得对应上，以下截图为官方文档的对插件版本的要求说明）但我们下载插件后就能通过交换机延迟消息的方式来实现消息的延迟了（由步骤8可见，我们验证插件是否安装成功是从Exchange进去的，而不是从Queues进去的）结论：基于测试发现在使用延迟插件的情况下，延迟时间短的消息会被先消费，这证明基于插件的延迟消息达到预期效果。10、基于插件延迟队列的代码实现。
RabbitMQ自学之路（九）——RabbitMQ实现延时队列的两种方式
gb4215287的博客
10-14 963
一、什么是延时队列 延时队列顾名思义，即放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费。 二、延时队列应用于什么场景 场景一：在订单系统中，一个用户下单之后通常有30分钟的时间进行支付，如果30分钟之内没有支付成功，那么这个订单将进行一场处理。这是就可以使用延时队列将订单信息发送到延时队列。 场景二：用户希望通过手机远程遥控家里的智能设备在指定的时间进行工作。这时候就可以将用户指令发送到延时队列，当指令设定的时间到了再将指令推送到智能设备。 Rabbitmq实现延时队列一般而言
RabbitMQ之延迟队列
最新发布
CSDN_LiMingfly的博客
05-01 939
RabbitMQ 提供了过期时间 TTL 机制，可以设置消息在队列中的存活时长。在消息到达过期时间时，会从当前队列中删除，并被 RabbitMQ 自动转发到对应的死信队列中。延迟消息就是指当消息被发送以后，并不想让消费者立即拿到消息，而是等待指定时间后，消费者才拿到这个消息进行消费。2:利用 RabbitMQ 中的插件 x-delay-message。然后再来消费该死信队列，这样就可以实现一个延迟队列的效果。失败重试：业务操作失败后，间隔一定的时间进行失败重试。此种方式需要安装mq的延迟第一列插件。
rabbitmq添加延时通道时报错
u011649691的博客
07-12 3145
rabbitmq
RabbitMQ实现延时队列
蹊源的奇思妙想的博客
03-10 780
RabbitMQ实现延时队列 前言 我们在设计大型的购物类的网站的时候，有这样的一个场景就是我们下订单后如果长时间不去支付的话需要超时将订单取消，并且存库要恢复，这就是我们经常说的订单过期会库存。 分布式秒杀系统的设计可参考我的博客：分布式秒杀系统的设计 SpringBoot项目中使用RabbitMQ可参考我的博客：SpringBoot项目中使用RabbitMQ 正文 延时队列 订单过期库存回库的场景： 淘宝七天自动确认收货：在我们签收商品后，物流系统会在七天后延时发送一个消息给支付系统，通知支付系统将款
RabbitMQ实现延时消息的两种方法
lan_kang的博客
12-17 5413
文章目录RabbitMQ实现延时消息的两种方法1、死信队列1.1消息什么时候变为死信(dead-letter)1.2死信队列的原理1.3 代码实现1.4死信队列的一个小坑2 、延时插件2.1如何实现 RabbitMQ实现延时消息的两种方法 1、死信队列 1.1消息什么时候变为死信(dead-letter) 消息被否定接收，消费者使用basic.reject 或者 basic.nack并且requeue 重回队列属性设为false。 消息在队列里得时间超过了该消息设置的过期时间（TTL）。 消息队列到达了它
rabbitMQ延迟队列
03-15
RabbitMQ延迟队列是一种特殊类型的队列，它允许消息在特定时间后才被消费者处理，而不是立即处理。这种功能在某些业务场景下非常有用，例如订单超时处理、定时发送邮件或短信通知等。在RabbitMQ中，实现延迟队列通常...
RabbitMq消息队列3.8.3
05-15
这两个文件分别对应于RabbitMQ的基础——Erlang OTP（Open Telecom Platform）和RabbitMQ服务器本身。 Erlang是一种并发性极强的编程语言，由Ericsson公司开发，主要用于构建分布式、高可用性的系统。OTP是Erlang的...
rabbitmq 延迟插件3.7.x
04-07
对于RabbitMQ延迟插件的监控和调试，可以通过RabbitMQ管理界面查看延迟队列的状态，包括消息数量、延迟时间和消息详情。同时，日志记录和告警设置也是确保系统稳定运行的重要手段。 8. **最佳实践** - 为避免消息...
RabbitMQ高效部署分布式消息队列实战篇
11-11
实战篇还将涵盖高级主题，如死信队列（Dead Letter Queue）、延迟队列（Delayed Queue）、高可用集群（Clustering）和镜像队列（Mirrored Queues）等。这些都是在生产环境中确保RabbitMQ稳定性和高可用性的关键配置...
3.6.X版本延迟队列插件，用7z解压
02-09
在这个场景中，我们关注的是RabbitMQ的一个特殊功能——延迟队列插件（rabbitmq-delayed-message-exchange），它允许我们在特定时间后才处理消息，而非立即处理。标题和描述提及的"3.6.X版本延迟队列插件，用7z解压...
php+rabbitMQ操作之延迟队列(延迟插件)
Enjun97的博客
03-01 1636
composer依赖包是官方的php-amqplib/php-amqplib(需打开php的sockets扩展，否则会报错)
RabbitMQ如何实现延时队列
Pandfson的专栏
07-03 3911
RabbitMQ实现延时队列
rabbitmq plugins rabbitmq_delayed_message_exchange消息队列延迟消息插件
偶爱喝可乐
09-08 8262
RabbitMQ实现延迟消息传递的方法
RabbitMQ案例七之延时任务
坛子成长记
12-08 2910
环境要求 Github:  https://github.com/rabbitmq/rabbitmq-delayed-message-exchange  Rabbitmq版本要求: RabbitMQ 3.5.7 and later versions.  Erlang版本要求: Erlang/OTP 18.0 and later versions  插件列表:  http://www
使用RabbitMq实现延时队列
xushuai2333333的博客
10-19 1328
使用RabbitMq实现延时队列
Rabbitmq死信队列及延时队列实现
weixin_37862824的博客
06-08 1948
RabbitMQ、死信队列、TTL、x-dead-letter-exchange、x-message-ttl
使用RabbitMq实现延迟队列
wang_97的博客
04-21 768
spring:rabbitmq:host: IP地址 // 若在本地：127.0.0.1username: guest //默认的账号密码port: 5672二、将下载的文件放入rabbitMq目录下的plugins文件夹中三、进入控制台，进入rabbitMq目录下的sbin目录下，执行：rabbitmq-plugins enable rabbitmq_delayed_message_exchange，开启插件支持四、重启rabbitMq。
rabbitmq自带延迟队列
06-07
是的，RabbitMQ自带延迟队列功能，可以使用插件的方式实现延迟消息的处理。 具体实现步骤如下： 1. 安装rabbitmq-delayed-message-exchange插件。该插件提供了延迟消息交换机的功能。 2. 创建一个延迟消息交换机...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值