RabbitMQ之延迟队列详解及代码实现
概念
延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望
在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的
元素的队列。
使用场景
● 订单在十分钟之内未支付则自动取消
● 新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。
● 用户注册成功后，如果三天内没有登陆则进行短信提醒。
● 用户发起退款，如果三天内没有得到处理则通知相关运营人员。
● 预定会议后，需要在预定的时间点前十分钟通知各个与会人员参加会议
这些场景都有一个特点，需要在某个事件发生之后或者之前的指定时间点完成某一项任务，如：
发生订单生成事件，在十分钟之后检查该订单支付状态，然后将未支付的订单进行关闭；看起来似乎
使用定时任务，一直轮询数据，每秒查一次，取出需要被处理的数据，然后处理不就完事了吗？如果
数据量比较少，确实可以这样做，比如：对于“如果账单一周内未支付则进行自动结算”这样的需求，
如果对于时间不是严格限制，而是宽松意义上的一周，那么每天晚上跑个定时任务检查一下所有未支
付的账单，确实也是一个可行的方案。但对于数据量比较大，并且时效性较强的场景，如：“订单十
分钟内未支付则关闭“，短期内未支付的订单数据可能会有很多，活动期间甚至会达到百万甚至千万
级别，对这么庞大的数据量仍旧使用轮询的方式显然是不可取的，很可能在一秒内无法完成所有订单
的检查，同时会给数据库带来很大压力，无法满足业务要求而且性能低下。
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.amqpgroupId>
<artifactId>spring-rabbitartifactId>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
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 的时间轮，这些方式各有特点,看需要适用的场景