RabbitMQ场景应用-死信队列模拟未支付订单自动取消

最新推荐文章于 2024-04-02 15:59:15 发布

熊猫-IT

最新推荐文章于 2024-04-02 15:59:15 发布

阅读量1.1k

点赞数 3

分类专栏：消息中间件专题

本文链接：https://blog.csdn.net/bruceliu_code/article/details/102888568

版权

消息中间件专题专栏收录该内容

17 篇文章 2 订阅

订阅专栏

1.简介

场景介绍：

我们都经常在淘宝上买东西，当我们提交订单后，如果某个时间段之内我们没有支付，淘宝肯定不会帮我们一直保留那个订单，如果超过半个小时我们未支付的话，淘宝会自动帮我们取消订单。在没有用RabbitMQ消息队列之前，我们可以通过设置一个定时任务，设定一个定时规则去轮询数据库查询超过半个小时而且未支付的订单，然后修改订单状态为已取消，这也是一个解决方案，但是需要轮询数据库，增加了对数据库的压力。

在学习了死信队列之后，其实这种场景可以使用死信队列来做，就是用户提交订单之后，发送一条消息并且设置消息过期时间为半个小时(或其他时间)，如果超过设置的这个时间，那么消息自动变成死信，就会被转发到死信队列中，这时候我们可以监听死信队列中的消息，然后查询一下订单的状态，如果还是未支付的话，那么更新订单的状态为已取消。

2.示例

本文采用springboot + mybatis实现。

2.1.pom.xml依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>


    <groupId>com.brruceliu.message.order</groupId>
    <artifactId>message-order-consumer</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

2.2.application.yml配置文件

server:
  port: 9099
spring:
  application:
    name: rabbitmq_deadqueue_demo
  rabbitmq:
    host: localhost
    virtual-host: /
    username: guest
    password: guest
    publisher-confirms: true
    port: 5672
  datasource:
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/rabbitmq_dead_queue?characterEncoding=utf8

mybatis:
  mapper-locations: classpath:mapping/*Mapper.xml
  type-aliases-package: com.bruceliu.bean
logging:
  level:
    com:
      example:
        mapper : info

2.3.数据库表创建脚本

DROP TABLE IF EXISTS `order_info`;
CREATE TABLE `order_info` (
  `pkid` varchar(50) NOT NULL COMMENT '主键ID',
  `order_id` varchar(50) DEFAULT NULL COMMENT '订单ID',
  `order_status` varchar(10) DEFAULT NULL COMMENT '订单状态 0：未支付  1：已支付 2 已取消',
  PRIMARY KEY (`pkid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2.4.实体类

package com.bruceliu.bean;

/**
 * @author bruceliu
 * @create 2019-11-03 18:48
 * @description
 */
import java.io.Serializable;

public class OrderInfo implements Serializable {

    private String pkid;
    private String orderId;
    private String orderStatus;

    public String getPkid() {
        return pkid;
    }

    public void setPkid(String pkid) {
        this.pkid = pkid;
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getOrderStatus() {
        return orderStatus;
    }

    public void setOrderStatus(String orderStatus) {
        this.orderStatus = orderStatus;
    }
}

2.5.Mybatis Mapper接口

package com.bruceliu.mapper;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

/**
 * @author bruceliu
 * @create 2019-11-03 18:49
 * @description
 */
@Mapper
public interface OrderInfoMapper {

    String findByOrderStatus(@Param("orderId") String orderId);

    void updateOrderStatus(@Param("orderId") String orderId);

    void saveOrderInfo(@Param("pkid") String pkid, @Param("orderId") String orderId, @Param("orderStatus") String orderStatus);
}

2.6.Mapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bruceliu.mapper.OrderInfoMapper">

    <select id="findByOrderStatus" resultType="String">
      select order_status from order_info where order_id = #{orderId}
    </select>

    <update id="updateOrderStatus">
          update order_info t set t.order_status = '2' where t.order_id = #{orderId}
    </update>

    <insert id="saveOrderInfo">
        insert into order_info(pkid,order_id,order_status) values(#{pkid},#{orderId},#{orderStatus})
    </insert>

</mapper>

2.7.启动类加上扫描mapper路径

package com.bruceliu;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author bruceliu
 * @create 2019-11-03 18:47
 * @description
 */
@SpringBootApplication
//扫描的mapper文件路径
@MapperScan("com.bruceliu.mapper")
public class ProducerAPP {
    public static void main(String[] args) {
        SpringApplication.run(ProducerAPP.class,args);
    }
}

2.8.RabbitMQ配置类

package com.bruceliu.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

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


/**
 * @author bruceliu
 * @create 2019-11-03 21:22
 * @description
 */
@Component
public class RabbitMQConfig {
    private static final String DEAD_LETTERS_QUEUE_NAME = "dead_letters_queue_name_order";

    private static final String DEAD_LETTERS_EXCHANGE_NAME = "dead_letters_exchange_name_order";

    private static final String QUEUE_NAME = "test_dlx_queue_name_order";

    private static final String EXCHANGE_NAME = "test_dlx_exchange_name_order";

    private static final String ROUTING_KEY = "order.add";

    /**
     * 声明死信队列、死信交换机、绑定队列到死信交换机
     * 建议使用FanoutExchange广播式交换机
     */
    @Bean
    public Queue deadLettersQueue() {
        return new Queue(DEAD_LETTERS_QUEUE_NAME);
    }

    @Bean
    public FanoutExchange deadLettersExchange() {
        return new FanoutExchange(DEAD_LETTERS_EXCHANGE_NAME);
    }

    @Bean
    public Binding deadLettersBinding() {
        return BindingBuilder.bind(deadLettersQueue()).to(deadLettersExchange());
    }

    /**
     * 声明普通队列，并指定相应的备份交换机、死信交换机
     */
    @Bean
    public Queue queue() {
        Map<String, Object> arguments = new HashMap<>(10);
        //指定死信发送的Exchange
        arguments.put("x-dead-letter-exchange", DEAD_LETTERS_EXCHANGE_NAME);
        return new Queue(QUEUE_NAME, true, false, false, arguments);
    }

    @Bean
    public Exchange exchange() {
        return new DirectExchange(EXCHANGE_NAME, true, false, null);
    }

    @Bean
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(exchange()).with(ROUTING_KEY).noargs();
    }

}

2.9.生产者

package com.bruceliu.producer;

import com.bruceliu.mapper.OrderInfoMapper;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.UUID;

/**
 * @author bruceliu
 * @create 2019-11-03 21:23
 * @description
 */
@Component
public class Producer {
    private static final String EXCHANGE_NAME = "test_dlx_exchange_name_order";

    private static final String ROUTING_KEY = "order.add";

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Resource
    private OrderInfoMapper orderInfoMapper;

    /**
     * 发送消息
     */
    public void send() {
        MessagePostProcessor messagePostProcessor = message -> {
            MessageProperties messageProperties = message.getMessageProperties();
            // 设置编码
            messageProperties.setContentEncoding("utf-8");
            // 设置过期时间(60秒过期)
            int expiration = 1000 * 60;
            messageProperties.setExpiration(String.valueOf(expiration));
            return message;
        };

        //模拟创建五条订单消息
        for (int i = 0; i < 5; i++) {
            String orderId = String.valueOf(i);
            //订单初始化状态都为未支付
            orderInfoMapper.saveOrderInfo(UUID.randomUUID().toString(), String.valueOf(i), "0");
            rabbitTemplate.convertAndSend(EXCHANGE_NAME, ROUTING_KEY, orderId, messagePostProcessor, new CorrelationData(UUID.randomUUID().toString()));
        }
    }

}

2.10.消费者

package com.bruceliu.consumer;

import com.bruceliu.mapper.OrderInfoMapper;
import com.rabbitmq.client.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * @author bruceliu
 * @create 2019-11-03 21:28
 * @description
 */
@Component
public class Consumer {

    private static final Logger logger = LoggerFactory.getLogger(Consumer.class);

    @Resource
    private OrderInfoMapper orderInfoMapper;

    @RabbitListener(queues = "dead_letters_queue_name_order")
    public void handler(Message message, Channel channel) throws IOException {
        /**
         * 发送消息之前，根据订单ID去查询订单的状态，如果已支付不处理，如果未支付，则更新订单状态为取消状态。
         */

        // 从队列中取出订单号
        byte[] body = message.getBody();
        String orderId = new String(body, StandardCharsets.UTF_8);
        logger.info("消费者接收到订单：" + orderId);
        String orderStatus = orderInfoMapper.findByOrderStatus(orderId);

        logger.info("订单状态： " + orderStatus);
        if (!"1".equals(orderStatus)) {
            //取消订单
            orderInfoMapper.updateOrderStatus(orderId);
        }
        if(channel.isOpen()){
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        }
    }

}

2.11.测试用例

package com.bruceliu.test;

import com.bruceliu.ProducerAPP;
import com.bruceliu.producer.Producer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @author bruceliu
 * @create 2019-11-03 21:24
 * @description
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ProducerAPP.class)
public class SpringbootRabbitmqDeadqueueDemoApplicationTests {

    @Autowired
    private Producer producer;

    @Test
    public void contextLoads() {
        producer.send();
    }

}

2.12.运行结果

这里设置订单一分钟未支付就算过期，然后监听死信队列，只要有消息，去数据库查询订单状态，如果仍然未支付，那么更新订单状态为已取消，并且发送ack确认应答给mq。

假设创建完成五个订单之后，在一分钟之内，手动修改数据库中两个订单的订单状态为已支付(这里只是为了测试，实际肯定是调用支付接口进行支付的),观察另外三个订单的状态是否在一分钟之后都被更新为已取消了。
在这里插入图片描述
手动修改1号和3号订单的状态为已支付，假设他们在一分钟之内已经付过款了。

一分钟之后，观察控制台输出：

2019-11-03 22:48:06.270  INFO 14692 --- [ntContainer#0-1] com.bruceliu.consumer.Consumer           : 消费者接收到订单：0
2019-11-03 22:48:06.279  INFO 14692 --- [ntContainer#0-1] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
2019-11-03 22:48:06.382  INFO 14692 --- [ntContainer#0-1] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
2019-11-03 22:48:06.398  INFO 14692 --- [ntContainer#0-1] com.bruceliu.consumer.Consumer           : 订单状态： 0
2019-11-03 22:48:06.402  INFO 14692 --- [ntContainer#0-1] com.bruceliu.consumer.Consumer           : 消费者接收到订单：1
2019-11-03 22:48:06.403  INFO 14692 --- [ntContainer#0-1] com.bruceliu.consumer.Consumer           : 订单状态： 1
2019-11-03 22:48:06.404 ERROR 14692 --- [ 127.0.0.1:5672] o.s.a.r.c.CachingConnectionFactory       : Channel shutdown: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - unknown delivery tag 1, class-id=60, method-id=80)
2019-11-03 22:48:06.409  INFO 14692 --- [ntContainer#0-1] o.s.a.r.l.SimpleMessageListenerContainer : Restarting Consumer@61dde151: tags=[[amq.ctag-lyU3IVg7k97ShV5gVFggww]], channel=Cached Rabbit Channel: PublisherCallbackChannelImpl: AMQChannel(amqp://guest@127.0.0.1:5672/,1), conn: Proxy@440eaa07 Shared Rabbit Connection: SimpleConnection@eb507b9 [delegate=amqp://guest@127.0.0.1:5672/, localPort= 59955], acknowledgeMode=AUTO local queue size=3
2019-11-03 22:48:06.414  INFO 14692 --- [ntContainer#0-2] com.bruceliu.consumer.Consumer           : 消费者接收到订单：1
2019-11-03 22:48:06.416  INFO 14692 --- [ntContainer#0-2] com.bruceliu.consumer.Consumer           : 订单状态： 1
2019-11-03 22:48:06.416  INFO 14692 --- [ntContainer#0-2] com.bruceliu.consumer.Consumer           : 消费者接收到订单：2
2019-11-03 22:48:06.417 ERROR 14692 --- [ 127.0.0.1:5672] o.s.a.r.c.CachingConnectionFactory       : Channel shutdown: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - unknown delivery tag 1, class-id=60, method-id=80)
2019-11-03 22:48:06.417  INFO 14692 --- [ntContainer#0-2] com.bruceliu.consumer.Consumer           : 订单状态： 0
2019-11-03 22:48:06.424  INFO 14692 --- [ntContainer#0-2] o.s.a.r.l.SimpleMessageListenerContainer : Restarting Consumer@55844235: tags=[[amq.ctag-CQ8T7ADXtDujfH9dli3dTg]], channel=Cached Rabbit Channel: PublisherCallbackChannelImpl: AMQChannel(amqp://guest@127.0.0.1:5672/,2), conn: Proxy@440eaa07 Shared Rabbit Connection: SimpleConnection@eb507b9 [delegate=amqp://guest@127.0.0.1:5672/, localPort= 59955], acknowledgeMode=AUTO local queue size=2
2019-11-03 22:48:06.428  INFO 14692 --- [ntContainer#0-3] com.bruceliu.consumer.Consumer           : 消费者接收到订单：2
2019-11-03 22:48:06.429  INFO 14692 --- [ntContainer#0-3] com.bruceliu.consumer.Consumer           : 订单状态： 2
2019-11-03 22:48:06.433  INFO 14692 --- [ntContainer#0-3] com.bruceliu.consumer.Consumer           : 消费者接收到订单：3
2019-11-03 22:48:06.434 ERROR 14692 --- [ 127.0.0.1:5672] o.s.a.r.c.CachingConnectionFactory       : Channel shutdown: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - unknown delivery tag 1, class-id=60, method-id=80)
2019-11-03 22:48:06.434  INFO 14692 --- [ntContainer#0-3] com.bruceliu.consumer.Consumer           : 订单状态： 0
2019-11-03 22:48:06.441  INFO 14692 --- [ntContainer#0-3] o.s.a.r.l.SimpleMessageListenerContainer : Restarting Consumer@2c296ced: tags=[[amq.ctag-vat1vtj-QiqWMwKyssfq0w]], channel=Cached Rabbit Channel: PublisherCallbackChannelImpl: AMQChannel(amqp://guest@127.0.0.1:5672/,2), conn: Proxy@440eaa07 Shared Rabbit Connection: SimpleConnection@eb507b9 [delegate=amqp://guest@127.0.0.1:5672/, localPort= 59955], acknowledgeMode=AUTO local queue size=1
2019-11-03 22:48:06.445  INFO 14692 --- [ntContainer#0-4] com.bruceliu.consumer.Consumer           : 消费者接收到订单：3
2019-11-03 22:48:06.445  INFO 14692 --- [ntContainer#0-4] com.bruceliu.consumer.Consumer           : 订单状态： 2
2019-11-03 22:48:06.449  INFO 14692 --- [ntContainer#0-4] com.bruceliu.consumer.Consumer           : 消费者接收到订单：4
2019-11-03 22:48:06.450  INFO 14692 --- [ntContainer#0-4] com.bruceliu.consumer.Consumer           : 订单状态： 0
2019-11-03 22:48:06.450 ERROR 14692 --- [ 127.0.0.1:5672] o.s.a.r.c.CachingConnectionFactory       : Channel shutdown: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - unknown delivery tag 1, class-id=60, method-id=80)
2019-11-03 22:48:06.462  INFO 14692 --- [ntContainer#0-4] o.s.a.r.l.SimpleMessageListenerContainer : Restarting Consumer@5bb3623f: tags=[[amq.ctag-ORbryKPcQhanIdekd3ULYQ]], channel=Cached Rabbit Channel: PublisherCallbackChannelImpl: AMQChannel(amqp://guest@127.0.0.1:5672/,2), conn: Proxy@440eaa07 Shared Rabbit Connection: SimpleConnection@eb507b9 [delegate=amqp://guest@127.0.0.1:5672/, localPort= 59955], acknowledgeMode=AUTO local queue size=0
2019-11-03 22:48:06.466  INFO 14692 --- [ntContainer#0-5] com.bruceliu.consumer.Consumer           : 消费者接收到订单：4
2019-11-03 22:48:06.467  INFO 14692 --- [ntContainer#0-5] com.bruceliu.consumer.Consumer           : 订单状态： 2
2019-11-03 22:48:06.471 ERROR 14692 --- [ 127.0.0.1:5672] o.s.a.r.c.CachingConnectionFactory       : Channel shutdown: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - unknown delivery tag 1, class-id=60, method-id=80)
2019-11-03 22:48:07.472  INFO 14692 --- [ntContainer#0-5] o.s.a.r.l.SimpleMessageListenerContainer : Restarting Consumer@4e0bdb8e: tags=[[amq.ctag-X3IAlTwnSI0KzEvm62m2Ng]], channel=Cached Rabbit Channel: PublisherCallbackChannelImpl: AMQChannel(amqp://guest@127.0.0.1:5672/,2), conn: Proxy@440eaa07 Shared Rabbit Connection: SimpleConnection@eb507b9 [delegate=amqp://guest@127.0.0.1:5672/, localPort= 59955], acknowledgeMode=AUTO local queue size=0

可见，消费者成功接收到五条消息，并且再次查询数据库之后，发现0号，2号，4号订单状态都被取消了，而1号、3号因为已经支付过，所以状态为已支付的。
在这里插入图片描述

4.总结

思路总结：

声明队列的时候指定参数 “ x-dead-letter-exchange ” 对应 死信路由器（dlx_exchange）；
发送消息的时候指定消息的过期时间为30分钟(或者其他时间)，这样消息超过30分钟未消费就变为死信消息；
生产者发送消息到交换机 ，等待30分钟后，会去绑定的死信路由（dlx_exchange），然后被转发到死信队列；
然后我们通过监听死信队列的消息，查询该订单是否支付，如果没有支付，则取消该订单；