RabbitMQ 延时队列

消息的TTL（Time To Live）

1. 消息的 TTL 就是消息的存活时间。
2. RabbitMQ 可对队列和消息分别设置 TTL。
   对队列设置TTL，表明消息进入队列的时间超过队列设置的TTL而没有被消费，消息就会被清除。
   对消息设置TTL，表明消息在队列中存活的最大时间是TTL，超过这个时间会被清除。
   如果队列设置了TTL而消息也设置了TTL，那么会选取两者之中较小的作为消息的TTL。
   消息设置TTL用 expiration 字段，队列设置TTL用 x-message-ttl 字段。
3. 超过TTL时间没有被消费的消息，称之为死信。

死信路由

1. 死信的种类
   a. 被 consumer 拒收但又不能重写回到队列中的消息。
   b. 消息过期，超过TTL时间没有被消费的消息。
   c. 队列满了，队头被丢弃的消息。
2. 什么是死信路由？
   当消息死亡后，不要被随意丢弃，而是丢弃到一个 exchange，该 exchange 就是死信路由。

延时队列

结合消息TTL 和 死信路由(Dead Letter Exchange) 可以实现延时队列
实现方式1：

进入到队列 queue 的消息，都是在delay.queue中待够 300000ms 后，变成死信，到达 dead.exchange 交换机，被路由到到 queue里的。这样，消费者消费到的消息，都是经过 300000ms延时后的消息。
delay.queue 设置了三个属性：
x-message-ttl 设置消息在队列中的存活时间。
x-dead-letter-exchange 设置消息变成死信后，交给的交换机。
x-dead-letter-routing-key 设置消息变成死信后，被放入 queue 队列所用的路由键。

实现方式2：

Spring Boot 创建 Queue Binding Exchange

/**
 * 容器中的Binding Queue Exchange 都会自动创建（RabbitMQ没有的情况下）
 */
@Configuration
public class MyMQConfig {

    /**
     * 先创建延时队列
     */
    @Bean
    public Queue orderDelayQueue() {
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-dead-letter-exchange", "order-event-exchange"); // 死信路由
        arguments.put("x-dead-letter-routing-key", "order.release.order"); // 死信用的路由键
        arguments.put("x-message-ttl", 60000);

        Queue queue = new Queue("order.delay.queue", true, false, false, arguments);
        return  queue;
    }

    /**
     * 创建死信队列
     */
    @Bean
    public Queue orderReleaseOrderQueue() {
        Queue queue = new Queue("order.release.order.queue", true, false, false);
        return  queue;
    }

    /**
     * 创建exchange, 类型为topic
     */
    @Bean
    public Exchange orderEventExchange() {
        // 交换机的名字
        return new TopicExchange("order-event-exchange", true, false);
    }

    /**exchange 与 延时队列的绑定关系
     * 绑定关系
     * @return
     */
    @Bean
    public Binding orderCreateOrderBinding() {
        return new Binding("order.delay.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.create.order", null);
    }

    /**
     *  exchange 与 死信队列的绑定关系
     */
    @Bean
    public Binding orderReleaseOrderBinding() {
        return new Binding("order.release.order.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.release.order", null);
    }
}

测试给延迟队列 order.delay.queue 发送消息

1. 测试将消息发送到延迟队列

   @Controller
   public class HelloController {
   
       @Autowired
       RabbitTemplate rabbitTemplate;
       
       @ResponseBody
       @GetMapping("/test/createOrder")
       public String createOrderTest() {
   
           OrderEntity orderEntity = new OrderEntity();
           orderEntity.setOrderSn(UUID.randomUUID().toString());
           orderEntity.setModifyTime(new Date());
   
           // 给MQ发消息
           rabbitTemplate.convertAndSend("order-event-exchange", "order.create.order", orderEntity);
           return "ok";
       }
   }
   

2. 监听死信队列

       @RabbitListener(queues = "order.release.order.queue")
       public void listener(OrderEntity entity) {
           System.out.println("收到过期订单信息，准备关闭订单:" + entity.getOrderSn());
       }
   

3. 现在看到延时队列中有条消息，就是我们测试的发送的消息
   
   接着消息1分钟后过期，进入死信队列，因此我们的消费者监听到了这条消息，并且进行了消费。
   

下单业务 结合 MQ的延迟队列