Spring Boot+RabbitMQ 基于死信队列和插件实现延迟队列详解

1. 死信队列

1.1 基本概念

死信即指无法被消费的消息。一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，而死信队列则是专门用于处理死信的队列。

出现死信的原因有三种：

1. 消息TTL过期（Time To Live生存时间），但没有被消费
2. 队列达到最大长度，无法继续添加数据到MQ中
3. 消息被拒绝 (使用basic.reject或 basic.nack方法）并且 requeue=false

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

RabbitMQ提供两种方式设置 TTL：消息设置TTL和队列设置TTL。消息设置TTL和队列设置TTL的区别：
如果队列设置消息TTL属性，那么一旦消息过期，就会被队列丢弃(如果配置了死信队列被丢到死信队
列中)。

而如果单条消息设置TTL，消息即使过期，也不一定会被马上丢弃，因为消息是否过期是在即将投递到消费者之前判定的，如果当前队列有严重的消息积压情况，则已过期的消息也许还能存活较长时间；另外，还需要注意的一点是，如果不设置 TTL，表示消息永远不会过期。如果将 TTL 设置为 0，则表示除非此时可以直接投递该消息到消费者，否则该消息将会被丢弃。

1.2 死信实战

创建Maven项目，pom.xml添加如下依赖：

   <dependencies>
       <dependency>
           <groupId>com.rabbitmq</groupId>
           <artifactId>amqp-client</artifactId>
           <version>5.7.2</version>
       </dependency>
   </dependencies>

创建工具类RabbitMQUtils 创建连接工厂，用于连接RabbitMQ。

public class RabbitMQUtils {
    
    
    /**
     * 创建工厂,连接工厂是重量型的，重复创建，消耗性能
     */
    private static ConnectionFactory connectionFactory;
    static {
    
    
        connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("");
        connectionFactory.setPassword("");
        connectionFactory.setVirtualHost("/");
    }

    /**
     * 获取连接
     * @throws
     */
    public static Connection getConnection() throws IOException, TimeoutException {
    
    
        return connectionFactory.newConnection();
    }

    /**
     * 关闭连接和通道
     * @param connection
     * @param channel
     */
    public static void closeConnectionAndChannel(Connection connection, Channel channel){
    
    
        try {
    
    
            channel.close();
            connection.close();
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }
}

1.2.1 模拟消息TTL过期

模拟消息TTL过期，出现死信的情况，生产者代码：

public class Producer {
    
    

    private static final String NORMAL_EXCHANGE = "normal_exchange";
    private static final String NORMAL_ROUTING_KEY = "normal_routing_key";

    public static void main(String[] args) throws IOException, TimeoutException {
    
    
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //设置消息的TTL
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
        for (int i = 0; i < 10; i++) {
    
    
            String message = "info" + i;
            channel.basicPublish(NORMAL_EXCHANGE, NORMAL_ROUTING_KEY, properties, message.getBytes());
            System.out.println("生产者发送消息：" + message);
        }
    }
}

消费者1代码，启动之后关闭该消费者模拟其接收不到消息，使消息经过死信交换机（DLX,Dead-Letter-Exchange）进入死信队列：

public class Consumer01 {
    
    
    private static final String NORMAL_EXCHANGE = "normal_exchange";
    private static final String DEAD_EXCHANGE = "dead_exchange";
    private static final String NORMAL_ROUTING_KEY = "normal_routing_key";
    private static final String NORMAL_DEAD_LETTER_ROUTING_KEY = "normal_dead_letter_routing_key";

    public static void main(String[] args) throws IOException, TimeoutException {
    
    
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        //声明死信交换机和普通交换机，类型为direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明死信队列,绑定到死信交换机
        String deadQueue= "dead-queue";
        channel.queueDeclare(deadQueue,false,false,false, null );
        channel.queueBind(deadQueue, DEAD_EXCHANGE, NORMAL_DEAD_LETTER_ROUTING_KEY);

        //声明普通队列，并绑定死信队列信息
        HashMap<String, Object> params = new HashMap<>();
        params.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        params.put("x-dead-letter-routing-key", NORMAL_DEAD_LETTER_ROUTING_KEY);
        String normalQueue = "normal-queue";
        channel.queueDeclare(normalQueue, false,false,false,params);
        channel.queueBind(normalQueue,NORMAL_EXCHANGE,NORMAL_ROUTING_KEY);
        channel.basicConsume(normalQueue, true, new DefaultConsumer(channel){
    
    
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    
    
                System.out.println("Consumer01接收普通队列的消息:"+new String(body));
            }
        });
    }
}

消费者2的代码：

public class Consumer02 {
    
    
    private static final String DEAD_EXCHANGE = "dead_exchange";
    private static final String NORMAL_DEAD_LETTER_ROUTING_KEY = "normal_dead_letter_routing_key";

    public static void main(String[] args) throws IOException, TimeoutException {
    
    
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明死信队列,绑定到死信交换机
        String deadQueue= "dead-queue";
        channel.queueDeclare(deadQueue,false,false,false, null );
        channel.queueBind(deadQueue, DEAD_EXCHANGE, NORMAL_DEAD_LETTER_ROUTING_KEY);
        channel.basicConsume(deadQueue, true, new DefaultConsumer(channel){
    
    
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    
    
                System.out.println("Consumer02接收死信队列的消息:"+new String(body));
            }
        });
    }
}

下面进行测试并通过RabbitMQ查看队列情况

启动消费者2消费死信队列中的消息，通过RabbitMQ查看队列情况

1.2.2 模拟队列达到最大长度

下面模拟队列达到最大长度，消息进入死信队列的情况：
（1）消息生产者代码去掉 TTL 属性

public class Producer {
    
    

    private static final String NORMAL_EXCHANGE = "normal_exchange";
    private static final String NORMAL_ROUTING_KEY = "normal_routing_key";

    public static void main(String[] args) throws IOException, TimeoutException {
    
    
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //设置消息的TTL
//        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
        for (int i = 0; i < 10; i++) {
    
    
            String message = "info" + i;
            channel.basicPublish(NORMAL_EXCHANGE, NORMAL_ROUTING_KEY, null, message.getBytes());
            System.out.println("生产者发送消息：" + message);
        }
    }
}

（2）删除原本的队列normal-queue，消费者1Consumer01类中修改normal-queue的参数，设置队列最大消息数为6.

       params.put("x-max-length", 6);

启动程序重新创建队列。然后关闭消费者1，模拟消息进入死信队列的情况。

1.2.3 模拟消息被拒绝

下面模拟消息被拒绝的场景
（1）首先生产者代码去掉消息的TTL属性设置
（2）删除normal-queue队列，修改Consumer01(消费者1)类的代码：

public class Consumer01 {
    
    
    private static final String NORMAL_EXCHANGE = "normal_exchange";
    private static final String DEAD_EXCHANGE = "dead_exchange";
    private static final String NORMAL_ROUTING_KEY = "normal_routing_key";
    private static final String NORMAL_DEAD_LETTER_ROUTING_KEY = "normal_dead_letter_routing_key";

    public static void main(String[] args) throws IOException, TimeoutException {
    
    
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        //声明死信交换机和普通交换机，类型为direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明死信队列,绑定到死信交换机
        String deadQueue= "dead-queue";
        channel.queueDeclare(deadQueue,false,false,false, null );
        channel.queueBind(deadQueue, DEAD_EXCHANGE, NORMAL_DEAD_LETTER_ROUTING_KEY);

        //声明普通队列，并绑定死信队列信息
        HashMap<String, Object> params = new HashMap<>();
        params.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        params.put("x-dead-letter-routing-key", NORMAL_DEAD_LETTER_ROUTING_KEY);
        //设置队列的最大消息数
//        params.put("x-max-length", 6);
        String normalQueue = "normal-queue";
        channel.queueDeclare(normalQueue, false,false,false,params);
        channel.queueBind(normalQueue,NORMAL_EXCHANGE,NORMAL_ROUTING_KEY);
        /*
        模拟消息被拒绝
         */
        boolean autoAck = false;
        channel.basicConsume(normalQueue, autoAck, new DefaultConsumer(channel){
    
    
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    
    
                String message = new String(body);
                if ("info5".equals(message)){
    
    
                    System.out.println("Consumer01接收普通队列的消息:"+ message);
                    channel.basicReject(envelope.getDeliveryTag(), false);
                }else{
    
    
                    System.out.println("Consumer01接收普通队列的消息:"+ message);
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        });
    }
}

启动之后关闭该消费者 模拟其接收不到消息.消费者2的代码保持不变。启动生产者发送消息，然后先启动消费者1，再启动消费者2程序进行测试。

2. 延迟队列介绍

延迟队列就是用来存放需要在指定时间被处理的消息的队列。队列内部是有序的，最重要的特性在于延时属性，延时队列中的消息是希望到了指定时间后取出和处理。

延迟队列的常见使用场景举例：

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

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

3. 基于死信队列实现延迟队列

我们可以通过设置TTL 属性则刚好能让消息在延迟多久之后成为死信，另一方面，成为死信的消息都会被投递到死信队列里，这样只需要消费者一直消费死信队列里的消息，即可完成消息的延迟消费，实现延迟队列的效果。基于死信队列实现延迟队列的基础代码架构图如下所示：

3.1 环境准备

创建一个Maven项目

3.1.1 引入依赖

    <dependencies>
        <!--RabbitMQ依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--Swagger依赖-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!--RabbitMQ测试依赖-->
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <version>2.2.3.RELEASE</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

3.1.2 配置文件

application.properties配置文件中配置RabbitMQ服务器纤细

spring:
  application:
    name: springboot_rabbitmq
  rabbitmq:
    host: 198.143.320.72
    port: 5672
    username: guest
    password: guest
    virtual-host: /learn

3.1.3 添加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",
                        "[email protected]"))
                .build();
    } }

3.2 队列设置TTL实现延迟

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

队列设置TTL实现延迟需要在定义队列的时候使用 x-message-ttl 参数进行设置，单位为“毫秒”。

3.2.1 配置类代码

创建配置类TtlQueueConfig，用于配置队列，交换机以及配置队列和交换机的绑定关系。配置队列中的消息过期时间，默认的时间单位为毫秒。

@EnableRabbit
@Configuration
public class TtlQueueConfig {
    
    
    private static final String X_CHANGE="X";
    private static final String QUEUE_A="QA";
    private static final String QUEUE_B="QB";


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

    @Bean
    public DirectExchange xExchange(){
    
    
        return new DirectExchange(X_CHANGE);
    }

    @Bean
    public DirectExchange yExchange(){
    
    
        return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
    }

    /**
     * 声明队列A 的消息ttl为10s，并绑定到对应的死信交换机
     *
     * @return
     */
    @Bean("queueA")
    public Queue queueA() {
    
    
        HashMap<String, Object> args = new HashMap<>();
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        args.put("x-dead-letter-routing-key", "YD");
        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 并绑定到对应的死信交换机
     * @return
     */
    @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 交换机
     * @return
     */
    @Bean
    public Binding queuebBindingX(@Qualifier("queueB") Queue queue1B,
                                  @Qualifier("xExchange") DirectExchange xExchange){
    
    
        return BindingBuilder.bind(queue1B).to(xExchange).with("XB");
    }
    /**
     *声明死信队列 QD
     * @return
     */
    @Bean("queueD")
    public Queue queueD(){
    
    
        return new Queue(DEAD_LETTER_QUEUE);
    }
    /**
     *声明死信队列 QD 绑定关系
     * @return
     */
    @Bean
    public Binding deadLetterBindingQAD(@Qualifier("queueD") Queue queueD,
                                        @Qualifier("yExchange") DirectExchange yExchange){
    
    
        return BindingBuilder.bind(queueD).to(yExchange).with("YD");
    }
}

3.2.2 生产者代码

@Slf4j
@RequestMapping("ttl")
@RestController
public class SendMsgController {
    
    

    @Autowired
    private RabbitTemplate rabbitTemplate;
    @GetMapping("sendMsg/{message}")
    public void sendMsg(@PathVariable String message){
    
    
        log.info("当前时间：{},发送一条信息给两个 TTL 队列:{}", new Date(), message);
        rabbitTemplate.convertAndSend("X", "XA", "消息来自 ttl 为 10S 的队列: "+message);
        rabbitTemplate.convertAndSend("X", "XB", "消息来自 ttl 为 40S 的队列: "+message);
    }
    
}

3.2.3 消费者代码

@Slf4j
@Component
public class DeadLetterQueueConsumer {
    
    

    @RabbitListener(queues = "QD")
    public void receiveD(Message message, Channel channel) throws IOException {
    
    
        String msg = new String(message.getBody());
        log.info("当前时间：{},收到死信队列信息{}", new Date().toString(), msg);
    }
   
}

通过Swagger：http://localhost:8080/swagger-ui.html，调用/ttl/sendMsg接口进行测试。

第一条消息在 10S 后变成了死信消息，然后被消费者消费掉。而第二条消息在 40S 之后变成了死信消息，然后被消费掉，这样完成实现延时队列的功能了。但是通过队列设置消息TTL的方式，每新增一个新的时间需求，就需要新增加一个队列，所以该方式只适合延迟时间固定的需求场景。对于延迟时间不固定的需求场景，则需要使用消息设置TTL的方式实现延迟。

3.3 消息设置TTL实现延迟

下面通过消息设置TTL实现延迟消息，消息设置TTL是通过设置消息属性的 expiration 参数的值，单位为 “毫秒”。

3.3.1 配置类代码

创建配置类MsgTtlQueueConfig ，用于配置队列，交换机以及配置队列和交换机的绑定关系。

@Configuration
public class MsgTtlQueueConfig {
    
    

    private static final String DELAY_EXCHANGE_NAME="DELAY_EXCHANGE_NAME";

    private static final String DELAY_QUEUE="DELAY_QUEUE";

    private static final String DELAY_ROUTING_KEY="DELAY_ROUTING_KEY";

    private static final String DEAD_EXCHANGE_NAME="DEAD_EXCHANGE_NAME";

    private static final String DEAD_QUEUE="DEAD_QUEUE";

    private static final String DEAD_ROUTING_KEY="DEAD_ROUTING_KEY";


    /**
     * 死信队列，交换机定义
     * @return
     */
    @Bean
    public DirectExchange deadExchange(){
    
    
        return new DirectExchange(DEAD_EXCHANGE_NAME);
    }

    @Bean
    public Queue deadQueue() {
    
    
        return QueueBuilder.durable(DEAD_QUEUE).build();
    }

    @Bean
    public Binding deadExchangeBinding(){
    
    
        return BindingBuilder.bind(deadQueue()).to(deadExchange()).with(DEAD_ROUTING_KEY);
    }

    /**
     * 延迟队列，交换机定义
     * @return
     */
    @Bean
    public DirectExchange delayExchange(){
    
    
        return new DirectExchange(DELAY_EXCHANGE_NAME);
    }

    @Bean
    public Queue delayQueue() {
    
    
        return QueueBuilder.durable(DELAY_QUEUE)
                .withArgument("x-dead-letter-exchange", DEAD_EXCHANGE_NAME)
                .withArgument("x-dead-letter-routing-key", DEAD_ROUTING_KEY)
                .build();
    }

    @Bean
    public Binding delayQueueBinding(){
    
    
        return BindingBuilder.bind(delayQueue()).to(delayExchange()).with(DELAY_ROUTING_KEY);
    }

}

配置分为两组，第一组配置普通队列，第二组配置死信队列。每一组都由消息队列、交换机以及 Binding 三者组成。

3.3.2 生产者代码

@Slf4j
@RequestMapping("ttl")
@RestController
public class SendMsgController {
    
    

    private static final String DELAY_EXCHANGE_NAME="DELAY_EXCHANGE_NAME";

    private static final String DELAY_ROUTING_KEY="DELAY_ROUTING_KEY";

    private static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";

    private static final String DELAYED_ROUTING_KEY = "delayed.routingkey";

    @GetMapping("sendDelayMsg/{message}/{delayTime}")
    public void sendMsg(@PathVariable String message,@PathVariable String delayTime) {
    
    
        rabbitTemplate.convertAndSend(DELAY_EXCHANGE_NAME, DELAY_ROUTING_KEY, message,
                correlationData ->{
    
    
                    correlationData.getMessageProperties().setExpiration(delayTime);

                    return correlationData;
                });
        log.info(" 基于死信队列实现，当 前 时 间 ： {}, 发送一条延迟 {} 毫秒的信息给队列DELAY_QUEUE:{}", new
                Date(),delayTime, message);
    }

3.3.3 消费者代码

@Slf4j
@Component
public class DeadLetterQueueConsumer {
    
    

    private static final String DEAD_QUEUE="DEAD_QUEUE";

    @RabbitListener(queues = DEAD_QUEUE)
    public void receiveDeadQueue(Message message){
    
    
        String msg = new String(message.getBody());
        log.info("当前时间：{},收到死信队列信息：{}", new Date().toString(), msg);
    }
}

通过Swagger：http://localhost:8080/swagger-ui.html，调用/ttl/sendDelayMsg接口进行测试。

通过在消息属性上设置TTL的方式，可以满足同类型消息不同延时时间的需求，但是因为RabbitMQ只会检查第一个消息是否过期，如果过期则丢到死信队列，如果第一个消息的延时时间很长则会影响到后面消息的消费。模拟上述场景如下所示

可以看到首先发送的延时 50000000 毫秒的消息影响到了后面消息的消费。上述的问题我们可以通过使用RabbitMQ官方提供的rabbitmq_delayed_message_exchange插件解决。

4. RabbitMQ插件实现延迟队列

基于RabbitMQ插件实现延迟队列，只需要创建一个交换机和一个队列使用起来比基于死信队列实现更为简单

4.1 安装RabbitMQ插件

下载插件rabbitmq_delayed_message_exchange

wget https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases/download/v3.8.0/rabbitmq_delayed_message_exchange-3.8.0.ez

rabbitmq_delayed_message_exchange插件的官方Github链接：https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases

将文件拷贝到Docker容器中

docker cp rabbitmq_delayed_message_exchange-3.8.0.ez 900822f303cd:/opt/rabbitmq/plugins

进入RabbitMQ容器

docker exec -it 900822f303cd /bin/sh

启用插件

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

查看插件是否启动成功

rabbitmq-plugins list

重新启动RabbitMQ容器

在RabbitMQ管理界面查看，创建交换机的页面，如果看到交换机的类型多了一个“x-delayed-message”的选项则表明插件安装成功了。

该type=x-delayed-message的交换机支持延迟投递机制 消息传递后并不会立即投递到目标队列中，而是存储在本地的Mnesia(一个分布式数据库)表中，当达到投递时间时，才会投递到目标队列中。

4.2 使用示例

创建配置类DelayedQueueConfig ，用于配置交换机和队列

@Configuration
public class DelayedQueueConfig {
    
    

    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);
    }

    /**
     * 自定义交换机 我们在这里定义的是一个延迟交换机
     */
    @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();
    } }

创建生产者代码

@Slf4j
@RequestMapping("ttl")
@RestController
public class SendMsgController {
    
    

    private static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";

    private static final String DELAYED_ROUTING_KEY = "delayed.routingkey";


    @GetMapping("sendDelayMsg2/{message}/{delayTime}")
    public void sendMsg2(@PathVariable String message,@PathVariable Integer delayTime) {
    
    
        rabbitTemplate.convertAndSend(DELAYED_EXCHANGE_NAME, DELAYED_ROUTING_KEY, message,
                correlationData ->{
    
    
                    correlationData.getMessageProperties().setDelay(delayTime);

                    return correlationData;
                });
        log.info(" 基于插件实现，当 前 时 间 ： {}, 发送一条延迟 {} 毫秒的信息给队列 delayed.queue:{}", new
                Date(),delayTime, message);
    }


}

创建消费者代码

@Slf4j
@Component
public class DeadLetterQueueConsumer {
    
    
    private static final String DELAYED_QUEUE_NAME = "delayed.queue";

    @RabbitListener(queues = DELAYED_QUEUE_NAME)
    public void receiveDelayedQueue(Message message){
    
    
        String msg = new String(message.getBody());
        log.info("当前时间：{},收到延时队列的消息：{}", new Date().toString(), msg);
    }

}

通过Swagger：http://localhost:8080/swagger-ui.html，调用/ttl/sendDelayMsg2接口进行测试。

通过测试可以看到，即使第一天消息的延迟时间很长，但是并不会影响到后面消息的消费。

笔记总结自课程：https://www.bilibili.com/video/BV1cb4y1o7zz
更多：
1.延迟消息的五种实现方案