RabbiiMQ借助队列TTL实现延迟队列

队列TTL

代码架构图

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

队列和交换机配置类代码

@Configuration
public class ExerciseTtlQueueConfig {
    private static final String X_EXCHANGE = "X";
    private static final String QUEUE_A = "QA";
    private static final String QUEUE_B = "QB";

    private static final String Y_DEAD_LETTER_EXCHNGE = "Y";
    private static final String DEAD_LETTER_QUEUE = "QD";
    //声明xExchange
    @Bean("xExchange")
    public DirectExchange xExchange(){
        return new DirectExchange(X_EXCHANGE);
    }

    //声明yExchange
    @Bean("yExchange")
    public DirectExchange yExchange(){
        return new DirectExchange(Y_DEAD_LETTER_EXCHNGE);
    }
    //声明队列A ttl为10s，并绑定到对应的死信交换机
    @Bean("queueA")
    public Queue queueA(){
        Map<String,Object> args = new HashMap<>();
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange",Y_DEAD_LETTER_EXCHNGE);
        //声明当前队列的死信路由key
        args.put("x-dead-letter-routing-key","YD");
        //声明队列的TTL
        args.put("x-message-ttl",10000);
        return QueueBuilder.durable(QUEUE_A).withArguments(args).build();
    }
    //声明队列A绑定X交换机
    @Bean
    public Binding queueBindingX(@Qualifier("queueA") Queue queueA,
                                 @Qualifier("xExchange")DirectExchange xExchange){
        return BindingBuilder.bind(queueA).to(xExchange).with("XA");
    }

    //声明队列BB ttl为10s，并绑定到对应的死信交换机
    @Bean("queueB")
    public Queue queue(){
        Map<String,Object> args = new HashMap<>();
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange",Y_DEAD_LETTER_EXCHNGE);
        //声明当前队列的死信路由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交换机
    @Bean
    public Binding queueBinding(@Qualifier("queueB") Queue queueB,
                                 @Qualifier("xExchange")DirectExchange xExchange){
        return BindingBuilder.bind(queueB).to(xExchange).with("XB");
    }
    //声明死信队列
    @Bean("queueD")
    public Queue queueD(){
        return new Queue(DEAD_LETTER_QUEUE);
    }
    //声明死信队列和死信交换机绑定
    public Binding deadLetterBindingQAD(@Qualifier("queueD")Queue queueD,
                                 @Qualifier("yExchange")DirectExchange  yExchange){
        return BindingBuilder.bind(queueD).to(yExchange).with("YD");
    }

}

生产者代码如下所示

//开始发消息
    @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);
    }

消费者代码如下

@Slf4j
@Component
public class DeadLetterQueueConsumer {
    //接收消息
    @RabbitListener(queues = "QD")
    public void receiveD(Message message, Channel channel) throws Exception{
      String msg = new String(message.getBody(), StandardCharsets.UTF_8) ;
      log.info("当前时间：{},收到死信队列的消息：{}",new Date().toString(),msg);

    }

}

但是上面这种方式有一个缺陷就是一个时间就要一个队列，那么可以和前面博客中的一样，把延迟时间写在生产者中，就可以自己设置时间变量。

这里就是由于队列的特性，先进先出，所以会等到第一个消息执行完成之后再执行第二个消息。

针对这个问题，rabbitmq提供了插件解决方式
在官网上下载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
添加完插件之后在图形化管理界面中点击添加一个交换机，会出现x-delayed-message类型的交换机。这就是延迟类型交换机。

代码架构图