• 订单超时未支付自动取消8种实现方案

    定时轮询

    数据库定时轮询方式，实现思路比较简单。启动一个定时任务，每隔一定时间扫描订单表，查询到超时订单就取消。

    优点：实现简单。
    缺点：轮询时间间隔不好确定，占用服务器资源，影响数据库性能。

    惰性取消

    当查询订单信息时，先判断该订单是否超时，如果超时就先取消。

    优点：实现简单。
    缺点：影响查询之外的业务（如：统计、库存），影响查询效率。

    JDK延迟队列

    JDK延时队列DelayQueue是一个无界阻塞队列，该队列只有在延迟期满的时候才能从中获取元素。

    简单实现代码demo如下，实际生产过程中会有专门的线程负责消息的入队与消费。

    1. import java.util.concurrent.Delayed;
    2. import java.util.concurrent.TimeUnit;
    3.  
    4. /**
    5.  * @author 向振华
    6.  * @date 2022/08/16 15:55
    7.  */
    8. public class OrderDelayed implements Delayed {
    9.  
    10.     /**
    11.      * 延迟时间
    12.      */
    13.     private final Long time;
    14.     /**
    15.      * 订单编号
    16.      */
    17.     public String orderNo;
    18.  
    19.     public OrderDelayed(String orderNo, long time, TimeUnit unit) {
    20.         this.orderNo = orderNo;
    21.         this.time = System.currentTimeMillis() + (time > 0 ? unit.toMillis(time) : 0);
    22.     }
    23.  
    24.     @Override
    25.     public long getDelay(TimeUnit unit) {
    26.         return time - System.currentTimeMillis();
    27.     }
    28.  
    29.     @Override
    30.     public int compareTo(Delayed o) {
    31.         OrderDelayed orderDelayed = (OrderDelayed) o;
    32.         long diff = this.time - orderDelayed.time;
    33.         if (diff <= 0) {
    34.             return -1;
    35.         } else {
    36.             return 1;
    37.         }
    38.     }
    39. }
    1. import java.util.concurrent.DelayQueue;
    2. import java.util.concurrent.TimeUnit;
    3.  
    4. /**
    5.  * @author 向振华
    6.  * @date 2022/08/16 16:02
    7.  */
    8. public class Test {
    9.  
    10.     public static void main(String[] args) {
    11.  
    12.         DelayQueue delayQueue = new DelayQueue<>();
    13.  
    14.         delayQueue.put(new OrderDelayed("220101001", 8, TimeUnit.SECONDS));
    15.         delayQueue.put(new OrderDelayed("220101002", 4, TimeUnit.SECONDS));
    16.  
    17.         System.out.println("订单延迟队列开始执行");
    18.  
    19.         while (true) {
    20.             // 取队列头部元素是否过期
    21.             OrderDelayed task = delayQueue.poll();
    22.             if (task != null) {
    23.                 // 取消订单业务逻辑
    24.                 System.out.println("订单 ---> " + task.orderNo + " 已过期准备取消");
    25.             }
    26.         }
    27.     }
    28. }

     

    优点：效率高，任务触发时间延迟低。
    缺点：异常恢复困难，集群扩展麻烦，内存占用。

    时间轮

    时间轮算法类似于时钟，会按某一个方向按固定频率轮动。可以用Netty的HashedWheelTimer来实现时间轮方法。

    1. <dependency>
    2.     <groupId>io.nettygroupId>
    3.     <artifactId>netty-allartifactId>
    4.     <version>4.1.78.Finalversion>
    5. dependency>
    1. import io.netty.util.HashedWheelTimer;
    2. import io.netty.util.Timeout;
    3. import io.netty.util.Timer;
    4. import io.netty.util.TimerTask;
    5.  
    6. import java.util.concurrent.TimeUnit;
    7.  
    8. /**
    9.  * @author 向振华
    10.  * @date 2022/08/16 16:02
    11.  */
    12. public class Test {
    13.  
    14.     public static void main(String[] args) {
    15.  
    16.         // 初始化时间轮
    17.         Timer timer = new HashedWheelTimer();
    18.  
    19.         // 定时任务
    20.         TimerTask task1 = new TimerTask() {
    21.             public void run(Timeout timeout) throws Exception {
    22.                 // 取消订单业务逻辑
    23.                 System.out.println("订单1已过期准备取消");
    24.             }
    25.         };
    26.         // 注册此定时任务（延迟时间为5秒，也就是说5秒后订单过期）
    27.         timer.newTimeout(task1, 5, TimeUnit.SECONDS);
    28.  
    29.         // 定时任务
    30.         TimerTask task2 = new TimerTask() {
    31.             public void run(Timeout timeout) throws Exception {
    32.                 // 取消订单业务逻辑
    33.                 System.out.println("订单2已过期准备取消");
    34.             }
    35.         };
    36.         // 注册此定时任务（延迟时间为3秒，也就是说3秒后订单过期）
    37.         timer.newTimeout(task2, 3, TimeUnit.SECONDS);
    38.     }
    39. }

    优点：效率高，任务触发时间延迟更低。
    缺点：异常恢复困难，集群扩展麻烦，内存占用。

    Redis过期回调

    Redis的key过期回调事件，也能达到延迟队列的效果。

    在redis.conf加入一条配置：

    notify-keyspace-events Ex

    监听配置

    1. @Configuration
    2. public class RedisListenerConfig {
    3.  
    4.     @Bean
    5.     RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) {
    6.         RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    7.         container.setConnectionFactory(connectionFactory);
    8.         return container;
    9.     }
    10. }

    Redis过期回调监听方法

    1. @Component
    2. public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {
    3.  
    4.     public RedisKeyExpirationListener(RedisMessageListenerContainer listenerContainer) {
    5.         super(listenerContainer);
    6.     }
    7.  
    8.     @Override
    9.     public void onMessage(Message message, byte[] pattern) {
    10.         // 过期key，可以设置成订单号
    11.         String expiredKey = message.toString();
    12.         // 取消订单业务逻辑
    13.         System.out.println("订单 ---> " + expiredKey + " 已过期准备取消");
    14.     }
    15. }

    优点：数据不易丢失，集群扩展方便。
    缺点：需要额外维护redis。

    Redis有序集合

    Redis的数据结构Zset，同样可以实现延迟队列的效果，主要利用它的score属性，redis通过score来为集合中的成员进行从小到大的排序。通过zadd命令向队列delayqueue 中添加元素，并设置score值表示元素过期的时间。

    消费端轮询队列delayqueue， 将元素排序后取最小时间与当前时间比对，如小于当前时间代表已经过期移除key。

    1. public void pollOrderQueue() {
    2.  
    3.     while (true) {
    4.         Set set = jedis.zrangeWithScores(delayqueue, 0, 0);
    5.  
    6.         String value = ((Tuple) set.toArray()[0]).getElement();
    7.         int score = (int) ((Tuple) set.toArray()[0]).getScore();
    8.  
    9.         int nowSecond = System.currentTimeMillis() / 1000);
    10.         if (nowSecond >= score) {
    11.             jedis.zrem(delayqueue, value);
    12.             System.out.println(sdf.format(new Date()) + " removed key:" + value);
    13.         }
    14.  
    15.         if (jedis.zcard(delayqueue) <= 0) {
    16.             System.out.println(sdf.format(new Date()) + " zset empty ");
    17.             return;
    18.         }
    19.         Thread.sleep(1000);
    20.     }
    21. }

    优点：数据不易丢失，集群扩展方便。
    缺点：可能重复消费同一key。

    任务调度

    使用任务调度中间件xxl-job、ScheduleX、Elastic-Job等来实现，设置一个调度时间cron，到达订单过期的调度时间时，触发任务执行取消订单业务逻辑。

    例如使用xxl-job实现，订单创建时提交一个过期任务到xxl-job服务器，下面时执行器方法：

    1. import com.xxl.job.core.handler.annotation.XxlJob;
    2. import org.springframework.stereotype.Component;
    3.  
    4. /**
    5.  * @author 向振华
    6.  * @date 2022/08/16 15:55
    7.  */
    8. @Component
    9. public class JobHandler {
    10.  
    11.     @XxlJob("payExpireJobHandler")
    12.     public void payExpireJobHandler(String executorParam) {
    13.         // 取消订单业务逻辑
    14.         System.out.println("订单 ---> " + executorParam + " 已过期准备取消");
    15.     }
    16. }

    优点：时效性强，支持分布式。
    缺点：实现复杂，维护成本高。

    消息队列

    使用RocketMQ、RabbitMQ、Kafka的延时消息，消息在发送到消息队列服务端后并不会立马投递，而是根据消息中的属性延迟固定时间后才投递给消费者。

    RocketMQ发送延时消息的示例代码如下：

    1. import com.aliyun.openservices.ons.api.Message;
    2. import com.aliyun.openservices.ons.api.ONSFactory;
    3. import com.aliyun.openservices.ons.api.Producer;
    4. import com.aliyun.openservices.ons.api.PropertyKeyConst;
    5. import com.aliyun.openservices.ons.api.SendResult;
    6. import java.util.Properties;
    7.  
    8. public class Test {
    9.     public static void main(String[] args) {
    10.         Properties properties = new Properties();
    11.         // AccessKey ID阿里云身份验证，在阿里云RAM控制台创建。
    12.         properties.put(PropertyKeyConst.AccessKey, "XXX");
    13.         // AccessKey Secret阿里云身份验证，在阿里云RAM控制台创建。
    14.         properties.put(PropertyKeyConst.SecretKey, "XXX");
    15.         // 设置TCP接入域名，进入消息队列RocketMQ版控制台实例详情页面的接入点区域查看。
    16.         properties.put(PropertyKeyConst.NAMESRV_ADDR,
    17.           "XXX");
    18.  
    19.         Producer producer = ONSFactory.createProducer(properties);
    20.         // 在发送消息前，必须调用start方法来启动Producer，只需调用一次即可。
    21.         producer.start();
    22.         Message msg = new Message( 
    23.                 // 您在消息队列RocketMQ版控制台创建的Topic。
    24.                 "Topic",
    25.                 // Message Tag,可理解为Gmail中的标签，对消息进行再归类，方便Consumer指定过滤条件在消息队列RocketMQ版服务器过滤。
    26.                 "tag",
    27.                 // Message Body可以是任何二进制形式的数据，消息队列RocketMQ版不做任何干预，需要Producer与Consumer协商好一致的序列化和反序列化方式。
    28.                 "Hello MQ".getBytes());
    29.         // 设置代表消息的业务关键属性，请尽可能全局唯一。
    30.         // 以方便您在无法正常收到消息情况下，可通过控制台查询消息并补发。
    31.         // 注意：不设置也不会影响消息正常收发。
    32.         msg.setKey("ORDERID_100");
    33.         try {
    34.             // 延时消息，在指定延迟时间（当前时间之后）进行投递。最大可设置延迟40天投递，单位毫秒（ms）。
    35.             // 以下示例表示消息在3秒后投递。
    36.             long delayTime = System.currentTimeMillis() + 3000;
    37.  
    38.             // 设置消息需要被投递的时间。
    39.             msg.setStartDeliverTime(delayTime);
    40.  
    41.             SendResult sendResult = producer.send(msg);
    42.             // 同步发送消息，只要不抛异常就是成功。
    43.             if (sendResult != null) {
    44.             System.out.println(new Date() + " Send mq message success. Topic is:" + msg.getTopic() + " msgId is: " + sendResult.getMessageId());
    45.             }
    46.             } catch (Exception e) {
    47.             // 消息发送失败，需要进行重试处理，可重新发送这条消息或持久化这条数据进行补偿处理。
    48.             System.out.println(new Date() + " Send mq message failed. Topic is:" + msg.getTopic());
    49.             e.printStackTrace();
    50.         }
    51.         // 在应用退出前，销毁Producer对象。
    52.         // 注意：如果不销毁也没有问题。
    53.         producer.shutdown();
    54.     }
    55. }

    RocketMQ延时消息的订阅与普通消息订阅一致。

    优点：高效，好扩展，支持分布式。
    缺点：实现复杂，维护成本高。

  • 相关阅读:
    HTML 图像
    深度前端性能调优的实际案例-小白都看的懂
    226. 翻转二叉树
    从零开始的深度学习之旅(3)
    RabbitMQ 基础操作
    超声功率放大器使用范围有哪些
    dtcloud 的消息机制（二）
    为华生物Dextran-SH 葡聚糖巯基 巯基化葡聚糖的简介及应用说明
    数码管显示驱动芯片 CH450
    基于单片机的指纹门禁设计
  • 原文地址：https://blog.csdn.net/Anenan/article/details/126368753