订单超时自动取消的技术方案解析及代码实现

前言

订单超时自动取消是电商平台中常见的功能之一,例如在淘宝、京东、拼多多等商城下单后,如果在一定的时间内没有付款,那么订单会自动被取消,是怎么做到的呢?作为技术人员我们应该了解自动取消的原理和实现逻辑,本文将介绍几种常用的技术方案,帮助开发者实现订单超时自动取消的功能。


通过以上图我们可以看到其实超时自动取消的方案有很多,虽然方案多(大多数都是结合延迟队列来实现的),但每个方案都有自己的优缺点,具体场景需要选用合适的方案。
本文我们主要讲解以下几种常用取消方案,其他方案可自行搜索研究。

  • 方案1:定时轮询(quartz实现)
  • 方案2:JDK延迟队列DelayQueue
  • 方案3:时间轮算法(netty的HashedWheelTimer)
  • 方案4:Redis
  • 方案5:RabbitMQ消息队列

方案 1:定时轮询(quartz实现)

方案描述

通过定时任务的方式去轮询扫描数据库表,根据订单有效期来判断订单是否到期,到期则更新订单状态。
这里我们使用quartz作业调度框架来实现定时轮询。

代码

需要添加maven依赖

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.1</version>
</dependency>

代码如下:

public class CancelOrderJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println(time + ":扫描订单表超时未付款订单...");
    }
}

public class QuartzJobTest {
    public static void main(String[] args) throws Exception {
        JobDetail jobDetail = JobBuilder.newJob(CancelOrderJob.class).build();
        Trigger trigger = TriggerBuilder.newTrigger()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever())
                .build();
        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        scheduler.scheduleJob(jobDetail, trigger);
        System.out.println("定时任务开启,每隔1秒执行一次");
        scheduler.start();
    }
}

运行结果:

定时任务开启,每隔1秒执行一次
2023-06-27 11:53:43:扫描订单表超时未付款订单...
2023-06-27 11:53:43:扫描订单表超时未付款订单...
2023-06-27 11:53:44:扫描订单表超时未付款订单...
2023-06-27 11:53:45:扫描订单表超时未付款订单...
2023-06-27 11:53:46:扫描订单表超时未付款订单...
2023-06-27 11:53:47:扫描订单表超时未付款订单...
...

优点

这种方案优点是实现简单,通过quartz框架进行任务调度,无其他依赖,支持集群部署。

缺点

简单粗暴的全表扫描方式对数据库性能影响特别大,可能影响其他正常的业务操作响应时效,另外配置扫描时间间隔也是个问题,配置大了,扫描延迟,影响取消订单的精准时间,在数据量较大的情况下,配置小了影响数据库性能,所以需要根据实际情况进行评估。

方案 2:JDK延迟队列DelayQueue

方案描述

JDK中的DelayQueue可以实现延迟,是一个无界阻塞队列,其实底层使用的是优先级队列PriorityQueue,可以对放入的对象进行排序,对象需要实现Delayed接口,采用阻塞的方式获取数据,也就是相当于延迟时间到了就会获取到数据。

代码

public class CancelOrder implements Delayed {

    private String orderNo;

    private long timeout;

    CancelOrder(String orderNo, long timeout) {
        this.orderNo = orderNo;
        this.timeout = timeout + System.nanoTime();
    }

    public int compareTo(Delayed other) {
        if (other == this) {
            return 0;
        }
        CancelOrder t = (CancelOrder) other;
        long d = (getDelay(TimeUnit.NANOSECONDS) - t.getDelay(TimeUnit.NANOSECONDS));
        return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(timeout - System.nanoTime(), TimeUnit.NANOSECONDS);
    }

    @Override
    public String toString() {
        return "CancelOrder{" +
                "orderNo='" + orderNo + '\'' +
                ", timeout=" + timeout +
                '}';
    }
}
public class DelayQueueTest {
    public static void main(String[] args) throws Exception {
        DelayQueue<CancelOrder> queue = new DelayQueue<>();
        for (int i = 0; i < 5; i++) {
            // 生成订单,10秒超时
            CancelOrder cancelOrder = new CancelOrder("orderNo100" + i, TimeUnit.NANOSECONDS.convert(10, TimeUnit.SECONDS));
            String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            System.out.println(time + ":生成了订单,10秒有效期,order:" + cancelOrder);
            queue.put(cancelOrder);
            // 每1秒生成一个订单
            Thread.sleep(1000);
        }
        try {
            while (!queue.isEmpty()) {
                CancelOrder order = queue.take();
                String timeout = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
                System.out.println(timeout + ":订单超时,order:" + order);
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

运行结果:

2023-06-27 18:43:25:生成了订单,10秒有效期,order:CancelOrder{orderNo='orderNo1000', timeout=1030377584852000}
2023-06-27 18:43:26:生成了订单,10秒有效期,order:CancelOrder{orderNo='orderNo1001', timeout=1030378653717600}
2023-06-27 18:43:27:生成了订单,10秒有效期,order:CancelOrder{orderNo='orderNo1002', timeout=1030379654276300}
2023-06-27 18:43:28:生成了订单,10秒有效期,order:CancelOrder{orderNo='orderNo1003', timeout=1030380655228900}
2023-06-27 18:43:29:生成了订单,10秒有效期,order:CancelOrder{orderNo='orderNo1004', timeout=1030381656177500}
2023-06-27 18:43:35:订单超时,order:CancelOrder{orderNo='orderNo1000', timeout=1030377584852000}
2023-06-27 18:43:36:订单超时,order:CancelOrder{orderNo='orderNo1001', timeout=1030378653717600}
2023-06-27 18:43:37:订单超时,order:CancelOrder{orderNo='orderNo1002', timeout=1030379654276300}
2023-06-27 18:43:38:订单超时,order:CancelOrder{orderNo='orderNo1003', timeout=1030380655228900}
2023-06-27 18:43:39:订单超时,order:CancelOrder{orderNo='orderNo1004', timeout=1030381656177500}

例子中设置的订单有效期是10秒中,每隔1秒生成一个订单,目的是为了便于观察不同的订单到期时间,可以看到10s后各订单相继超时。

优点

不需要任何第三方依赖,实现非常简单

缺点

数据全部保存在JVM内存中,占用内存,可能会引发内存溢出,另外宕机或重启数据会全部丢失,无法做集群。

方案 3:时间轮算法(netty的HashedWheelTimer)

方案描述

时间轮算法用的是一个环形的数据结构(使用数组实现),每一轮相当于沿着环形走一圈,类似于钟表,可以分成很多格子(秒针一圈分成60格,算法中叫bucket,这个bucket里可以存放任务),然后每个格子有持续的时间间隔(比如秒针一个格子是1秒,也就是走过这一格持续1秒的时间,算法中对应的是tickDuration)。
时间轮算法有多种实现,单轮算法,多轮算法(相当于在单轮上做了循环),分层时间轮算法(类似于水表,有多个表盘共同计算出总水量)
时间轮算法使用一个worker线程,将任务放到计算获得的bucket里,并按指定的时间间隔tickDuration去执行bucket的时间到期任务。
netty4版本中的时间轮结构如下:


图中HashedWheelTimer内部存储使用的是HashedWheelBucket数组,形成一个环形结构,每一个HashedWheelBucket中存储的是HashedWheelTimeout双向链表,在HashedWheelTimeout中存的是TimerTask,就是具体要执行的任务。
假设当前指针指在3上,如有有一个任务2秒后执行,那么会存在5的格子上,如果有一个任务8秒后执行,则会放到3上,转了一圈,这是任务的轮数就加了1。

代码

需要添加maven依赖

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.24.Final</version>
</dependency>

public class CancelOrderTimerTask implements TimerTask {

    private String orderNo;

    public CancelOrderTimerTask(String orderNo) {
        this.orderNo = orderNo;
    }

    @Override
    public void run(Timeout timeout) throws Exception {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println(time + ":处理订单超时,orderNo:" + orderNo);
    }
}

public class HashedWheelTimerTest {
    public static void main(String[] argv) {
        /*
        此处使用的HashedWheelTimer构造方法参数解释如下:
        threadFactory:创建线程的工厂
        tickDuration:时间间隔,这里的1,结合后面的TimeUnit.SECONDS,就是走完一格需要1秒时间。
        unit:时间单位,这是里秒
        ticksPerWheel:表示数组的大小,也就是格子的多少
         */
        HashedWheelTimer hashedWheelTimer = new HashedWheelTimer(new DefaultThreadFactory("test-thread"), 1, TimeUnit.SECONDS, 60);
        hashedWheelTimer.start();
        CancelOrderTimerTask timerTask0 = new CancelOrderTimerTask("orderNo1000");
        CancelOrderTimerTask timerTask1 = new CancelOrderTimerTask("orderNo1001");
        CancelOrderTimerTask timerTask2 = new CancelOrderTimerTask("orderNo1002");
        CancelOrderTimerTask timerTask3 = new CancelOrderTimerTask("orderNo1003");
        hashedWheelTimer.newTimeout(timerTask0, 0, TimeUnit.SECONDS);
        hashedWheelTimer.newTimeout(timerTask1, 5, TimeUnit.SECONDS);
        hashedWheelTimer.newTimeout(timerTask2, 30, TimeUnit.SECONDS);
        hashedWheelTimer.newTimeout(timerTask3, 70, TimeUnit.SECONDS);
    }
}

运行结果:

2023-06-28 11:43:42:处理订单超时,orderNo:orderNo1000
2023-06-28 11:43:47:处理订单超时,orderNo:orderNo1001
2023-06-28 11:44:12:处理订单超时,orderNo:orderNo1002
2023-06-28 11:44:52:处理订单超时,orderNo:orderNo1003

任务均是按指定时间间隔执行的。

优点

精度灵活可控制,执行效率高,延迟时间比DelayQueue队列低。

缺点

同DelayQueue一样,数据全部保存在JVM内存中,占用内存,可能会引发内存溢出,另外宕机或重启数据会全部丢失,大数据量的情况下也会影响延迟精度。

方案 4:Redis

redis有两种方案可以实现延迟,一种是采用轮询有序集合zset,一种是采用key过期监听

方案4.1:定时任务轮询有序集合zset

方案描述

zset是一个有序集合,存储的每个元素都有个score分值,可以把score当做过期时间,按照score排序(默认按照score从小到大排序,降序可使用zrerange命令),再结合使用一个线程轮询该集合即可实现延迟功能。

代码

需要添加maven依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.2.0</version>
</dependency>
public class CancelOrderRedisTest {
    private static JedisPool jedisPool = new JedisPool("127.0.0.1", 6379);

    public static void main(String[] args) throws Exception {
        // 放入几个元素到zset有序集合里
        new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
                    redisClient().zadd("cancel:order:list", System.currentTimeMillis() + (i + 1) * 1000, "orderNo100" + i);
                    System.out.println(time + ":生成订单,订单号:orderNo100" + i + ",有效期:" + (i + 1) + "秒");
                    Thread.sleep(1000);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
        // 开一个线程轮询这个有序集合
        new Thread(() -> {
            Jedis jedis = redisClient();
            while (true) {
                Set<Tuple> items = jedis.zrangeWithScores("cancel:order:list", 0, 1);
                if (items == null || items.isEmpty()) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    Tuple tuple = (Tuple) items.toArray()[0];
                    long score = (long) tuple.getScore();
                    if (System.currentTimeMillis() >= score) {
                        Long num = jedis.zrem("cancel:order:list", tuple.getElement());
                        if (num != null && num > 0) {
                            String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
                            System.out.println(time + ":订单号:" + tuple.getElement() + "已到期");
                        }
                    }
                }
            }
        }).start();

    }

    /**
     * 获取redis连接
     *
     * @return
     */
    public static Jedis redisClient() {
        return jedisPool.getResource();
    }
}

运行结果:

2023-06-28 12:41:31:生成订单,订单号:orderNo1000,有效期:1秒
2023-06-28 12:41:32:订单号:orderNo1000已到期
2023-06-28 12:41:32:生成订单,订单号:orderNo1001,有效期:2秒
2023-06-28 12:41:33:生成订单,订单号:orderNo1002,有效期:3秒
2023-06-28 12:41:34:订单号:orderNo1001已到期
2023-06-28 12:41:34:生成订单,订单号:orderNo1003,有效期:4秒
2023-06-28 12:41:35:生成订单,订单号:orderNo1004,有效期:5秒
2023-06-28 12:41:36:订单号:orderNo1002已到期
2023-06-28 12:41:38:订单号:orderNo1003已到期
2023-06-28 12:41:40:订单号:orderNo1004已到期

优点

实现简单,redis内存操作,速度快,性能高,集群扩展方便,可存储大量订单数据,持久化机制使得故障时通过AOF或RDB方式恢复,适合对延迟精度要求不高的业务场景

缺点

轮询线程如果不带休眠或休眠时间短,可能导致空轮询,CPU飙高,带休眠时间,休眠多久不好评估,休眠时间过长可能导致延迟不准确。另外处理消息异常时可能要实现重试机制,还有一个就是可靠性问题,比如是先删数据在处理订单还是先处理订单再删除数据,处理异常时可能会导致数据丢失。

方案4.2:Redis key过期监听

方案描述

过期监听机制是redis在2.8版本以上提供的功能,如果key失效后,redis会给客户端发送消息即pub/sub机制,从而实现延迟方案。
以windows系统的redis为例。
在redis安装目录的redis.windows.conf文件中找到“notify-keyspace-events”如果被注释则放开,将这行配成如下所示:

notify-keyspace-events Ex

然后再启动(或重启)redis。

注意:windows系统下,直接使用redis-server.exe,不会加载redis.windows.conf这个配置文件,需要用命令行启动。命令行进入redis安装目录,执行命令:redis-server.exe redis.windows.conf

代码

public class RedisKeyExpireTest {
    private static JedisPool jedisPool = new JedisPool("127.0.0.1", 6379);

    public static void main(String[] args) throws InterruptedException {
        // subscribe方法会阻塞等待,用异步去初始化订阅监听事件
        new Thread(() -> {
            jedisPool.getResource().subscribe(new RedisSub(), "__keyevent@0__:expired");
        }).start();
        // 添加几个带过期时间的key
        new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
                    jedisPool.getResource().setex("orderNo100" + i, i + 1, "orderNo100" + i);
                    System.out.println(time + ":生成订单,订单号:orderNo100" + i + ",有效期:" + (i + 1) + "秒");
                    Thread.sleep(1000);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }
}

class RedisSub extends JedisPubSub {
    @Override
    public void onMessage(String channel, String message) {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println(time + ":订单号:" + message + "已到期");

    }
}

运行结果:

2023-06-28 12:56:17:生成订单,订单号:orderNo1000,有效期:1秒
2023-06-28 12:56:18:生成订单,订单号:orderNo1001,有效期:2秒
2023-06-28 12:56:18:订单号:orderNo1000已到期
2023-06-28 12:56:19:生成订单,订单号:orderNo1002,有效期:3秒
2023-06-28 12:56:20:生成订单,订单号:orderNo1003,有效期:4秒
2023-06-28 12:56:20:订单号:orderNo1001已到期
2023-06-28 12:56:21:生成订单,订单号:orderNo1004,有效期:5秒
2023-06-28 12:56:22:订单号:orderNo1002已到期
2023-06-28 12:56:24:订单号:orderNo1003已到期
2023-06-28 12:56:26:订单号:orderNo1004已到期

通过redis的key过期监听实现了延迟功能,需要开启redis服务器的key过期监听配置。

优点

实现简单,redis内存操作,速度快,性能高,集群扩展方便,可存储大量订单数据,持久化机制使得故障时通过AOF或RDB方式恢复,适合对延迟精度要求不高的业务场景

缺点

redis的key过期有惰性清除和定时清除两种策略,可能会存在延迟时间不精确的问题,另外redis的pub/sub 机制是不可靠的,如果客户端故障或重启期间有key过期则过期通知事件的数据就丢失了,从而订单无法过期,可以通过补偿机制配合使用,定时任务去做轮询补偿。

方案 5:RabbitMQ消息队列

方案5.1:消息TTL+死信队列

RabbitMQ 可以针对 Queue 和 Message 设置 x-message-tt,来控制消息的生存时间,如果超时,则消息变为 dead letter
RabbitMQ 的 Queue 可以配置 x-dead-letter-exchange 和 x-dead-letter-routing-key(可选)两个参数,用来控制队列内出现了 deadletter,则按照这两个参数重新路由。结合以上两个特性,就可以模拟出延迟消息的功能。

方案5.2:RabbitMQ延迟队列插件

在这里下载RabbitMQ对应的插件:https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases,本文使用的RabbitMQ版本是3.8.17,所以找到对应的版本下载的是ez结尾的文件,直接放到RabbitMQ的插件目录plugins即可,位置:/usr/lib/rabbitmq/lib/rabbitmq_server-3.8.17/plugins,然后执行下面的命令使插件生效(若不生效,需要重启RabbitMQ)。

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

查看是否生效(rabbitmq-plugins list命令是查看所有的插件):

rabbitmq-plugins list | grep delayed

显示如下表示已启动。

代码

采用springboot集成rabbitMQ实现,代码如下:

  • 配置类
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 RabbitMQConfig {

    /**
     * 正常交换机名称
     */
    public static final String EXCHANGE_NAME_NORMAL_DIRECT = "exchange.normal.direct";

    /**
     * 消息不带ttl队列名称
     */
    public static final String QUEUE_NAME_WITHOUT_TTL = "queue.without.ttl";

    /**
     * 消息带ttl队列名称
     */
    public static final String QUEUE_NAME_WITH_TTL = "queue.with.ttl";

    /**
     * 消息不带ttl消息路由
     */
    public static final String ROUTING_KEY_WITHOUT_TTL = "routing.without.ttl.*";

    /**
     * 消息带ttl消息路由
     */
    public static final String ROUTING_KEY_WITH_TTL = "routing.with.ttl.*";

    /**
     * 死信交换机名称
     */
    public static final String EXCHANGE_NAME_DEADLETTER_DIRECT = "exchange.deadLetter.direct";

    /**
     * 死信队列名称
     */
    public static final String QUEUE_NAME_DEAD_LETTER = "queue.deadLetter";
    /**
     * 死信队列消息路由
     */
    public static final String ROUTING_KEY_DEAD_LETTER = "routing.deadletter.*";

    /**
     * rabbitMQ插件实现的延迟队列-队列名称
     */
    public static final String QUEUE_NAME_PLUGIN = "queue.plugin";
    /**
     * rabbitMQ插件实现的延迟队列-交换机名称
     */
    public static final String EXCHANGE_NAME_PLUGIN = "exchange.customexchange.plugin";
    /**
     * rabbitMQ插件实现的延迟队列-路由名称
     */
    public static final String ROUTING_KEY_PLUGIN = "routing.plugin.*";

    /**
     * 正常交换机
     *
     * @return
     */
    @Bean("normalExchange")
    public DirectExchange normalExchange() {
        return new DirectExchange(EXCHANGE_NAME_NORMAL_DIRECT);
    }

    /**
     * 死信交换机
     *
     * @return
     */
    @Bean("deadLetterExchange")
    public DirectExchange deadLetterExchange() {
        return new DirectExchange(EXCHANGE_NAME_DEADLETTER_DIRECT);
    }

    /**
     * rabbitMQ插件实现的延迟队列-自定义的交换机
     *
     * @return
     */
    @Bean
    public CustomExchange customExchange() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-delayed-type", "direct");
        return new CustomExchange(EXCHANGE_NAME_PLUGIN, "x-delayed-message", true, false, args);
    }

    /**
     * 消息不带ttl队列并设置死信交换机
     *
     * @return
     */
    @Bean("withOutttlQueue")
    public Queue withOutttlQueue() {
        Map<String, Object> args = new HashMap<>(3);
        args.put("x-dead-letter-exchange", EXCHANGE_NAME_DEADLETTER_DIRECT);
        args.put("x-dead-letter-routing-key", ROUTING_KEY_DEAD_LETTER);
        args.put("x-message-ttl", 10000);
        return QueueBuilder.durable(QUEUE_NAME_WITHOUT_TTL).withArguments(args).build();
    }

    /**
     * 消息带ttl队列并设置死信交换机
     *
     * @return
     */
    @Bean("withttlQueue")
    public Queue withttlQueue() {
        Map<String, Object> args = new HashMap<>(3);
        args.put("x-dead-letter-exchange", EXCHANGE_NAME_DEADLETTER_DIRECT);
        args.put("x-dead-letter-routing-key", ROUTING_KEY_DEAD_LETTER);
        return QueueBuilder.durable(QUEUE_NAME_WITH_TTL).withArguments(args).build();
    }

    /**
     * 死信队列
     *
     * @return
     */
    @Bean("deadLetterQueue")
    public Queue deadLetterQueue() {
        return new Queue(QUEUE_NAME_DEAD_LETTER);
    }

    /**
     * rabbitMQ插件实现的延迟队列-队列
     *
     * @return
     */
    @Bean
    public Queue pluginQueue() {
        return new Queue(QUEUE_NAME_PLUGIN);
    }

    /**
     * 消息不带ttl队列与正常交换机绑定
     *
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding withoutttlQueueBinding(@Qualifier("withOutttlQueue") Queue queue,
                                          @Qualifier("normalExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY_WITHOUT_TTL);
    }

    /**
     * 消息带ttl队列与正常交换机绑定
     *
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding withttlQueueBinding(@Qualifier("withttlQueue") Queue queue,
                                       @Qualifier("normalExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY_WITH_TTL);
    }


    /**
     * 死信队列与死信交换机绑定
     *
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding deadLetterBinding(@Qualifier("deadLetterQueue") Queue queue,
                                     @Qualifier("deadLetterExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY_DEAD_LETTER);
    }

    /**
     * rabbitMQ插件实现的延迟队列-队列绑定交换机
     *
     * @param queue
     * @param customExchange
     * @return
     */
    @Bean
    public Binding pluginBinding(@Qualifier("pluginQueue") Queue queue,
                                 @Qualifier("customExchange") CustomExchange customExchange) {
        return BindingBuilder.bind(queue).to(customExchange).with(ROUTING_KEY_PLUGIN).noargs();
    }
}
  • 消息生产者
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import static com.star95.springcloud.rabbitmq.cancelorder.RabbitMQConfig.*;

@Component
public class MessageSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 发送带自定义ttl的消息
     *
     * @param msg
     * @param ttl
     */
    public void sendMsgWithTtl(String msg, String ttl) {
        MessagePostProcessor messagePostProcessor = message -> {
            message.getMessageProperties().setExpiration(ttl);//设置消息过期时间
            return message;
        };
        rabbitTemplate.convertAndSend(EXCHANGE_NAME_NORMAL_DIRECT, ROUTING_KEY_WITH_TTL, msg, messagePostProcessor);
    }

    /**
     * 发送公共ttl的消息
     *
     * @param msg
     */
    public void sendMsgWithOutTtl(String msg) {
        rabbitTemplate.convertAndSend(EXCHANGE_NAME_NORMAL_DIRECT, ROUTING_KEY_WITHOUT_TTL, msg);
    }

    /**
     * 使用rabbitmq插件实现的延迟队列,发送带自定义ttl的消息
     * @param msg
     * @param ttl
     */
    public void sendMsgWithPlugin(String msg, Integer ttl) {
        rabbitTemplate.convertAndSend(EXCHANGE_NAME_PLUGIN, ROUTING_KEY_PLUGIN, msg, a -> {
            a.getMessageProperties().setDelay(ttl);
            return a;
        });
    }

}
  • 消息消费者
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.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import static com.star95.springcloud.rabbitmq.cancelorder.RabbitMQConfig.QUEUE_NAME_DEAD_LETTER;
import static com.star95.springcloud.rabbitmq.cancelorder.RabbitMQConfig.QUEUE_NAME_PLUGIN;

@Slf4j
@Component
public class QueueConsumer {


    /**
     * 不带ttl队列消费消息
     *
     * @param message
     * @param channel
     * @throws IOException
     */
    // @RabbitListener(queues = QUEUE_NAME_WITHOUT_TTL)
    public void withoutttlQueueReceive(Message message, Channel channel) throws IOException {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        String msg = new String(message.getBody());
        log.info("当前时间:{},公共ttl队列消费的消息内容:{}", time, msg);
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
    }

    /**
     * 带ttl队列消费消息
     *
     * @param message
     * @param channel
     * @throws IOException
     */
    // @RabbitListener(queues = QUEUE_NAME_WITH_TTL)
    public void withttlQueueReceive(Message message, Channel channel) throws IOException {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        String msg = new String(message.getBody());
        log.info("当前时间:{},自定义ttl队列消费的消息内容:{}", time, msg);
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
    }

    /**
     * 死信队列消费消息
     *
     * @param message
     * @param channel
     * @throws IOException
     */
    @RabbitListener(queues = QUEUE_NAME_DEAD_LETTER)
    public void deadQueueReceive(Message message, Channel channel) throws IOException {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        String msg = new String(message.getBody());
        log.info("当前时间:{},死信队列消费的消息内容:{}", time, msg);
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }

    /**
     * 使用rabbitmq插件实现延迟队列消费消息
     *
     * @param message
     * @param channel
     * @throws IOException
     */
    @RabbitListener(queues = QUEUE_NAME_PLUGIN)
    public void pluginQueueReceive(Message message, Channel channel) throws IOException {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        String msg = new String(message.getBody());
        log.info("当前时间:{},使用rabbitmq插件实现延迟队列,消费的消息内容:{}", time, msg);
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}
  • controller发送消息入口
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

@Slf4j
@RequestMapping("cancelorder")
@RestController
public class RabbitMQMsgController {

    @Autowired
    private MessageSender sender;

    @RequestMapping("/msgwithttl")
    public void msgWithttl(String msg, String ttl) {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        log.info("当前时间:{},创建带自定义ttl消息,msg:{},ttl:{}", time, msg, ttl);
        sender.sendMsgWithTtl(msg, ttl);
    }

    @RequestMapping("/msgwithoutttl")
    public void msgWithoutttl(String msg) {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        log.info("当前时间:{},创建公共ttl消息,msg:{}", time, msg);
        sender.sendMsgWithOutTtl(msg);
    }

    @RequestMapping("msgwithplugin")
    public void msgWithPlugin(String msg, Integer ttl) {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        log.info("当前时间:{},使用rabbitmq插件实现延迟队列,发送的消息,msg:{},ttl:{}", time, msg, ttl);
        sender.sendMsgWithPlugin(msg, ttl);
    }

}

注意:@RabbitListener(queues = QUEUE_NAME_WITHOUT_TTL),@RabbitListener(queues = QUEUE_NAME_WITH_TTL),这两个是注释掉的,如果不注释消息就被正常消费了,注释掉就可以测试消息到期会进入死信队列实现延迟队列的功能。

  • 使用公共ttl的接口发送两条消息

http://127.0.0.1:8080/cancelorder/msgwithoutttl?msg=order123
http://127.0.0.1:8080/cancelorder/msgwithoutttl?msg=order321
结果:

当前时间:2023-06-27 14:45:58,创建公共ttl消息,msg:order123
当前时间:2023-06-27 14:45:00,创建公共ttl消息,msg:order321
当前时间:2023-06-27 14:45:08,死信队列消费的消息内容:order123
当前时间:2023-06-27 14:45:10,死信队列消费的消息内容:order321

不管是两条请求谁先执行,结果均是在默认的10秒后过期,结果正常,这种适用于消息具有同一过期时间的场景。

  • 使用自定义ttl的接口发送两条消息

http://127.0.0.1:8080/cancelorder/msgwithttl?msg=order321&ttl=5000(先执行)
http://127.0.0.1:8080/cancelorder/msgwithttl?msg=order123&ttl=20000(后执行)
结果:

当前时间:2023-06-27 14:51:40,创建带自定义ttl消息,msg:order321,ttl:5000
当前时间:2023-06-27 14:51:45,死信队列消费的消息内容:order321
当前时间:2023-06-27 14:51:52,创建带自定义ttl消息,msg:order123,ttl:20000
当前时间:2023-06-27 14:52:12,死信队列消费的消息内容:order123

这里可以看到先执行延迟5秒的请求,再执行延迟20秒的请求,结果是正常按指定时间消费的消息。
如果我们按下面这个顺序执行(先执行延迟20秒的请求,再执行延迟5秒的请求)
http://127.0.0.1:8080/cancelorder/msgwithttl?msg=order123&ttl=20000(先执行)
http://127.0.0.1:8080/cancelorder/msgwithttl?msg=order321&ttl=5000(后执行)
结果:

当前时间:2023-06-27 14:53:27,创建带自定义ttl消息,msg:order123,ttl:20000
当前时间:2023-06-27 14:53:31,创建带自定义ttl消息,msg:order321,ttl:5000
当前时间:2023-06-27 14:53:47,死信队列消费的消息内容:order123
当前时间:2023-06-27 14:53:47,死信队列消费的消息内容:order321

这里两条请求执行完后,结果却是同一时间消费的消息,这是因为RabbitMQ只会检查第一个消息是否过期,如果过期则丢到死信队列,如果第一个消息的延时时长很长,而第二个消息的延时时长很短,则第二个消息并不会优先得到执行,这个问题可以通过rabbMQ的延迟插件来解决。

  • 使用rabbitMQ插件实现的延迟队列接口发送两条消息

http://127.0.0.1:8080/cancelorder/msgwithplugin?msg=order123&ttl=20000(先执行)
http://127.0.0.1:8080/cancelorder/msgwithplugin?msg=order321&ttl=5000(后执行)
结果:

当前时间:2023-06-27 15:08:04,使用rabbitmq插件实现延迟队列,发送的消息,msg:order123,ttl:20000
当前时间:2023-06-27 15:08:06,使用rabbitmq插件实现延迟队列,发送的消息,msg:order321,ttl:5000
当前时间:2023-06-27 15:08:11,使用rabbitmq插件实现延迟队列,消费的消息内容:order321
当前时间:2023-06-27 15:08:24,使用rabbitmq插件实现延迟队列,消费的消息内容:order123

这里消息过期正常被消费,解决了由于消息过期时长不一致导致的不能及时消费的问题。

优点

RabbitMQ消息服务可靠性高,消息处理速度快,支持大数据量,并且支持分布式横向扩展方便。

缺点

引入RabbitMQ中间件系统复杂度增高,运维成本增加,使用起来配置较复杂。

总结

订单超时自动取消是电商平台中非常重要的功能之一,通过合适的技术方案,可以实现自动化处理订单超时的逻辑,提升用户体验和系统效率。本文介绍了几种常用的技术方案,开发者可以根据具体的业务需求和技术栈选择合适的方案,并结合相应的文档和示例进行实现和配置。

热门相关:总裁别再玩了   裙上之臣   金粉   裙上之臣   神算大小姐