需求分析：
24小时内未支付的订单过期失效。
解决方案
- 被动设置：在查询订单的时候检查是否过期并设置过期状态。
- 定时调度：定时器定时查询并过期需要过期的订单。
- 延时队列：将未支付的订单放入一个延时队列中，依次取出过期订单。
- 过期提醒：reids支持将一个过期的key(订单号)通知给客户端，监听过期的key进行相应的处理。
- 延时队列：利用RabbitMq的延时队列功能，订单创建后发送检查订单状态的消息，24小时后监听到该消息并执行订单是否支付完成的逻辑。
1. 被动设置
这个太简单了，就是在查询的时候判断是否失效，如果失效了就给他设置失效状态。但是弊端也很明显，每次查询都要对未失效的订单做判断，如果用户不查询，订单就不失效，那么如果有类似统计失效状态个数的功能，将会受到影响，所以只能适用于简单独立的场景。简直low爆了。
2. 定时调度
这种是常见的方法，利用一个定时器，在设置的周期内轮询检查并处理需要过期的订单。
具体实现有基于Timer的,有基于Quartz,还有springboot自带的Scheduler，实现起来比较简单。
就写一下第三个的实现方法吧：
- 启动类加上注解
@EnableScheduling - 新建一个定时调度类，方法上加上
@Scheduled注解，如下图那么简单。
弊端
- 不能够精准的去处理过期订单，轮询周期设置的越小，精准度越高，但是项目的压力越大，我们上一个项目就有这种状况，太多定时器在跑，项目运行起来比较笨重。
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());运行结果：
延时队列
RabbitMQ默认是不支持延时消息的，需要安装rabbitmq_delayed_message_exchange延时插件，
下载地址：https://www.rabbitmq.com/comm...
上传插件rabbitmq_delayed_message_exchange-3.8.0.ez到/usr/lib/rabbitmq/lib/rabbitmq_server-3.8.14/plugins目录。
开启插件
rabbitmq-plugins enable rabbitmq_delayed_message_exchange查看已安装插件列表
rabbitmq-plugins list重启RabbitMQ
/bin/systemctl restart rabbitmq-server.service生产者延时发送代码：
delayTime：延时时间
rabbitTemplate.convertAndSend(DELAYED_EXCHANGE_NAME, DELAYED_ROUTING_KEY, msg, a ->{
a.getMessageProperties().setDelay(delayTime);
return a;
});没有绝对的好方案，只有在不同场景下的更合适的方案。随着需求的变化，技术的革新，方案也会不断的被优化和迭代，唯一不变的是工资。
java
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。