死信队列使用-订单超时未支付监控

执行流程

消息->延时队列，消息超时后->根据绑定哒死信交换器进入死信队列->消费者根据死信路由键进行消费处理。

配置类

@Slf4j
@Data
@ConfigurationProperties(prefix = "mq.conf")
@Component
public class OrderRabbitConfig {
    /**
     * 支付延迟队列交换器
     */
    private String delayExchange;
    /**
     * 死信队列交换器
     */
    private String deadExchange;
    /**
     * 死信队列路由键
     */
    private String deadKey;
    /**
     * 延迟队列路由键
     */
    private String delayKey;
    /**
     * 死信队列名称
     */
    private String deadQueue;
    /**
     * 延迟队列名称
     */
    private String delayQueue;
    /**
     * 延迟队列超时时间
     */
    private Long timeOut;
    /**
     * 取消未支付订单交换器
     */
    private String cancleOrderExchange;
    /**
     * 取消未支付订单队列名称
     */
    private String cancleOrderQueue;
    /**
     * 取消未支付订单路由键
     */
    private String cancleOrderRoutingKey;


    // 声明延时Exchange
    @Bean("delayExchange")
    public DirectExchange delayExchange() {
        log.info("创建延时交换器{}", delayExchange);
        return new DirectExchange(delayExchange);
    }

    // 声明死信Exchange
    @Bean("deadLetterExchange")
    public DirectExchange deadLetterExchange() {
        log.info("创建死信交换器{}", deadExchange);
        return new DirectExchange(deadExchange);
    }

    // 声明延时队列C
    // 并绑定到对应的死信交换机
    @Bean("delayQueue")
    public Queue delayQueueC() {
        log.info("声明延迟队列并绑定死信交换器");
        Map<String, Object> args = new HashMap<>(3);
        // x-dead-letter-exchange    这里声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", deadExchange);
        // x-dead-letter-routing-key  这里声明当前队列的死信路由key
        args.put("x-dead-letter-routing-key", deadKey);
        args.put("x-message-ttl", timeOut);
        return QueueBuilder.durable(delayQueue).withArguments(args).build();
    }

    // 声明死信队列 用于接收延时任意时长处理的消息
    @Bean("deadLetterQueue")
    public Queue deadLetterQueueC() {
        return new Queue(deadQueue);
    }

    // 声明延时列绑定关系
    @Bean
    public Binding delayBinding(@Qualifier("delayQueue") Queue queue,
                                @Qualifier("delayExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(delayKey);
    }

    // 声明死信队列绑定关系
    @Bean
    public Binding deadLetterBinding(@Qualifier("deadLetterQueue") Queue queue,
                                     @Qualifier("deadLetterExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(deadKey);
    }


    @Bean("cancleOrderExchange")
    public DirectExchange cancleOrderExchange() {
        log.info("创建取消订单交换器{}", cancleOrderExchange);
        return new DirectExchange(cancleOrderExchange);
    }

    @Bean("cancleOrderQueue")
    public Queue cancleOrderQueue() {
        log.info("创建取消订单队列{}", cancleOrderQueue);
        return new Queue(cancleOrderQueue);
    }

    @Bean
    public Binding cancleRegistBinding(@Qualifier("cancleOrderQueue") Queue queue,
                                       @Qualifier("cancleOrderExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(cancleOrderRoutingKey);
    }
}

配置文件

#下单超时监控
mq.conf.delayQueue = order_pay_delay_queue
mq.conf.deadQueue = order_pay_dead_queue
mq.conf.delayExchange = order_pay_delay_exchange
mq.conf.deadExchange = order_pay_dead_exchange
mq.conf.delayKey = order_pay_routing_key
mq.conf.deadKey = order_pay_routing_key
mq.conf.timeOut = 300000
mq.conf.cancleOrderExchange = cancle_order_exchage
mq.conf.cancleOrderQueue = cancle_order_queue
mq.conf.cancleOrderRoutingKey = cancle_order_routing_key

生产者

@Component
@Slf4j
public class MessageProducer {
    @Autowired
    OrderRabbitConfig config;
    
    @Autowired
    private MqProducer mqProducer;
    /**
     * 将未支付的消息发送到延迟队列进行超时监控
     *
     * @param msg
     */
    public void sendUnPaidOrderMsg(String msg) {
        log.info("开始发送延迟消息，delayExchangeName {} delayQueueRoutingKey {}  {}", config.getDelayExchange(), config.getDelayKey(), msg);
        mqProducer.sendMq(config.getDelayExchange(), config.getDelayKey(), msg, false);
    }
}

消费者

import java.nio.charset.StandardCharsets;
import java.util.Date;

/**
 * 死信队列消费者
 *
 * @author xxd
 */
@Component
@Slf4j
@RabbitListener(queuesToDeclare = {@Queue(name = "${mq.conf.deadQueue}")})
public class DeadMessageConsumer extends MqConsumerTemplate {
    @Autowired
    OrderService orderService;
    @Value("${mq.conf.deadQueue}")
    private String deadQueue;
    @Autowired
    private OrderMapper orderMapper;

    @Override
    public boolean process(String s) {
        String msg = new String(s.getBytes(StandardCharsets.UTF_8));
        log.info("当前时间：{},死信队列{}收到消息：{}", new Date().toString(), deadQueue, msg);
        Order order = JSONUtil.toBean(msg, Order.class);
        Order existOrder = orderServiceMapper.getByOrderCode(order.getOrderCode());
        if (existOrder != null) {
            Integer payStatus = existOrder.getPayStatus();
            //订单超时未支付，取消订单
            if (payStatus != null && payStatus == OrderPayStatusEnum.UNPAID.getStatus()) {
                orderServiceService.cancelUnPayForm(existOrder);
                log.info("死信队列消费成功，{}", order.getOrderCode());
            }
        }
        return true;
    }
}


**补充：**
其实还可以用Redis 的ZSET，SCORE使用时间戳，程序判断当前时间戳与REDIS中时间戳进行比较来实现，感觉也是一种可行方案，欢迎补充！

大家不要卷啦！hiahiahia！
转载注明呀，Thanks♪(･ω･)ﾉ！ 虽然现在还没有5555~ 咳咳 严肃严肃！