RabbitMQ之延迟队列详解及代码实现

Java王权

已于 2023-12-06 08:53:35 修改

阅读量507

点赞数

分类专栏： rabbitmq 文章标签： rabbitmq 分布式

于 2023-02-12 15:12:49 首次发布

本文链接：https://blog.csdn.net/weixin_43902413/article/details/128995056

版权

rabbitmq 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

概念

延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望
在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的
元素的队列。
使用场景
● 订单在十分钟之内未支付则自动取消
● 新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。
● 用户注册成功后，如果三天内没有登陆则进行短信提醒。
● 用户发起退款，如果三天内没有得到处理则通知相关运营人员。
● 预定会议后，需要在预定的时间点前十分钟通知各个与会人员参加会议

这些场景都有一个特点，需要在某个事件发生之后或者之前的指定时间点完成某一项任务，如：
发生订单生成事件，在十分钟之后检查该订单支付状态，然后将未支付的订单进行关闭；看起来似乎
使用定时任务，一直轮询数据，每秒查一次，取出需要被处理的数据，然后处理不就完事了吗？如果
数据量比较少，确实可以这样做，比如：对于“如果账单一周内未支付则进行自动结算”这样的需求，
如果对于时间不是严格限制，而是宽松意义上的一周，那么每天晚上跑个定时任务检查一下所有未支
付的账单，确实也是一个可行的方案。但对于数据量比较大，并且时效性较强的场景，如：“订单十
分钟内未支付则关闭“，短期内未支付的订单数据可能会有很多，活动期间甚至会达到百万甚至千万
级别，对这么庞大的数据量仍旧使用轮询的方式显然是不可取的，很可能在一秒内无法完成所有订单
的检查，同时会给数据库带来很大压力，无法满足业务要求而且性能低下。

TTL

TTL 是什么呢？ Time to Live 的简称，即过期时间。
TTL 是 RabbitMQ 中一个消息或者队列的属性，表明一条消息或者该队列中的所有消息的最大存活时间，

单位是毫秒。换句话说，如果一条消息设置了 TTL 属性或者进入了设置 TTL 属性的队列，那么这条消息如果在 TTL 设置的时间内没有被消费，则会成为"死信"。如果同时配置了队列的 TTL 和消息的 TTL，那么较小的那个值将会被使用，有两种方式设置 TTL。
设置TTL
● 消息设置TTL
● 队列设置TTL

代码架构图

在这里插入图片描述

通过TTL实现演出效果

方式一：设置队列的TTL

QA队列设置为10秒
QB队列设置为40秒

pom

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

配置类

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName：DelayConfig
 * @Author: MACRO
 * @Date: 2023/2/12 12:31
 * @Description: 延迟队列配置类
 */
@Configuration
public class DelayConfig {
    public static final String X_EXCHANGE = "X";
    public static final String QUEUE_A = "QA";
    public static final String QUEUE_B = "QB";

    public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
    public static final String DEAD_LETTER_QUEUE = "QD";

    // 声明 xExchange
    @Bean("xExchange")
    public DirectExchange xExchange() {
        return new DirectExchange(X_EXCHANGE);
    }

    // 声明 队列QA
    @Bean("yExchange")
    public DirectExchange yExchange() {
        return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
    }

    @Bean("queueA")
    public Queue queueA() {
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //声明队列的 TTL
        args.put("x-message-ttl", 10000);
        return QueueBuilder.durable(QUEUE_A).withArguments(args).build();
    }

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

    //声明队列 B ttl 为 40s 并绑定到对应的死信交换机
    @Bean("queueB")
    public Queue queueB() {
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //声明队列的 TTL
        args.put("x-message-ttl", 40000);
        return QueueBuilder.durable(QUEUE_B).withArguments(args).build();
    }

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

    //声明死信队列 QD
    @Bean("queueD")
    public Queue queueD() {
        return new Queue(DEAD_LETTER_QUEUE);
    }

    //声明死信队列 QD 绑定关系
    @Bean
    public Binding deadLetterBindingQAD(@Qualifier("queueD") Queue queueD,
                                        @Qualifier("yExchange") DirectExchange yExchange) {
        return BindingBuilder.bind(queueD).to(yExchange).with("YD");
    }
}

死信消费者监听类

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.Date;
/**
 * @ClassName：DelayListener
 * @Author: MACRO
 * @Date: 2023/2/12 12:41
 * @Description: 死信消费者监听类
 */
@Component
public class DelayListener {
    @RabbitListener(queues = "QD")
    public void receiveD(Message message, Channel channel) throws IOException {
        String msg = new String(message.getBody());
        System.out.println("当前时间"+new Date()+"收到死信队列信息"+msg);
    }
}

生产者-junit启动生产者

package com.macro.producer.amqp;

import com.macro.producer.ProducerApplication;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.util.Date;

/**
 - @ClassName：DelayProducer
 - @Author: MACRO
 - @Date: 2023/2/12 12:38
 - @Description: 生产者
 */
//调用方法时启动spring容器
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ProducerApplication.class)
public class DelayProducer {
    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void send() {
        rabbitTemplate.convertAndSend("X", "XA", "消息来自 ttl 为 10S 的队列: "+new Date());
        rabbitTemplate.convertAndSend("X", "XB", "消息来自 ttl 为 40S 的队列: "+new Date());
    }
}

消息二：设置队列的TTL（基于方式一进行修改）

删除配置类队列QA QB的TTL参数修改生产者代码

 @Test
    public void sendMsgTTL() {
        rabbitTemplate.convertAndSend("X", "XA", "消息来自 ttl 为 10S 的队列: " + new Date(), correlationData -> {
            //消息设置TTL 为10秒
            correlationData.getMessageProperties().setExpiration("10000");
            return correlationData;
        });

        rabbitTemplate.convertAndSend("X", "XA", "消息来自 ttl 为 40S 的队列: " + new Date(), correlationData -> {
            //消息设置TTL 为40秒
            correlationData.getMessageProperties().setExpiration("40000");
            return correlationData;
        });
    }

效果

发送消息时间
在这里插入图片描述

第一条消息在 10S 后变成了死信消息，然后被消费者消费掉，第二条消息在 40S 之后变成了死信消息，然后被消费掉，这样一个延时队列就打造完成了。
问题
不过，如果这样使用的话，岂不是每增加一个新的时间需求，就要新增一个队列，这里只有 10S 和 40S 两个时间选项，如果需要一个小时后处理，那么就需要增加 TTL 为一个小时的队列，如果是预定会议室然后提前通知这样的场景，岂不是要增加无数个队列才能满足需求？

延时队列优化

问题案例

在这里新增了一个队列 QC,绑定关系如下,该队列不设置 TTL 时间

修改配置类

添加队列QC 绑定关系

 public static final String QUEUE_C = "QC";
    //声明队列 C 死信交换机
    @Bean("queueC")
    public Queue queueC(){
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //没有声明 TTL 属性
        return QueueBuilder.durable(QUEUE_C).withArguments(args).build();
    }
    //声明队列 C 绑定 X 交换机
    @Bean
    public Binding queuecBindingX(@Qualifier("queueC") Queue queueC,
                                  @Qualifier("xExchange") DirectExchange xExchange){
        return BindingBuilder.bind(queueC).to(xExchange).with("XC");
    }

生产者

 @Test
    public void sendMain() {
        sendMsgWithTTL("消息来自 ttl 为 10S 的队列: " + new Date(),"10000");
        sendMsgWithTTL("消息来自 ttl 为 2s 的队列: " + new Date(),"2000");
    }
    public void sendMsgWithTTL(String msg,String ttlTime){
        rabbitTemplate.convertAndSend("X", "XA", msg, correlationData -> {
            //消息设置TTL 为40秒
            correlationData.getMessageProperties().setExpiration(ttlTime);
            return correlationData;
        });
    }

效果

在这里插入图片描述

问题

看起来似乎没什么问题，但是在最开始的时候，就介绍过如果使用在消息属性上设置 TTL 的方式，消
息可能并不会按时“死亡“，因为 RabbitMQ 只会检查第一个消息是否过期，如果过期则丢到死信队列，
如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。

如果不能实现在消息粒度上的 TTL，并使其在设置的 TTL 时间
及时死亡，就无法设计成一个通用的延时队列。那如何解决呢，接下来我们就去解决该问题。

解决：延迟队列插件

安装

下载插件

https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases?q=3&expanded=true
要根据mq的版本下载不同的插件

查看当前版本

docker inspect mq的容器名称

查看插件版本

开启插件

将插件复制到容器中

//docker cp 插件路径 容器名：/plugins
docker cp /opt/rabbitmq_delayed_message_exchange-3.11.1.ez mq:/plugins

进入容器

docker exec -it mq bash

启动插件

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

代码架构图

代码实现

延迟配置类

package com.macro.consumer.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName：DelayPluginListener
 * @Author: MACRO
 * @Date: 2023/2/12 14:30
 * @Description: 使用延迟插件-配置类
 */
@Configuration
public class DelayPluginConfig {
    public static final String DELAYED_QUEUE_NAME = "delayed.queue";
    public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
    public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";

    /*声明队列*/
    @Bean
    public Queue delayedQueue() {
        return new Queue(DELAYED_QUEUE_NAME);
    }

    /*使用CustomExchange 自定义交换机 延迟交换机*/
    @Bean
    public CustomExchange delayedExchange() {
        Map<String, Object> args = new HashMap<>();
        //自定义交换机的类型
        args.put("x-delayed-type", "direct");
        return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false,
                args);
    }

    @Bean
    public Binding bindingDelayedQueue(@Qualifier("delayedQueue") Queue queue,
                                       @Qualifier("delayedExchange") CustomExchange
                                               delayedExchange) {
        return
                BindingBuilder.bind(queue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs();
    }
}

消费者监听类

@Component
public class DelayListener {
     final String DELAYED_QUEUE_NAME = "delayed.queue";
    @RabbitListener(queues = DELAYED_QUEUE_NAME)
    public void receiveDelayP(Message message) throws IOException {
        String msg = new String(message.getBody());
        System.out.println("当前时间"+new Date()+"延迟队列消息"+msg);
    }
}

生产者
设置延期时间

>     @Test
>     public void sendDelay() {
>         sendDelaySub("消息来自 ttl 为 10S 的队列: " + new Date(),10000);
>         sendDelaySub("消息来自 ttl 为 2s 的队列: " + new Date(),2000);
>     }
>     public void sendDelaySub(String msg,Integer delayTime){
>         rabbitTemplate.convertAndSend(DelayPluginConfig.DELAYED_EXCHANGE_NAME,
> DelayPluginConfig.DELAYED_ROUTING_KEY, msg, correlationData -> {
>             //消息设置TTL 为40秒
>             correlationData.getMessageProperties().setDelay(delayTime);
>             return correlationData;
>         });
>     }

效果

发送第一条消息 ttl为10秒
发送第二条消息 ttl为2秒

第二秒第二条消息被消费
第十秒第一条消息被消费

总结

延时队列在需要延时处理的场景下非常有用，使用 RabbitMQ 来实现延时队列可以很好的利用
RabbitMQ 的特性，如：消息可靠发送、消息可靠投递、死信队列来保障消息至少被消费一次以及未被正确处理的消息不会被丢弃。另外，通过 RabbitMQ 集群的特性，可以很好的解决单点故障问题，不会因为单个节点挂掉导致延时队列不可用或者消息丢失。
当然，延时队列还有很多其它选择，比如利用 Java 的 DelayQueue，利用 Redis 的 zset，利用 Quartz 或者利用 kafka 的时间轮，这些方式各有特点,看需要适用的场景

Java王权

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ之延迟队列详解及代码实现

延时队列在需要延时处理的场景下非常有用，使用 RabbitMQ 来实现延时队列可以很好的利用RabbitMQ 的特性，如：消息可靠发送、消息可靠投递、死信队列来保障消息至少被消费一次以及未被正确处理的消息不会被丢弃。另外，通过 RabbitMQ 集群的特性，可以很好的解决单点故障问题，不会因为单个节点挂掉导致延时队列不可用或者消息丢失。
复制链接

扫一扫