【RabbitMQ】——延迟队列

一、概念

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

二、场景

<1> 订单在十分钟之内未支付则自动取消
<2> 新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。
<3> 用户注册成功后，如果三天内没有登陆则进行短信提醒。
<4> 用户发起退款，如果三天内没有得到处理则通知相关运营人员。
<5> 预定会议后，需要在预定的时间点前十分钟通知各个与会人员参加会议

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

三、基于死信的基本实现（一个队列一个TTL）

<1>代码架构

  使用TTL过期的死信队列,创建普通交换机和死信交换机，创建普通队列和死信队列，设置普通队列的TTL，当消息过期时，消息会转发到死信队列，就实现了延迟队列，最后通过死信队列消费消息。

<2>rabbitmq配置类

package com.rabbitmqdemoboot.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;

/**
 * rabbitmq配置文件类
 */
@Configuration
public class RabbitmqConfig {


    /**
     * 声明普通交换机X
     *
     * @return 交换机X
     */
    @Bean("xExchange")
    public DirectExchange xExchange() {
        return new DirectExchange(RabbitmqConstant.EXCHANGE_NORMAL_X);
    }

    /**
     * 声明死信交换机y
     *
     * @return 交换机y
     */
    @Bean("yExchange")
    public DirectExchange yExchange() {
        return new DirectExchange(RabbitmqConstant.EXCHANGE_DEAD_Y);
    }

    /**
     * 声明普通队列 qa
     * TTL 10s
     *
     * @return 交换机qa
     */
    @Bean("qaQueue")
    public Queue qaQueue() {
        Map<String, Object> arguments = new HashMap<>();
        //设置死信交换机
        arguments.put("x-dead-letter-exchange", RabbitmqConstant.EXCHANGE_DEAD_Y);
        //设置死信routingKey
        arguments.put("x-dead-letter-routing-key", RabbitmqConstant.ROUTING_KEY_DEAD_YD);
        //设置TTL,单位ms
        arguments.put("x-message-ttl", 10 * 1000);

        return QueueBuilder
                .durable(RabbitmqConstant.QUEUE_NORMAL_QA)
                .withArguments(arguments)
                .build();
    }

    /**
     * 声明普通队列 qb
     * TTL 10s
     *
     * @return 交换机qb
     */
    @Bean("qbQueue")
    public Queue qbQueue() {
        Map<String, Object> arguments = new HashMap<>();
        //设置死信交换机
        arguments.put("x-dead-letter-exchange", RabbitmqConstant.EXCHANGE_DEAD_Y);
        //设置死信routingKey
        arguments.put("x-dead-letter-routing-key", RabbitmqConstant.ROUTING_KEY_DEAD_YD);
        //设置TTL,单位ms
        arguments.put("x-message-ttl", 40 * 1000);

        return QueueBuilder
                .durable(RabbitmqConstant.QUEUE_NORMAL_QB)
                .withArguments(arguments)
                .build();
    }

    /**
     * 声明死信队列 qd
     * TTL 10s
     *
     * @return 交换机qd
     */
    @Bean("qdQueue")
    public Queue qdQueue() {
        return QueueBuilder
                .durable(RabbitmqConstant.QUEUE_DEAD_QD)
                .build();
    }

    /**
     * 绑定routingKey
     * QA Binding X
     */
    @Bean
    public Binding queueQABindingX(@Qualifier("qaQueue") Queue qaQueue, @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(qaQueue).to(xExchange).with(RabbitmqConstant.ROUTING_KEY_NORMAL_XA);
    }

    /**
     * 绑定routingKey
     * QB Binding X
     */
    @Bean
    public Binding queueQBBindingX(@Qualifier("qbQueue") Queue qbQueue, @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(qbQueue).to(xExchange).with(RabbitmqConstant.ROUTING_KEY_NORMAL_XB);
    }

    /**
     * 绑定routingKey
     * QD Binding Y
     */
    @Bean
    public Binding queueQDBindingX(@Qualifier("qdQueue") Queue qdQueue, @Qualifier("yExchange") DirectExchange yExchange) {
        return BindingBuilder.bind(qdQueue).to(yExchange).with(RabbitmqConstant.ROUTING_KEY_DEAD_YD);
    }
}

<3>发送消息

package com.rabbitmqdemoboot.Controller;

import com.rabbitmqdemoboot.config.RabbitmqConstant;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

/**
 * 发送延迟消息
 */
@Slf4j
@RestController
@RequestMapping("/ttl")
public class SendMsgController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/sendMsg/{message}")
    public String sendMsg(@PathVariable String message) {

        log.info("current time : {} , send message to queue: {}", new Date(), message);

        rabbitTemplate.convertAndSend(RabbitmqConstant.EXCHANGE_NORMAL_X, RabbitmqConstant.ROUTING_KEY_NORMAL_XA, "10s TTL queue" + message);
        rabbitTemplate.convertAndSend(RabbitmqConstant.EXCHANGE_NORMAL_X, RabbitmqConstant.ROUTING_KEY_NORMAL_XB, "40s TTL queue" + message);
        return "success";
    }
}

<4>接收消息

package com.rabbitmqdemoboot.consumer;


import com.rabbitmq.client.Channel;
import com.rabbitmqdemoboot.config.RabbitmqConstant;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;


import java.util.Date;

@Slf4j
@Component
public class DeadLetterQueueConsumer {

    @RabbitListener(queues = RabbitmqConstant.QUEUE_DEAD_QD)
    public void receive(Message message, Channel channel) {
        String s = new String(message.getBody());
        log.info("current time : {} , receive message  : {}", new Date(), s);

    }
}

<5>运行结果

四、基于死信的优化实现（一个消息一个TTL）

<1>解释

  之前的实现方式 每增加一个新的时间需求，就要新增一个队列，这里只有10S和40S两个时间选项，如果需要一个小时后处理，那么就需要增加TTL为一个小时的队列，如果是预定会议室然后提前通知这样的场景，岂不是要增加无数个队列才能满足需求。
  可以通过通过消费者设置TTL ，在创建队列的时候设置TTL。就可以每个消息一个TTL

<2> 代码架构

<3>代码优化

1. 新增一个不设置TTL的队列

    /**
     * 声明普通队列 qc
     * 不设置TTL
     *
     * @return 交换机qc
     */
    @Bean("qcQueue")
    public Queue qcQueue() {
        Map<String, Object> arguments = new HashMap<>();
        //设置死信交换机
        arguments.put("x-dead-letter-exchange", RabbitmqConstant.EXCHANGE_DEAD_Y);
        //设置死信routingKey
        arguments.put("x-dead-letter-routing-key", RabbitmqConstant.ROUTING_KEY_DEAD_YD);

        return QueueBuilder
                .durable(RabbitmqConstant.QUEUE_NORMAL_QC)
                .withArguments(arguments)
                .build();
    }

2. 将队列与交换机绑定

  /**
     * 绑定routingKey
     * QC Binding X
     */
    @Bean
    public Binding queueQCBindingX(@Qualifier("qcQueue") Queue qcQueue, @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(qcQueue).to(xExchange).with(RabbitmqConstant.ROUTING_KEY_NORMAL_XC);
    }

3. 新增一个生产者，发送消息的时候执行TTL

    @GetMapping("/sendMsgAndTTL/{message}/{ttlSecond}")
    public String sendMsgAndTTL(@PathVariable String message, @PathVariable String ttlSecond) {
        log.info("current time : {} , send message and TTL to queue. message : {} , ttlSecond : {} ", new Date(), message, ttlSecond);
        rabbitTemplate.convertAndSend(RabbitmqConstant.EXCHANGE_NORMAL_X, RabbitmqConstant.ROUTING_KEY_NORMAL_XC, ttlSecond + "s TTL queue" + message, msg -> {
            msg.getMessageProperties().setExpiration(String.valueOf(Integer.parseInt(ttlSecond) * 1000));
            return msg;
        });
        return "success";
    }

<4> 运行结果

五、基于插件的实现

<1>解释

  因为RabbitMQ指只会检查最后一个消息是否过期，如果过期则丢弃到死信队列，如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到消费，就会造成问题。

<2>安装延时队列插件

1. 在官网上下载https://www.rabbitmq.com/community-plugins.html，
   下载rabbitmq_delayed_message_exchange插件。
2. 放置到RabbitMQ的插件目录(/usr/lib/rabbitmq/lib/rabbitmq_server-3.10.6/plugins)。
3. 进入RabbitMQ的安装目录下的plgins目录。

cd /usr/lib/rabbitmq/lib/rabbitmq_server-3.10.6/plugins

4. 执行下面命令让该插件生效

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

5. 然后重启RabbitMQ

service rabbitmq-server restart

6. 安装结果
   安装完成如下如，会多出来一个x-delayed-message 的交换机选项
   

<3>代码架构

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

<4>配置类

package com.rabbitmqdemoboot.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.CustomExchange;
import org.springframework.amqp.core.Queue;
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;

@Configuration
public class DelayedRabbitmqconfig {

    /**
     * 基于插件 声明交换机
     *
     * @return 交换机
     */
    @Bean("delayedExchange")
    public CustomExchange delayedExchange() {

        Map<String, Object> arguments = new HashMap<>();
        //延迟的类型
        arguments.put("x-delayed-type", "direct");
        /**
         * param1 交换机名称
         * param2 交换机的类型
         * param3 是否需要持久化
         * param4 是否需要自动删除
         * param4 其他参数
         */
        return new CustomExchange(RabbitmqConstant.EXCHANGE_DELAYED, "x-delayed-message", true, false, arguments);
    }

    /**
     * 声明队列
     *
     * @return
     */
    @Bean("delayedQueue")
    public Queue delayedQueue() {
        return new Queue(RabbitmqConstant.QUEUE_DELAYED);
    }

    @Bean
    public Binding delayedQueueBindingDelayedExchange(@Qualifier("delayedQueue") Queue delayedQueue, @Qualifier("delayedExchange") CustomExchange delayedExchange) {
        return BindingBuilder.bind(delayedQueue).to(delayedExchange).with(RabbitmqConstant.ROUTING_KEY_DELAYED).noargs();
    }


}

<5>生产者

/**
     * 发送延迟消息，基于插件
     *
     * @param message   消息
     * @param delayTime 延迟时间,单位毫秒
     * @return 返回结果
     */
    @GetMapping("/sendMsgByplugin/{message}/{delayTime}")
    public String sendMsgByplugin(@PathVariable String message, @PathVariable Integer delayTime) {
        log.info("current time : {} , send message and delayTime to delay queue. message : {} , delayTime : {} s", new Date(), message, delayTime);
        rabbitTemplate.convertAndSend(RabbitmqConstant.EXCHANGE_DELAYED, RabbitmqConstant.ROUTING_KEY_DELAYED, message, msg -> {
            msg.getMessageProperties().setDelay(delayTime * 1000);
            return msg;
        });
        return "success";
    }

<6>消费者

package com.rabbitmqdemoboot.consumer;
import com.rabbitmq.client.Channel;
import com.rabbitmqdemoboot.config.RabbitmqConstant;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Date;
/**
 * 消费基于插件的延迟消息
 */
@Component
@Slf4j
public class DelayQueueConsumer {

    @RabbitListener(queues = RabbitmqConstant.QUEUE_DELAYED)
    public void receiveDelayMessage(Message message, Channel channel) {
        String s = new String(message.getBody());
        log.info("current time : {} , receive delay message  : {}", new Date(), s);

    }
}

<7>运行结果

六、总结

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