支付超时订单关单策略之RabbitMQ死信队列方式

目录

一、需求背景之为什么要有超时关单

二、所以多数订单业务都是会有这个功能，那如何设计呢？

​三、RabbitMQ死信队列-延迟消息知识点回顾

3.1什么是rabbitmq的死信队列

3.2什么是rabbitmq的死信交换机

 3.3消息有哪几种情况成为死信

3.4什么是延迟队列

四、代码环节

 4.1 Rabbitmq死信队列配置         

4.2延迟消息的发送

4.3关单消费者处理

---

一、需求背景之为什么要有超时关单

 原因一：第三方支付平台的支付连接都是有时效性，创建订单后，需要再一定的时间内支付完成
    微信支付、支付宝支付等
    也可以不关闭订单，做订单二次支付的操作，但业务链路会更加复杂
 原因二：电商业务里面还会涉及到商品库存的锁定和释放

二、所以多数订单业务都是会有这个功能，那如何设计呢？

三、RabbitMQ死信队列-延迟消息知识点回顾

3.1什么是RabbitMQ的死信队列

        没有被及时消费的消息存放的队列

3.2什么是rabbitmq的死信交换机

    Dead Letter Exchange(死信交换机，缩写：DLX)当消息成为死信后，会被重新发送到另一个交换机，这个交换机就是DLX死信交换机

 3.3消息有哪几种情况成为死信

    消费者拒收消息（basic.reject/ basic.nack），并且没有重新入队 requeue=false
    消息在队列中未被消费，且超过队列或者消息本身的过期时间TTL(time-to-live)
    队列的消息长度达到极限
    结果：消息成为死信后，如果该队列绑定了死信交换机，则消息会被死信交换机重新路由到死信队列

3.4什么是延迟队列

        一种带有延迟功能的消息队列，Producer 将消息发送到消息队列 服务端，但并不期望这条消息立马投递，而是推迟到在当前时间点之后的某一个时间投递到 Consumer 进行消费，该消息即定时消息
    业界的一些实现方式:
           .定时任务高精度轮训
           .redis监听key过期
           .jdk自带的DelayQueue
           .采用RocketMQ自带延迟消息功能
           .RabbitMQ本身是不支持延迟队列的, 结合死信队列的特性，就可以做到延迟消息

四、代码环节

 4.1 Rabbitmq死信队列配置         

package net.wnn.config;

import lombok.Data;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

/**
 *  * 自定义消息队列配置，
 *  * 发送 关单消息-》延迟exchange-》order.close.delay.queue-》死信exchange-》order.close.queue
 **/

@Configuration
@Data
public class RabbitMQConfig {
    /**
     * 交换机
     */
    private String orderEventExchange="order.event.exchange";
    /**
     * 延迟队列，不能被消费者监听
     */
    private String orderCloseDelayQueue = "order.close.delay.queue";
    /**
     * 关单队列，延迟队列的消息过期后转发的队列，用于被消费者监听
     */
    private String orderCloseQueue = "order.close.queue";
    /**
     * 进入到延迟队列的routingKey
     */
    private String orderCloseDelayRoutingKey = "order.close.delay.routing.key";
    /**
     * 进入死信队列的routingKey，消息过期进入死信队列的key
     */
    private String orderCloseRoutingKey = "order.close.routing.key";
    /**
     * 过期时间，毫秒单位，临时改为1分钟过期
     */
    private Integer ttl = 1000 * 60;
    /**
     * 消息转换器
     * @return
     */
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }
    /**
     * 创建交换机，topic类型，一般一个业务一个交换机
     * @return
     */
    @Bean
    public Exchange orderEventExchange(){
        return new TopicExchange(orderEventExchange,true,false);
    }
    /**
     * 延迟队列getOrderEventExchange
     * @return
     */
    @Bean
    public Queue orderCloseDelayQueue(){
        Map<String,Object> args = new HashMap<>(3);
        args.put("x-dead-letter-exchange",orderEventExchange);
        args.put("x-dead-letter-routing-key",orderCloseRoutingKey);
        args.put("x-message-ttl",ttl);
        return new Queue(orderCloseDelayQueue,true,false,false,args);

    }
    /**
     * 死信队列，是一个普通队列，用于被监听
     * @return
     */
    @Bean
    public Queue orderCloseQueue(){
        return new Queue(orderCloseQueue,true,false,false);
    }
    /**
     * 第一个队列 即延迟队列和交换机建立绑定关系
     * @return
     */
    @Bean
    public Binding orderCloseDelayBinding(){
        return new Binding(orderCloseDelayQueue,
                Binding.DestinationType.QUEUE,orderEventExchange,orderCloseDelayRoutingKey,null);
    }
    /**
     * 死信队列和死信交换机建立绑定关系
     * @return
     */
    @Bean
    public Binding orderCloseBinding(){

        return new Binding(orderCloseQueue,
                Binding.DestinationType.QUEUE,orderEventExchange,orderCloseRoutingKey,null);
    }


}

##----------rabbit配置--------------
spring.rabbitmq.host=120.79.xxx.xxx
spring.rabbitmq.port=5672
#需要手工创建虚拟主机
spring.rabbitmq.virtual-host=dev
spring.rabbitmq.username=admin
spring.rabbitmq.password=password
#消息确认方式，manual(手动ack) 和auto(自动ack); 消息消费重试到达指定次数进到异常交换机和异常队列，需要改为自动ack确认消息
spring.rabbitmq.listener.simple.acknowledge-mode=auto

4.2延迟消息的发送

    @Autowired
    private RabbitMQConfig rabbitMQConfig;
    @Autowired
    private RabbitTemplate rabbitTemplate;
 
//发送延迟消息
            EventMessage eventMessage = EventMessage.builder()
                .eventMessageType(EventMessageType.PRODUCT_ORDER_NEW.name())
                .accountNo(loginUser.getAccountNo())
                .bizId(orderOutTradeNo)
                .build();

        rabbitTemplate.convertAndSend(rabbitMQConfig.getOrderEventExchange(),rabbitMQConfig.getOrderCloseDelayRoutingKey(),eventMessage);

4.3关单消费者处理

package net.wnn.listener;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import net.wnn.enums.BizCodeEnum;
import net.wnn.exception.BizException;
import net.wnn.model.EventMessage;
import net.wnn.service.ProductOrderService;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
@Slf4j
@RabbitListener(queuesToDeclare = {@Queue("order.close.queue")})
public class ProductOrderMQListener {

    @Autowired
    private ProductOrderService productOrderService;

    @RabbitHandler
    public void productOrderHandler(EventMessage eventMessage, Message message, Channel channel){
        log.info("监听到消息ProductOrderMQListener messsage消息内容:{}",message);
        try{
            //关闭订单 业务逻辑
            productOrderService.closeProductOrder(eventMessage);
        }catch (Exception e){
            log.error("消费者失败:{}",eventMessage);
            throw new BizException(BizCodeEnum.MQ_CONSUME_EXCEPTION);
        }
        log.info("消费成功:{}",eventMessage);
    }
}

监听到延迟的关单消息后，根据实际业务进行查询订单、支付等确定是否要进行关单操作