RabbitMQ TTL延迟队列使用细节

TTL延迟队列使用的场景

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

springboot整合mq

//
 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
              <!--RabbitMQ 测试依赖-->
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>

TTL队列的优化过程（找问题，解决问题，优化代码）

配置类，配置两个交换机，两个死信队列，一个普通队列

package com.example.demo.mq;


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

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

@Configuration
public class TtlQueueConfig {
    public static final String normalExchange = "normalX";
    public static final String queue_A = "queue_A";
    public static final String queue_B = "queue_B";
    public static final String deadExchange = "deadY";
    public static final String deadExchange_letter_queuq = "queueD";

    @Bean
    public DirectExchange normalExchange() {
        return new DirectExchange(normalExchange);
    }

    @Bean
    public DirectExchange deadExchange() {
        return new DirectExchange(deadExchange);
    }

    @Bean
    public Queue queueA() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-dead-letter-exchange", deadExchange);
        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 queueBindingX(@Qualifier("queueA") Queue queueA,
                                  @Qualifier("normalExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueA).to(xExchange).with("XA");
    }

    @Bean
    public Queue queueB() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-dead-letter-exchange", deadExchange);
        args.put("x-dead-letter-routing-key", "YD");
        args.put("x-message-ttl", 1000);
        return QueueBuilder.durable(queue_B).withArguments(args).build();
    }

    @Bean
    public Binding queueBBindX(@Qualifier("queueB") Queue queueB,
                               @Qualifier("normalExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueB).to(normalExchange()).with("XB");
    }

    @Bean
    public Queue queueD() {
        return new Queue(deadExchange_letter_queuq);
    }

    @Bean
    public Binding queueDBindY(@Qualifier("queueD") Queue queueD,
                               @Qualifier("deadExchange") DirectExchange deadExchange) {
        return BindingBuilder.bind(queueD).to(deadExchange).with("YD");
    }
}

生产者

package com.example.demo.mq;

import lombok.extern.log4j.Log4j;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.Date;

@RequestMapping("ttl")
@Controller
@Slf4j
public class Producer {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("sendMsg/{message}")
    public void sendMsg(@PathVariable("message") String message) {
        log.info("消息来了" + new Date().toString() + message);
        rabbitTemplate.convertAndSend("normalX", "XA", "10s"+message.getBytes());
        rabbitTemplate.convertAndSend("normalX", "XB", "1s"+message.getBytes());
    }
}

消费者

package com.example.demo.mq;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;


import org.springframework.stereotype.Component;

import java.io.IOException;

import java.util.Date;

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

}

解决问题一：当需要一个新的死信时间时，就需要重新声明一个队列

解决思路：在生产者处声明消息的过期时间（不在声明队列的时候绑定时间）

    public void sendMsg(@PathVariable("msg") String msg, @PathVariable("ttlTime") String ttlTime) {

        log.info("消息来了" + new Date().toString() + msg + ttlTime);
        rabbitTemplate.convertAndSend(TtlQueueConfig.normalExchange,
                "XC", msg.getBytes(), correlationData -> {
                    correlationData.getMessageProperties().setExpiration(ttlTime);
                    return correlationData;
                });
    }

问题又来了，当只有一个队列的时候，先输入长时间的消息再输入短时间过期的消息，短时间过期的消息会在长过期消息输出后在输出

因为 RabbitMQ 只会检查第一个消息是否过期，如果过期则丢到死信队列，
如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行

解决方法： Rabbitmq 插件实现延迟队列

//交换机的类型为x-delayed-message
//x-delayed-type设置为direct交换机
    @Bean
    public CustomExchange customExchange() {
        Map<String, Object> map = new HashMap<>();
        map.put("x-delayed-type", "direct");
        return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false, map);
    }

该类型消息支持延迟投递机制， 消息传递后并不会立即投递到目标队列中
等消息过期时间到后在传递信息。相当于在交换机处进行了排序