延迟队列介绍

延迟队列是死信队列的一种，如果通过过期时间来设置死信，且普通队列没有消费者，就成了延迟队列。

生产者发送消息 ---> 到达普通队列 ---> 等待过期时间 ---> 进入死信队列 ----> 被死信消费者消费。

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

 QC的存活时间由生产者确定

代码实现上面这张图：

@Configuration
public class TtlQueueConfig {

    // 普通交换机

    public static final String X_EXCHANGE = "X";

    // 死信交换机

    public static final String Y_DEAD_LETTER_EXCHANGE = "Y";

    // 普通队列

    public static final String Queue_a = "QA";
    public static final String Queue_b = "QB";


    // 死信队列

    public static final String DEAN_LETTER_QUEUE = "QD";

    // 普通队列名称
    public static final String Queue_c = "QC";

    /**
     * 存活时间暂时不写
     * @return
     */
    @Bean("queueC")
    public Queue queueC(){
        Map<String,Object> map = new HashMap<String, Object>() ;
        map.put("x-dead-letter-exchange",Y_DEAD_LETTER_EXCHANGE);
        map.put("x-dead-letter-routing-key","YD");
        return QueueBuilder.durable(Queue_c).withArguments(map).build();
    }

    @Bean
    public Binding queueCBindingX(@Qualifier("queueC") Queue queueC,
                                  @Qualifier("xExchange") DirectExchange xExchange){

        return BindingBuilder.bind(queueC).to(xExchange).with("XC");

    }

    // 声明 xExchange
    @Bean("xExchange")
    public DirectExchange xExchange(){
        return new DirectExchange(X_EXCHANGE); }

    // 声明死信交换机 yExchange
    @Bean("yExchange")
    public DirectExchange yExchange(){
        return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
    }

    // 声明队列 有过期时间的
    @Bean("queueA")
    public Queue queueA(){
        Map<String,Object> args = new HashMap<>();
        // 设置死信交换机
        args.put("x-dean-letter-exchange",Y_DEAD_LETTER_EXCHANGE);
        // 设置死信routingKey
        args.put("x-dead-letter-routing-key","YD");
        // 设置过期时间
        args.put("x-mesage-ttl",1000);

        return QueueBuilder.durable(Queue_a).withArguments(args).build();

    }

    // 声明队列  有过期时间的
    @Bean("queueB")
    public Queue queueB(){
        Map<String,Object> args = new HashMap<>();
        // 设置死信交换机
        args.put("x-dean-letter-exchange",Y_DEAD_LETTER_EXCHANGE);
        // 设置死信routingKey
        args.put("x-dead-letter-routing-key","YD");
        // 设置过期时间
        args.put("x-mesage-ttl",4000);

        return QueueBuilder.durable(Queue_b).withArguments(args).build();

    }

    // 死信队列
    @Bean("queueD")
    public Queue queueD(){
        return QueueBuilder.durable().build();
    }

    // 设置队列与交换机的绑定

    /**
     * 队列a绑定交换机X
     * @param queueA
     * @param xExchange
     * @return
     */
    @Bean
    public Binding queueABindingX(@Qualifier("queueA") Queue queueA,
                                  @Qualifier("xExchange") DirectExchange xExchange){
        // 其中with里面设置routingkey
        return BindingBuilder.bind(queueA).to(xExchange).with("XA");
    }

    /**
     * 队列B 绑定交换机X
     * @param queueB
     * @param xExchange
     * @return
     */
    @Bean
    public Binding queueBBindingX(@Qualifier("queueB") Queue queueB,
                                  @Qualifier("xExchange") DirectExchange xExchange){
        // 其中with里面设置routingkey
        return BindingBuilder.bind(queueB).to(xExchange).with("XB");
    }

    /**
     * 队列D绑定交换机 Y
     * @param queueD
     * @param yExchange
     * @return
     */
    @Bean
    public Binding queueDBindingX(@Qualifier("queueD") Queue queueD,
                                  @Qualifier("yExchange") DirectExchange yExchange){
        // 其中with里面设置routingkey
        return BindingBuilder.bind(queueD).to(yExchange).with("YD");
    }
}

/**
 * 生产者
 */
@RestController
@RequestMapping("/ttlapi/v1")
@Slf4j
public class SendMsg {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/sendmsg/{message}")
    public void senMsg(@PathVariable String message){
        log.info("发送延迟消息，当前时间:{},消息内容:{}",new Date().toString(),message);

        rabbitTemplate.convertAndSend("X","XA","消息来自ttl为10s的队列"+message);
        rabbitTemplate.convertAndSend("X","XB","消息来自ttl为40s的队列"+message);

    }

    // 开始法消息  消息TTL
    @GetMapping("sendmsg/{message}/{ttlTime}")
    public void sendMsg(@PathVariable String message,
                        @PathVariable String ttlTime){
        log.info("发送延迟消息给ttl队列，当前时间:{},消息内容:{}",new Date().toString(),message);
        rabbitTemplate.convertAndSend("X","XC",message,msg->{
            // 发送消息的延迟时长
            msg.getMessageProperties().setExpiration(ttlTime);
            return msg;
        });


    }
}

/**
 * 消费者
 * 是一个监听器，监听死信队列
 */
@Slf4j
@Component
public class DeadLetterQueueConsumer {

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

}