RabbitMQ的消息延迟两种实现--死信和插件

在实际场景中，我们经常会有这种情况，当用户进入支付页面，但是不支付退出，通常会出现30min支付时间，否则订单取消的场景，那么这种就可以用到消息延迟

RabbitMQ的消息延迟有两种实现方案：死信和RabbitMQ插件

死信队列，在队列中并没有明确的指定哪种是死信队列，所以需要我们自己通过配置去实现

RabbitMQ插件rabbitmq_delayed_message_exchange：RabbitMQ的版本必须是3.5.8以上

死信：

原理：

当提交订单后，未支付，设置订单30分钟超时。

当改订单，30分钟后还未支付，那么进入死信队列。

对死信队列做监听，当死信队列有数据，那么根据数据的信息修改数据库的订单状态。

代码：

生产者项目，新增死信的配置

package com.lyc.springbootmqproducers.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class SiXinRabbitConfig {

    /**
     * 死信队列
     */
    @Bean
    public Queue sixinQueue(){
        return new Queue("sixinQueue",true);
    }

    /**
     * 死信交换机
     * @return
     */
    @Bean
    DirectExchange sixinExchange(){
        return new DirectExchange("sixinExchange");
    }

    /**
     * 绑定
     * @return
     */
    @Bean
    Binding bindingSiXinDirect() {
        return BindingBuilder.bind(sixinQueue()).to(sixinExchange()).with("sixinDirectRouting");
    }

    /**
     * 声明订单业务交换机
     * @return DirectExchange
     */
    @Bean
    public DirectExchange orderExchange() {
        return new DirectExchange("orderExchange");
    }

    /**
     * 声明订单业务队列
     * @return Queue
     */
    @Bean
    public Queue orderQueue() {
        Map<String,Object> arguments = new HashMap<>(2);
        // 绑定该队列到死信交换机
        arguments.put("x-dead-letter-exchange","sixinExchange");
        arguments.put("x-dead-letter-routing-key","sixinDirectRouting");
        return new Queue("orderQueue",true,false,false,arguments);
    }

    /**
     * 绑定订单队列到订单交换机
     * @return Binding
     */
    @Bean
    public Binding orderBinding() {
        return BindingBuilder.bind(orderQueue())
                .to(orderExchange())
                .with("orderRoutingKey");

    }

}

新增请求类

/**
     * 死信
     * 发送带有过期时间的消息
     * @return
     */
    @GetMapping("/sendSiXin")
    public String sendSiXin() {
        String messageData = "message: 死信 ";
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setMessageId(UUID.randomUUID().toString());
        messageProperties.setContentEncoding("utf8");
        Message message = new Message(messageData.getBytes(), messageProperties);
        message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
        // 模拟，设置10S后消息过期
        message.getMessageProperties().setExpiration("10000");
        rabbitTemplate.convertAndSend("orderExchange", "orderRoutingKey", message);
        return "ok";
    }

消费者代码，监听死信队列，当有消息就去处理，此处用的手动应答

package com.lyc.springbootmq.customer;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Map;

/**
 * 监听的队列名称 sixinQueue
 */
@Component

public class SIxinDirectReceiver {

    @RabbitHandler
    @RabbitListener(queues = "sixinQueue")//监听的队列名称 sixinQueue
    public void process(Message testMessage, Channel channel) throws IOException {
        long deliveryTag = testMessage.getMessageProperties().getDeliveryTag();
        //手工ack
        channel.basicAck(deliveryTag,true);
        System.out.println("监听死信队列消费者收到消息  : " + testMessage.toString());
    }

}

测试:

启动生产者项目，并请求localhost:6060/rabbiMQDemo/sendSiXin，在RabbitMQ中出现，死信队列和订单队列，并且在订单队列中有一条数据

10s后订单过期，直接进入死信队列

启动消费者，消费者监听的是死信队列，因为死信队列有数据所以直接消费

控制台输出

监听死信队列消费者收到消息  : (Body:'[B@326796c2(byte[16])' MessageProperties [headers={spring_listener_return_correlation=b15a49b1-6530-434c-8b90-a43b38663735, x-first-death-exchange=orderExchange, x-death=[{reason=expired, original-expiration=10000, count=1, exchange=orderExchange, time=Tue Apr 13 15:37:46 CST 2021, routing-keys=[orderRoutingKey], queue=orderQueue}], x-first-death-reason=expired, x-first-death-queue=orderQueue}, messageId=6d764647-1d2a-4bfb-816b-dfc2c5c8d473, contentType=application/octet-stream, contentEncoding=utf8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, redelivered=false, receivedExchange=sixinExchange, receivedRoutingKey=sixinDirectRouting, deliveryTag=1, consumerTag=amq.ctag-3ZsP-Hfc6UeMhUQvSTjolw, consumerQueue=sixinQueue])

在消费者这可以调用其他业务去对订单状态修改。

死信完毕

RabbitMQ插件rabbitmq_delayed_message_exchange

下载插件地址：官网或者这里

下载后将文件放入RabbitMQ下的plugins文件中

在plugins文件下执行rabbitmq-plugins.bat enable rabbitmq_delayed_message_exchange，后重启RabbitMQ

验证

生产者配置类

package com.lyc.springbootmqproducers.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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * 配置类
 */
@Configuration
public class ChaJianRabbitConfig {

    /**
     * 创建交换机，如果用插件使用CustomExchange创建
     * @return
     */
    @Bean
    public CustomExchange delayExchange() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-delayed-type", "direct");
        return new CustomExchange("delayed_exchange", "x-delayed-message", true, false, args);
    }

    @Bean
    public Queue queue() {
        Queue queue = new Queue("delay_queue_1", true);
        return queue;
    }

    @Bean
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(delayExchange()).with("delay_routing_1").noargs();
    }


}

生产者新增请求

@GetMapping("/sendChaJIAN")
    public String sendChaJIAN() {
        String messageData = "message: 插件 ";
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setMessageId(UUID.randomUUID().toString());
        messageProperties.setContentEncoding("utf8");
        Message message = new Message(messageData.getBytes(), messageProperties);
        message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
        // 模拟，设置10S后消息过期
        message.getMessageProperties().setHeader("x-delay", 50000);
        rabbitTemplate.convertAndSend("delayed_exchange", "delay_routing_1", message);
        return "ok";
    }

消费者监听队列

package com.lyc.springbootmq.customer;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * 监听的队列名称 delay_queue_1
 */
@Component

public class ChajianDirectReceiver {

    @RabbitHandler
    @RabbitListener(queues = "delay_queue_1")//监听的队列名称 delay_queue_1
    public void process(Message testMessage, Channel channel) throws IOException {
        long deliveryTag = testMessage.getMessageProperties().getDeliveryTag();
        //手工ack
        channel.basicAck(deliveryTag,true);
        System.out.println("监听插件队列消费者收到消息  : " + testMessage.toString());
    }

}

测试：

启动生产者项目，请求localhost:6060/rabbiMQDemo/sendChaJIAN，因为设置了延时时间50000毫秒，5W毫秒以后队列中会出现一条消息

50000毫秒后

启动消费者，因为监听了这个队列，启动之后直接消费

控制台输入

监听插件队列消费者收到消息  : (Body:'[B@20ecb143(byte[16])' MessageProperties [headers={spring_listener_return_correlation=6d5448f6-8c68-4d89-8d34-c0d200cd2795}, messageId=10cc314f-fff2-4e24-99b8-fc116bc1858c, contentType=application/octet-stream, contentEncoding=utf8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, redelivered=false, receivedExchange=delayed_exchange, receivedRoutingKey=delay_routing_1, receivedDelay=50000, deliveryTag=1, consumerTag=amq.ctag-IcFsaAxVercH4N47y7cCtg, consumerQueue=delay_queue_1])

插件版消息延迟完成