Java实现订单超时未支付自动取消的8种方法总结

Java实现订单超时未支付自动取消的8种方法总结

定时轮询

• 数据库定时轮询方式，实现思路比较简单。启动一个定时任务，每隔一定时间扫描订单表，查询到超时订单就取消。
• 优点：实现简单。
• 缺点：轮询时间间隔不好确定，占用服务器资源，影响数据库性能。

惰性取消

• 当查询订单信息时，先判断该订单是否超时，如果超时就先取消。
• 优点：实现简单。
• 缺点：影响查询之外的业务（如：统计、库存），影响查询效率。

JDK延迟队列

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

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

• import java.util.concurrent.Delayed;
  import java.util.concurrent.TimeUnit;
   
  public class OrderDelayed implements Delayed {
   
      /**
       * 延迟时间
       */
      private final Long time;
      /**
       * 订单编号
       */
      public String orderNo;
   
      public OrderDelayed(String orderNo, long time, TimeUnit unit) {
          this.orderNo = orderNo;
          this.time = System.currentTimeMillis() + (time > 0 ? unit.toMillis(time) : 0);
      }
   
      @Override
      public long getDelay(TimeUnit unit) {
          return time - System.currentTimeMillis();
      }
   
      @Override
      public int compareTo(Delayed o) {
          OrderDelayed orderDelayed = (OrderDelayed) o;
          long diff = this.time - orderDelayed.time;
          if (diff <= 0) {
              return -1;
          } else {
              return 1;
          }
      }
  }
  

• import java.util.concurrent.DelayQueue;
  import java.util.concurrent.TimeUnit;
   
  public class Test {
   
      public static void main(String[] args) {
   
          DelayQueue delayQueue = new DelayQueue<>();
   
          delayQueue.put(new OrderDelayed("220101001", 8, TimeUnit.SECONDS));
          delayQueue.put(new OrderDelayed("220101002", 4, TimeUnit.SECONDS));
   
          System.out.println("订单延迟队列开始执行");
   
          while (true) {
              // 取队列头部元素是否过期
              OrderDelayed task = delayQueue.poll();
              if (task != null) {
                  // 取消订单业务逻辑
                  System.out.println("订单 ---> " + task.orderNo + " 已过期准备取消");
              }
          }
      }
  }
  

• 优点：效率高，任务触发时间延迟低。

• 缺点：异常恢复困难，集群扩展麻烦，内存占用。

时间轮

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

• 
      io.netty
      netty-all
      4.1.78.Final
  
  

• import io.netty.util.HashedWheelTimer;
  import io.netty.util.Timeout;
  import io.netty.util.Timer;
  import io.netty.util.TimerTask;
   
  import java.util.concurrent.TimeUnit;
   
  public class Test {
   
      public static void main(String[] args) {
   
          // 初始化时间轮
          Timer timer = new HashedWheelTimer();
   
          // 定时任务
          TimerTask task1 = new TimerTask() {
              public void run(Timeout timeout) throws Exception {
                  // 取消订单业务逻辑
                  System.out.println("订单1已过期准备取消");
              }
          };
          // 注册此定时任务（延迟时间为5秒，也就是说5秒后订单过期）
          timer.newTimeout(task1, 5, TimeUnit.SECONDS);
   
          // 定时任务
          TimerTask task2 = new TimerTask() {
              public void run(Timeout timeout) throws Exception {
                  // 取消订单业务逻辑
                  System.out.println("订单2已过期准备取消");
              }
          };
          // 注册此定时任务（延迟时间为3秒，也就是说3秒后订单过期）
          timer.newTimeout(task2, 3, TimeUnit.SECONDS);
      }
  }
  

• 优点：效率高，任务触发时间延迟更低。

• 缺点：异常恢复困难，集群扩展麻烦，内存占用。

Redis过期回调

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

• 在redis.conf加入一条配置：

• notify-keyspace-events Ex
  

• 监听配置

• @Configuration
  public class RedisListenerConfig {
   
      @Bean
      RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) {
          RedisMessageListenerContainer container = new RedisMessageListenerContainer();
          container.setConnectionFactory(connectionFactory);
          return container;
      }
  }
  

• Redis过期回调监听方法

• @Component
  public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {
   
      public RedisKeyExpirationListener(RedisMessageListenerContainer listenerContainer) {
          super(listenerContainer);
      }
   
      @Override
      public void onMessage(Message message, byte[] pattern) {
          // 过期key，可以设置成订单号
          String expiredKey = message.toString();
          // 取消订单业务逻辑
          System.out.println("订单 ---> " + expiredKey + " 已过期准备取消");
      }
  }
  

• 优点：数据不易丢失，集群扩展方便。

• 缺点：需要额外维护redis。

Redis有序集合

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

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

• public void pollOrderQueue() {
   
      while (true) {
          Set set = jedis.zrangeWithScores(delayqueue, 0, 0);
   
          String value = ((Tuple) set.toArray()[0]).getElement();
          int score = (int) ((Tuple) set.toArray()[0]).getScore();
   
          int nowSecond = System.currentTimeMillis() / 1000);
          if (nowSecond >= score) {
              jedis.zrem(delayqueue, value);
              System.out.println(sdf.format(new Date()) + " removed key:" + value);
          }
   
          if (jedis.zcard(delayqueue) <= 0) {
              System.out.println(sdf.format(new Date()) + " zset empty ");
              return;
          }
          Thread.sleep(1000);
      }
  }
  

• 优点：数据不易丢失，集群扩展方便。\

• 缺点：可能重复消费同一key。

任务调度

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

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

• import com.xxl.job.core.handler.annotation.XxlJob;
  import org.springframework.stereotype.Component;
   
  @Component
  public class JobHandler {
   
      @XxlJob("payExpireJobHandler")
      public void payExpireJobHandler(String executorParam) {
          // 取消订单业务逻辑
          System.out.println("订单 ---> " + executorParam + " 已过期准备取消");
      }
  }
  

• 优点：时效性强，支持分布式。

• 缺点：实现复杂，维护成本高。

消息队列

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

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

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

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

• 优点：高效，好扩展，支持分布式。

• 缺点：实现复杂，维护成本高。