订单自动过时实现方案

需求分析：

24小时内未支付的订单过时失效。

解决方案

1. 被动设置：在查询订单的时候检查是否过时并设置过时状态。
2. 定时调度：定时器定时查询并过时须要过时的订单。
3. 延时队列：将未支付的订单放入一个延时队列中，依次取出过时订单。
4. 过时提醒：reids支持将一个过时的key(订单号)通知给客户端，根据过时的订单号进行相应的处理。

1. 被动设置

这个太简单了，就是在查询的时候判断是否失效，若是失效了就给他设置失效状态。可是弊端也很明显，每次查询都要对未失效的订单作判断，若是用户不查询，订单就不失效，那么若是有相似统计失效状态个数的功能，将会受到影响，因此只能适用于简单独立的场景。简直low爆了。

2. 定时调度

这种是常见的方法，利用一个定时器，在设置的周期内轮询检查并处理须要过时的订单。
具体实现有基于Timer的,有基于Quartz,还有springboot自带的Scheduler，实现起来比较简单。
就写一下第三个的实现方法吧：

1. 启动类加上注解@EnableScheduling
2. 新建一个定时调度类，方法上加上@Scheduled注解，以下图那么简单。

弊端

1. 不可以精准的去处理过时订单，轮询周期设置的越小，精准度越高，可是项目的压力越大，咱们上一个项目就有这种情况，太多定时器在跑，项目运行起来比较笨重。
2. 并且须要处理的是过时的订单，可是要查询全部未支付的订单，范围大。对于大订单量的操做不合适。

3. 延时队列

基于JDK的实现方法，将未支付的订单放到一个有序的队列中，程序会自动依次取出过时的订单。
若是当前没有过时的订单，就会阻塞，直至有过时的订单。因为每次只处理过时的订单，而且处理的时间也很精准，不存在定时调度方案的那两个弊端。
实现：
1.首先建立一个订单类OrderDelayDto须要实现Delayed接口。而后重写getDelay()方法和compareTo()方法，只加了订单编号和过时时间两个属性。
这两个方法很重要，
getDelay()方法实现过时的策略，好比，订单的过时时间等于当前时间就是过时，返回负数就表明须要处理。不然不处理。
compareTo()方法实现订单在队列中的排序规则，这样即便后面加入的订单，也能加入到排序中，我这里写的规则是按照过时时间排序，最早过时的排到最前面，这一点很重要，由于排在最前面的若是没有被处理，就会进入阻塞状态，后面的不会被处理。

import lombok.Data;
import java.util.Date;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * @author mashu
 * Date 2020/5/17 16:25
 */
@Data
public class OrderDelayDto implements Delayed {
    /**
     * 订单编号
     */
    private String orderCode;
    /**
     * 过时时间
     */
    private Date expirationTime;

    /**
     * 判断过时的策略：过时时间大于等于当前时间就算过时
     *
     * @param unit
     * @return
     */
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(this.expirationTime.getTime() - System.currentTimeMillis(), TimeUnit.NANOSECONDS);
    }

    /**
     * 订单加入队列的排序规则
     *
     * @param o
     * @return
     */
    @Override
    public int compareTo(Delayed o) {
        OrderDelayDto orderDelayDto = (OrderDelayDto) o;
        long time = orderDelayDto.getExpirationTime().getTime();
        long time1 = this.getExpirationTime().getTime();
        return time == time1 ? 0 : time < time1 ? 1 : -1;
    }
}

其实这样已经算是写好了。我没有耍你。
写个main 方法测试一下，建立两个订单o1和o2，放入到延时队列中，而后while()方法不断的去取。
在此方法内经过队列的take()方法得到已过时的订单，而后作出相应的处理。

public static void main(String[] args) {
        DelayQueue<OrderDelayDto> queue = new DelayQueue<>();
        OrderDelayDto o1 = new OrderDelayDto();
        //第一个订单，过时时间设置为一分钟后
        o1.setOrderCode("1001");
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.MINUTE, 1);
        o1.setExpirationTime(calendar.getTime());
        OrderDelayDto o2 = new OrderDelayDto();
        //第二个订单，过时时间设置为如今
        o2.setOrderCode("1002");
        o2.setExpirationTime(new Date());
        //往队列中放入数据
        queue.offer(o1);
        queue.offer(o2);
        // 延时队列
        while (true) {
            try {
                OrderDelayDto take = queue.take();
                System.out.println("订单编号：" + take.getOrderCode() + " 过时时间：" + take.getExpirationTime());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

运行结果：

我故意把第二个订单的过时时间设置为第一个订单以前，从结果能够看出，他们已经自动排序把最早过时的排到了最前面。
第一个订单的失效时间是当前时间的后一分钟，结果也显示一分钟后处理了第一条订单。

2.然而一般状况下，咱们会使用多线程去取延时队列中的数据，这样即便线程启动以后也能动态的向队列中添加订单。
建立一个线程类OrderCheckScheduler实现Runnable接口，
添加一个延时队列属性，重写run()方法，在此方法内经过队列的take()方法得到已过时的订单，而后作出相应的处理。

import java.util.concurrent.DelayQueue;
/**
 * @author mashu
 * Date 2020/5/17 14:27
 */
public class OrderCheckScheduler implements Runnable {

  // 延时队列
  private DelayQueue<OrderDelayDto> queue;

  public OrderCheckScheduler(DelayQueue<OrderDelayDto> queue) {
      this.queue = queue;
  }

  @Override
  public void run() {
      while (true) {
          try {
              OrderDelayDto take = queue.take();
              System.out.println("订单编号：" + take.getOrderCode() + " 过时时间：" + take.getExpirationTime());
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  }
}

好了，写个方法测试一下：

public static void main(String[] args) {
        // 建立延时队列
        DelayQueue<OrderDelayDto> queue = new DelayQueue<>();
        OrderDelayDto o1 = new OrderDelayDto();
        //第一个订单，过时时间设置为一分钟后
        o1.setOrderCode("1001");
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.MINUTE, 1);
        o1.setExpirationTime(calendar.getTime());
        OrderDelayDto o2 = new OrderDelayDto();
        //第二个订单，过时时间设置为如今
        o2.setOrderCode("1002");
        o2.setExpirationTime(new Date());
        //运行线程
        ExecutorService exec = Executors.newFixedThreadPool(1);
        exec.execute(new OrderCheckScheduler(queue));
        //往队列中放入数据
        queue.offer(o1);
        queue.offer(o2);
        exec.shutdown();
    }

结果和上面的同样，图就不截了，相信我。

过时提醒

基于redis的过时提醒功能，听名字就知道这个方案最是纯真、最直接的，就是单纯处理过时的订单。
修改个redis的配置吧先，由于redis默认不开启过时提醒。
notify-keyspace-events改成notify-keyspace-events "Ex"
写一个类用来接收来自redis的暖心提醒OrderExpirationListener,继承一下KeyExpirationEventMessageListener抽象类。重写onMessage()方法，在此方法中处理接收到的过时key.

import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.listener.KeyExpirationEventMessageListener;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.stereotype.Component;
import java.util.Date;

/**
 * @author mashu
 * Date 2020/5/17 23:01
 */
@Component
public class OrderExpirationListener extends KeyExpirationEventMessageListener {

    public OrderExpirationListener(RedisMessageListenerContainer listenerContainer) {
        super(listenerContainer);
    }

    @Override
    public void onMessage(Message message, byte[] pattern) {
        final String expiredKey = message.toString();
        System.out.println("我过时了" + expiredKey+"当前时间:"+new Date());
    }
}

ok，向redis中存入一个订单，过时时间为1分钟。

redis.set("orderCode/10010", "1", 1L, TimeUnit.MINUTES);
System.out.println("redis存入订单号 key: orderCode/10010,value:1,过时时间一分钟，当前时间"+new Date());

运行结果：

除此以外还有用到消息队列的。夜深了，我得玩会游戏了。

没有绝对的好方案，只有在不一样场景下的更合适的方案。随着需求的变化，技术的革新，方案也会不断的被优化和迭代，惟一不变的是工资。