【RabbitMQ】- 延迟队列

目录

• 第七章 延迟队列
• • 7.1. 延迟队列概念
  • 7.2. 延迟队列使用场景
  • 7.3. RabbitMQ 中的 TTL
  • • 7.3.1. 队列设置 TTL
    • 7.3.2. 消息设置 TTL
    • 7.3.3. 两者的区别
    • 7.4. 整合 springboot
    • • 7.4.1. 创建项目
      • 7.4.2. 在pom文件中添加依赖
      • 7.4.3. 修改配置文件
      • 7.4.4. 添加 Swagger 配置类
      • 7.5. 队列 TTL
      • • 7.5.1. 代码架构图
        • 7.5.2. 配置文件类代码
        • 7.5.3. 消息生产者代码
        • 7.5.4. 消息消费者代码
        • 7.5.5. 异常信息
        • 7.6. 延时队列优化
        • • 7.6.1. 代码架构图
          • 7.6.2. 配置文件类代码
          • 7.6.3. 消息生产者代码
          • 7.7. Rabbitmq 插件实现延迟队列
          • • 7.7.1. 安装延时队列插件
            • 7.7.2. 代码架构图
            • 7.7.3. 配置文件类代码
            • 7.7.4. 消息生产者代码
            • 7.7.5. 消息消费者代码
            • 7.8. 总结

              第七章 延迟队列

              简单说，延迟队列就是我们前面说的死信队列中消息过期的一种。

              7.1. 延迟队列概念

              ​ 延时队列，队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。

              7.2. 延迟队列使用场景

              1.订单在十分钟之内未支付则自动取消

              2.新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。

              3.用户注册成功后，如果三天内没有登陆则进行短信提醒。

              4.用户发起退款，如果三天内没有得到处理则通知相关运营人员。

              5.预定会议后，需要在预定的时间点前十分钟通知各个与会人员参加会议。

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

              

              7.3. RabbitMQ 中的 TTL

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

              7.3.1. 队列设置 TTL

              第一种是在创建队列的时候设置队列的“x-message-ttl”属性

              

              7.3.2. 消息设置 TTL

              另一种方式便是针对每条消息设置 TTL

              

              7.3.3. 两者的区别

              ​ 如果设置了队列的 TTL 属性，那么一旦消息过期，就会被队列丢弃(如果配置了死信队列被丢到死信队列中)，而第二种方式，消息即使过期，也不一定会被马上丢弃，因为消息是否过期是在即将投递到消费者之前判定的，如果当前队列有严重的消息积压情况，则已过期的消息也许还能存活较长时间；另外，还需要注意的一点是，如果不设置 TTL，表示消息永远不会过期，如果将 TTL 设置为 0，则表示除非此时可以直接投递该消息到消费者，否则该消息将会被丢弃。

              ​ 前一小节我们介绍了死信队列，刚刚又介绍了 TTL，至此利用 RabbitMQ 实现延时队列的两大要素已经集齐，接下来只需要将它们进行融合，再加入一点点调味料，延时队列就可以新鲜出炉了。想想看，延时队列，不就是想要消息延迟多久被处理吗，TTL 则刚好能让消息在延迟多久之后成为死信，另一方面， 成为死信的消息都会被投递到死信队列里，这样只需要消费者一直消费死信队列里的消息就完事了，因为里面的消息都是希望被立即处理的消息。

              7.4. 整合 springboot

              7.4.1. 创建项目

              

              7.4.2. 在pom文件中添加依赖

              
                      
                          org.springframework.boot
                          spring-boot-starter
                      
                          
                          
                              org.springframework.boot
                              spring-boot-starter-amqp
                          
                          
                              org.springframework.boot
                              spring-boot-starter-web
                          
                          
                              org.springframework.boot
                              spring-boot-starter-test
                              test
                          
                          
                              com.alibaba
                              fastjson
                              1.2.47
                          
                          
                              org.projectlombok
                              lombok
                          
                          
                          
                              io.springfox
                              springfox-swagger2
                              2.9.2
                          
                          
                              io.springfox
                              springfox-swagger-ui
                              2.9.2
                          
                          
                          
                              org.springframework.amqp
                              spring-rabbit-test
                              test
                          
                  
              

              7.4.3. 修改配置文件

              

              7.4.4. 添加 Swagger 配置类

              在启动类所在包下创建一个配置包，并添加Swagger配置类

              

              @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("enjoy6288", "http://atguigu.com", "1150887943@qq.com"))
                              .build();
                  }
              }
              

              7.5. 队列 TTL

              7.5.1. 代码架构图

              ​创建两个队列 QA 和 QB，两者队列 TTL 分别设置为 10S 和 40S，然后在创建一个交换机 X 和死信交换机 Y，它们的类型都是 direct，创建一个死信队列 QD，它们的绑定关系如下：

              

              因为没有指定消费者，所以最终所有消息都会进入死信队列。

              7.5.2. 配置文件类代码

              ​之前声明交换机和队列的时候，我们都是在消费者中进行相应的创建，整个SpringBoot之后，我们可以将这些相关信息统一写在配置文件中。

              

              @Configuration // 声明为配置文件
              public class TtlQueueConfig {
                  // 普通交换机的名称
                  public static final String X_EXCHANGE = "X";
                  // 死信交换机的名称
                  public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
                  // 普通队列的名称
                  public static final String QUEUE_A = "QA";
                  public static final String QUEUE_B = "QB";
                  // 死信队列的名称
                  public static final String DEAD_LETTER_QUEUE = "QD";
                  // 新的普通队列的名称
                  public static final String QUEUE_C = "QC";
                  // 声明xExchange
                  @Bean("xExchange")
                  public DirectExchange xExchange(){
                      return new DirectExchange(X_EXCHANGE);
                  }
                  // 声明yExchange
                  @Bean("yExchange")
                  public DirectExchange yExchange(){
                      return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
                  }
                  // 声明普通队列A     TTL设为10s
                  @Bean("queueA")
                  public Queue queueA(){
                      Map arguments = new HashMap<>(3);
                      // 设置死信交换机
                      arguments.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
                      // 设置死信RoutingKey
                      arguments.put("x-dead-letter-routing-key", "YD");
                      // 设置TTL    单位为ms
                      arguments.put("x-message-ttl",10000);
                      return QueueBuilder.durable(QUEUE_A).withArguments(arguments).build(); // withArguments为设置参数
                  }
                  // 声明普通队列B    TTL设为40s
                  @Bean("queueB")
                  public Queue queueB(){
                      Map arguments = new HashMap<>(3);
                      // 设置死信交换机
                      arguments.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
                      // 设置死信RoutingKey
                      arguments.put("x-dead-letter-routing-key", "YD");
                      // 设置TTL    单位为ms
                      arguments.put("x-message-ttl",40000);
                      return QueueBuilder.durable(QUEUE_B).withArguments(arguments).build(); // withArguments为设置参数
                  }
                  // 声明死信队列
                  @Bean("queueD")
                  public Queue queueD(){
                      return QueueBuilder.durable(DEAD_LETTER_QUEUE).build();
                  }
                  // 设置队列A的绑定关系
                  @Bean
                  public Binding queueABindingToX(@Qualifier("queueA") Queue queueA,
                                                  @Qualifier("xExchange") DirectExchange xExchange){
                      return BindingBuilder.bind(queueA).to(xExchange).with("XA"); // queueA绑定到xExchange交换机且routingKey为XA
                  }
                  // 设置队列B的绑定关系
                  @Bean
                  public Binding queueBBindingToX(@Qualifier("queueB") Queue queueB,
                                                  @Qualifier("xExchange") DirectExchange xExchange){
                      return BindingBuilder.bind(queueB).to(xExchange).with("XB"); // queueB绑定到xExchange交换机且routingKey为XB
                  }
                  // 设置死信队列D的绑定关系
                  @Bean
                  public Binding queueDBindingToY(@Qualifier("queueD") Queue queueD,
                                                  @Qualifier("yExchange") DirectExchange yExchange){
                      return BindingBuilder.bind(queueD).to(yExchange).with("YD"); // queueD绑定到yExchange交换机且routingKey为YD
                  }
                  // 声明QC
                  @Bean("queueC")
                  public Queue queueC(){
                      Map arguments = new HashMap<>(3);
                      // 设置死信交换机
                      arguments.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
                      // 设置死信RoutingKey
                      arguments.put("x-dead-letter-routing-key", "YD");
                      return QueueBuilder.durable(QUEUE_C).withArguments(arguments).build();
                  }
                  // 设置队列C的绑定关系
                  @Bean
                  public Binding queueCBindingTox(@Qualifier("queueC") Queue queueC,
                                                  @Qualifier("xExchange") DirectExchange xExchange){
                      return BindingBuilder.bind(queueC).to(xExchange).with("XC");
                  }
              }
              

              7.5.3. 消息生产者代码

              @Slf4j
              @RestController
              @RequestMapping("/ttl")
              public class SendMsgController {
                  @Autowired
                  private RabbitTemplate rabbitTemplate;
                  // 开始发消息
                  @GetMapping("/sendMsg/{message}")
                  public void sendMsg(@PathVariable String message){
                      log.info("当前时间：{}，发送一条消息给两个TTL队列：{}",new Date().toString(), message); // {}为占位符
                      rabbitTemplate.convertAndSend("X","XA","消息来自ttl为10s的队列：" + message);
                      rabbitTemplate.convertAndSend("X","XB","消息来自ttl为40s的队列：" + message);
                  }
              }
              

              7.5.4. 消息消费者代码

              消费者是通过监听的方式来接收消息，所以在项目中写一个监听器

              @Slf4j
              @Component
              public class DelayQueueConsumer {
                  // 监听消息
                  @RabbitListener(queues = DelayedQueueConfig.DELAYED_QUEUE_NAME)
                  public void receiveDelayQueue(Message message){
                      String msg = new String(message.getBody());
                      log.info("当前时间：{}，收到延迟队列的消息：{}", new Date().toString(), msg);
                  }
              }
              

              7.5.5. 异常信息

              启动项目，查看有没有异常。

              如果项目启动失败，并且报空指针异常

              

              解决方式一：将springboot版本调到2.6.0以下（不包括）

              解决方式二：在配置文件中添上一行代码

              

              则启动正常

              

              在浏览器进行访问

              如果报错。可能是信道的包导错了

              

              

              换成这个

              

              再重启项目，刷新浏览器，得到结果，查看日志信息

              

              可以看到间隔之间分别为10s和40s。

              问题：

              ​第一条消息在 10S 后变成了死信消息，然后被消费者消费掉，第二条消息在 40S 之后变成了死信消息， 然后被消费掉，这样一个延时队列就打造完成了。

              ​不过，如果这样使用的话，岂不是每增加一个新的时间需求，就要新增一个队列，这里只有 10S 和 40S 两个时间选项，如果需要一个小时后处理，那么就需要增加 TTL 为一个小时的队列，如果是预定会议室然后提前通知这样的场景，岂不是要增加无数个队列才能满足需求？

              7.6. 延时队列优化

              7.6.1. 代码架构图

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

              

              这个QC就是通用的，不设置TTL时间，而是由生产者设置。

              理解：

              由于队列的先进先出特性，只有当过期的消息到了队列的顶端（队首），才会被真正的丢弃或是进入死信队列，所以在考虑使用RabbitMQ来实现延迟任务队列的时候，需要确保业务上每个任务的延迟时间是一致的，如果遇到不同的任务类型需要不同的延迟的话，需要为每一种不同延迟时间的消息建立单独的消息队列。

              7.6.2. 配置文件类代码

              修改代码

              

              

              7.6.3. 消息生产者代码

              修改代码

              

              运行项目：

              发起两个请求

              http://localhost:8080/ttl/sendExpirationMsg/你好 1/20000

              http://localhost:8080/ttl/sendExpirationMsg/你好 2/2000

              看起来应该是延迟2000ms的延迟消息先到达死信队列，而实际运行结果却是：

              

              所以现在能达到消息想延迟多久就延迟多久，但发送两条以上的消息时，不能达到延迟低先输出的效果。

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

              7.7. Rabbitmq 插件实现延迟队列

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

              7.7.1. 安装延时队列插件

              ​在官网上下载 https://www.rabbitmq.com/community-plugins.html，下载 rabbitmq_delayed_message_exchange 插件，然后解压放置到 RabbitMQ 的插件目录。 进入 RabbitMQ 的安装目录下的 plgins 目录，执行下面命令让该插件生效，然后重启 RabbitMQ /usr/lib/rabbitmq/lib/rabbitmq_server-3.8.8/plugins rabbitmq-plugins enable rabbitmq_delayed_message_exchange

              就是前面第一章节提到的传输到虚拟机的三个文件之一

              

              先复制到指令路径下，并进入到指定路径

              

              输入ll查看是否已经复制过来

              

              输入指令安装完成

              

              输入指令重启后RabbitMQ

              

              此时打开网页，找到交换机，点击添加新交换机，点击Typr选项，如果有对应的x-delayed-message选项则说明插件安装成功

              

              原理：

              在基于死信的情况下，消息延迟的位置是在队列，而队列又是先进先出的，所以无法保证低延迟消息先出。

              而在基于插件的情况下，消息延迟的位置是在交换机，而在延迟时间到达以后，就会达到队列。

              

              7.7.2. 代码架构图

              ​在这里新增了一个队列 delayed.queue,一个自定义交换机 delayed.exchange，绑定关系如下:

              

              7.7.3. 配置文件类代码

              ​在我们自定义的交换机中，这是一种新的交换类型，该类型消息支持延迟投递机制 消息传递后并不会立即投递到目标队列中，而是存储在 mnesia(一个分布式数据系统)表中，当达到投递时间时，才投递到目标队列中。

              新建配置类

              

              package com.atguigu.rabbitmq.springbootrabbitmq.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 java.util.HashMap;
              import java.util.Map;
              /**
               * @author lishuai
               * @date 2023/6/12-10:00
               */
              @Configuration
              public class DelayedQueueConfig {
                  // 队列
                  public static final String DELAYED_QUEUE_NAME = "delayed.queue";
                  // 交换机
                  public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
                  // routingKey
                  public static final String DELAYED_ROUTING_KEY_NAME = "delayed.routingkey";
                  // 声明队列
                  @Bean
                  public Queue delayedQueue(){
                      return new Queue(DELAYED_QUEUE_NAME);
                  }
                  // 声明交换机（基于插件的）
                  @Bean
                  public CustomExchange delayedExchange(){ // CustomExchange：自定义类型交换机
                      /**
                       *  String name：交换机的名称
                       *  String type：交换机的类型
                       *  boolean durable：是否需要持久化
                       *  boolean autoDelete：是否需要自动删除
                       *  Map arguments：其他的参数
                       */
                      Map arguments = new HashMap<>();
                      arguments.put("x-delayed-type","direct"); // 声明交换机的类型，以及延迟消息的类型（direct直接型）
                      return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message",true,false,arguments);
                  }
                  // 声明绑定关系
                  @Bean
                  public Binding delayedQueueBindingDelayedExchange(@Qualifier("delayedQueue") Queue delayedQueue,
                     @Qualifier("delayedExchange")CustomExchange delayedExchange){
                      return BindingBuilder.bind(delayedQueue).to(delayedExchange).with(DELAYED_ROUTING_KEY_NAME).noargs(); // 自定义类型的交换机需要添加一个noargs为构建方法
                  }
              }
              

              7.7.4. 消息生产者代码

              在生产者中添加代码

              

              @Slf4j
              @RestController
              @RequestMapping("/ttl")
              public class SendMsgController {
                  @Autowired
                  private RabbitTemplate rabbitTemplate;
                  // 开始发消息
                  @GetMapping("/sendMsg/{message}")
                  public void sendMsg(@PathVariable String message){
                      log.info("当前时间：{}，发送一条消息给两个TTL队列：{}",new Date().toString(), message); // {}为占位符
                      rabbitTemplate.convertAndSend("X","XA","消息来自ttl为10s的队列：" + message);
                      rabbitTemplate.convertAndSend("X","XB","消息来自ttl为40s的队列：" + message);
                  }
                  // 开始发消息：消息+TTL
                  @GetMapping("/sendExpirationMsg/{message}/{ttlTime}")
                  public void sendMsg(@PathVariable String message,@PathVariable String ttlTime){
                      log.info("当前时间：{}，发送一条时长{}毫秒TTL信息给QC队列：{}",new Date().toString(), ttlTime , message); // {}为占位符
                      rabbitTemplate.convertAndSend("X", "XC",message,msg -> {
                             // 发送消息的时候，延迟时长
                          msg.getMessageProperties().setExpiration(ttlTime);
                          return msg;
                      });
                  }
                  // 开始发消息（基于插件的）：消息+延迟时间
                  @GetMapping("/sendDelayMsg/{message}/{delayTime}")
                  public void sendMsg(@PathVariable String message,@PathVariable Integer delayTime){
                      log.info("当前时间：{}，发送一条时长{}毫秒TTL信息给延迟队列delayed.queue：{}",new Date().toString(), delayTime , message); // {}为占位符
                      rabbitTemplate.convertAndSend(DelayedQueueConfig.DELAYED_EXCHANGE_NAME, DelayedQueueConfig.DELAYED_ROUTING_KEY_NAME,message, msg -> {
                          // 发送消息的时候，延迟时长
                          msg.getMessageProperties().setDelay(delayTime);
                          return msg;
                      });
                  }
              }
              

              7.7.5. 消息消费者代码

              建立新的消费者类

              

              @Slf4j
              @Component
              public class DelayQueueConsumer {
                  // 监听消息
                  @RabbitListener(queues = DelayedQueueConfig.DELAYED_QUEUE_NAME)
                  public void receiveDelayQueue(Message message){
                      String msg = new String(message.getBody());
                      log.info("当前时间：{}，收到延迟队列的消息：{}", new Date().toString(), msg);
                  }
              }
              

              启动后

              发起请求：

              http://localhost:8080/ttl/sendDelayMsg/come on baby1/20000

              http://localhost:8080/ttl/sendDelayMsg/come on baby2/2000

              查看控制台结果，可以看到已经达到预期效果，低延迟的先输出：

              

              7.8. 总结

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

              ​当然，延时队列还有很多其它选择，比如利用 Java 的 DelayQueue，利用 Redis 的 zset，利用 Quartz 或者利用 kafka 的时间轮，这些方式各有特点,看需要适用的场景。