定制化开发订单超时未支付自动取消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<OrderDelayed> 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.netty</groupId>
  3.     <artifactId>netty-all</artifactId>
  4.     <version>4.1.78.Final</version>
  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<Tuple> 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延时消息的订阅与普通消息订阅一致。

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

网站建设定制开发 软件系统开发定制 定制软件开发 软件开发定制 定制app开发 app开发定制 app开发定制公司 电商商城定制开发 定制小程序开发 定制开发小程序 客户管理系统开发定制 定制网站 定制开发 crm开发定制 开发公司 小程序开发定制 定制软件 收款定制开发 企业网站定制开发 定制化开发 android系统定制开发 定制小程序开发费用 定制设计 专注app软件定制开发 软件开发定制定制 知名网站建设定制 软件定制开发供应商 应用系统定制开发 软件系统定制开发 企业管理系统定制开发 系统定制开发