RabbitMQ之延迟队列

1. 场景：“订单下单成功后，10分钟未支付自动取消”
   1.传统处理超时订单
   采取定时任务轮询数据库订单，并且批量处理。其弊端也是显而易见的；对服务器、数据库性会有很大的要求，
   并且当处理大量订单起来会很力不从心,而且实时性也不是特别好。当然传统的手法还可以再优化一下，
   即存入订单的时候就算出订单的过期时间插入数据库，设置定时任务查询数据库的时候就只需要查询过期了的订单，
   然后再做其他的业务操作

   2.rabbitMQ延时队列方案
   一台普通的rabbitmq服务器单队列容纳千万级别的消息还是没什么压力的，而且rabbitmq集群扩展支持的也是非常好的，
   并且队列中的消息是可以进行持久化，即使我们重启或者宕机也能保证数据不丢失

2. TTL和DLX
   rabbitMQ中是没有延时队列的，也没有属性可以设置，只能通过死信交换器(DLX)和设置过期时间(TTL)结合起来实现延迟队列

   1.TTL
   TTL是Time To Live的缩写, 也就是生存时间。
   RabbitMq支持对消息和队列设置TTL，对消息这设置是在发送的时候指定，对队列设置是从消息入队列开始计算, 只要超过了队列的超时时间配置, 那么消息会自动清除。
   如果两种方式一起使用消息对TTL和队列的TTL之间较小的为准，也就是消息5s过期，队列是10s，那么5s的生效。
   默认是没有过期时间的，表示消息没有过期时间；如果设置为0，表示消息在投递到消费者的时候直接被消息，否则丢弃。

   设置消息的过期时间用 x-message-ttl 参数实现，单位毫秒。
   设置队列的过期时间用 x-expires 参数，单位毫秒，注意，不能设置为0。

   2.DLX和死信队列
   DLX即Dead-Letter-Exchange(死信交换机)，它其实就是一个正常的交换机，能够与任何队列绑定。

   死信队列是指队列(正常)上的消息(过期)变成死信后，能够后发送到另外一个交换机(DLX)，然后被路由到一个队列上，
   这个队列，就是死信队列

   成为死信一般有以下几种情况：
   消息被拒绝(basic.reject or basic.nack)且带requeue=false参数
   消息的TTL-存活时间已经过期
   队列长度限制被超越(队列满)

   注1：如果队列上存在死信， RabbitMq会将死信消息投递到设置的DLX上去 ，
   注2：通过在队列里设置x-dead-letter-exchange参数来声明DLX，如果当前DLX是direct类型还要声明
   x-dead-letter-routing-key参数来指定路由键，如果没有指定，则使用原队列的路由键

3. 延迟队列 即时消费
   通过DLX和TTL模拟出延迟队列的功能，即，消息发送以后，不让消费者拿到，而是等待过期时间，变成死信后，发送给死信交换机再路由到死信队列进行消费

   

4. 开发步骤

生产者：

DlxConfig ：

package com.xujie.rabbitmqprovider.config;



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

/**
 * @author 许缘
 * @company xxx公司
 * @create 2023-01-01  19:28
 * 延时队列
 */
@Configuration
public class DlxConfig {

    //延时
    public static final String NORMAL_EXCHANGE="normal_exchange";
    public static final String NORMAL_QUEUE="normal_queue";
    public static final String NORMAL_ROUTING_KEY="normal_routing_key";

    //死信
    public static final String DLX_EXCHAGE = "dlx_exchage";
    public static final String DLX_QUEUE = "dlx_queue";
    public static final String DLX_ROUTING_KEY = "dlx_routing_key";

    //设置过期时间
    public static final Long TTL = 15000L;

    //定义正常队列
    @Bean
    public Queue normalQueue(){

        //durable：true则持久队列
        //exclusive：如果我们声明一个排他队列（该队列将仅由声明者的连接使用），则为true
        //autoDelete：服务器不再使用时应删除队列，则为true
        //arguments：用于声明队列的参数
        String name = NORMAL_QUEUE;
        boolean durable = true;
        boolean exclusive = false;
        boolean autoDelete = false;
        Map<String, Object> arguments = new HashMap<String, Object>();
        arguments.put("x-message-ttl", TTL);//message在该队列queue的存活时间最大为10秒
        arguments.put("x-dead-letter-exchange", DLX_EXCHAGE); //x-dead-letter-exchange参数是设置该队列的死信交换器（DLX）
        arguments.put("x-dead-letter-routing-key", DLX_ROUTING_KEY);//x-dead-letter-routing-key参数是给这个DLX指定路由键
        return new Queue(name, durable, exclusive, autoDelete, arguments);
    }


    //定义正常交换机
    @Bean
    public DirectExchange normalDirectExchange(){
        return new DirectExchange(NORMAL_EXCHANGE);
    }

    //将正常交换机和正常队列绑定
    @Bean
    public Binding bindingNormalQueueToNormalExchange(){
        return BindingBuilder.bind(normalQueue()).to(normalDirectExchange())
                .with(NORMAL_ROUTING_KEY);
    }

    //定义死信队列
    @Bean
    public Queue dlxQueue(){
        return new Queue(DLX_QUEUE,true);
    }

    //定义死信交换机（直连）
    @Bean
    public DirectExchange dlxExchange(){
        return new DirectExchange(DLX_EXCHAGE);
    }

    //将死信队列和死信交换机进行绑定
    @Bean
    public Binding bindingDlxQueueToDlxExchange(){
        return BindingBuilder.bind(dlxQueue())
                .to(dlxExchange())
                .with(DLX_ROUTING_KEY);
    }



}

sendController:

 /**
     * 延迟队列
     * @return
     */
    @RequestMapping("/senderDlx")
    public Map<String,Object> senderDlx(){
        Map<String,Object> data = this.toJson("将信息发送到延迟交换机");
        //发送消息

        rabbitTemplate.convertAndSend("normal_exchange","normal_routing_key",data);
        Map<String,Object> rs= new HashMap<>();
        rs.put("success",true);
        rs.put("msg","ok");
        rs.put("ts",new Date().toLocaleString());
        return rs;
    }
    private Map<String,Object> toJson(String msg){
        Map<String,Object> json = new HashMap<>();
        json.put("code",200);
        json.put("msg",msg);
        json.put("createdate", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        return json;
    }

消费者:
DlxConsumer :

package com.xujie.rabbitmqconsumer.li;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @author 许缘
 * @company xxx公司
 * @create 2022-12-31  9:42
 */
@Component
@RabbitListener(queues = {"dlx_queue"})
public class DlxConsumer {
    @RabbitHandler
    public void handler(Map<String,Object> json){
        System.out.println(json);
    }
}