delayQueue实现订单超时自动取消

说明

商城系统的订单模块都应该有：订单未支付超时后自动取消订单的操作。我们在开发过程中实现该功能也有很多，例如 消息中间件、定时任务等，每种方法都有各自的优点。这里我使用java DelayQueue容器来实现，优点是本地存储，系统资源消耗低，缺点是单机模式。

实现

1.编写Delayed实现类

@Data
@Accessors(chain = true)
@NoArgsConstructor
public class OrderAutoEntity implements Delayed {

    //订单编号
    private String orderNo;
    //订单具体的过期时间
    private long expire;
    //订单过期时间间隔定义（毫秒），这里设置30分钟
    public static final long expireTime = TimeUnit.MINUTES.toMillis(30);

    public OrderAutoEntity(String orderNo, LocalDateTime orderTime) {
        this.orderNo = orderNo;
        //转成毫秒
        long creatTime = orderTime.toInstant(ZoneOffset.of("+8")).toEpochMilli();
        this.expire = expireTime + creatTime;
    }

    /**
     * 获取剩余时间
     */
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(expire - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed other) {
        return (int) (this.getDelay(TimeUnit.MILLISECONDS) - other.getDelay(TimeUnit.MILLISECONDS));
    }

}

2.编写DelayQueue业务类

@PostConstruct 这个注解会让标注的方法在系统启动后自定加载

@Service
@Slf4j
public class OrderCanelService {
	
	//订单增删改查业务逻辑
    @Resource
    private OrderService orderService;
    
    //用于存放需要未支付计时订单
    private final static DelayQueue<OrderAutoEntity> delayQueue = new DelayQueue<>();


    //订单取消，数据库改变订单状态，DelayQueue容器移除该订单记录
    public void cancelOrder(String orderNo) {
       //数据库改变订单状态
       orderService.cancelOrder(orderNo);
       //容器遍历找到对应的订单记录，并从容器中移除
       Iterator val = delayQueue.iterator();
       while (val.hasNext()) {
           OrderAutoEntity orderAutoEntity = (OrderAutoEntity) val.next();
           if(orderAutoEntity.getOrderNo().equals(orderNo)){
               delayQueue.remove(orderAutoEntity);
           }
       }
    }

    //往队列中新增订单记录
    public void add(OrderAutoEntity orderAutoEntity) {
        delayQueue.put(orderAutoEntity);
    }

    /**
     * 服务器启动时，自动加载待支付订单
     */
    @PostConstruct
    public void initOrderStatus() {
        log.info(">>>>>>>>>>> 系统启动时，加载所有待支付订单到延时队列 >>>>>>>>>>>>.");
        //未支付订单查询
        QueryWrapper<Order> wrapper = new QueryWrapper();
        wrapper.select("order_no", "create_time").eq("status", "0");
        //获取所有未支付订单，这里用了mybatisplus操作数据库
        List<Map<String, Object>> orders = orderService.listMaps(wrapper);
        
        //逐个构造Delay的实现类，添加进容器
        for (Map<String, Object> order : orders) {
            Timestamp createTime = (Timestamp) order.get("create_time");
            OrderAutoEntity orderAutoEntity = new OrderAutoEntity((String) order.get("order_no"), createTime.toLocalDateTime());
            delayQueue.add(orderAutoEntity);
        }
        
        //启动一个线程持续健康订单超时
        Executors.newSingleThreadExecutor().execute(() -> {
            try {
                while (true) {
                    if (delayQueue.size() > 0) {
                    	//容器中超时的订单记录会被取出
                        OrderAutoEntity order = delayQueue.take();
                        //修改数据库，容器中移除数据
                        cancelOrder(order.getOrderNo());
                    }
                }
            } catch (InterruptedException e) {
                log.error("InterruptedException error:", e);
            }
        });
    }
}

3.编写订单业务逻辑

需要朱阿姨的是：我们前台每次新增订单时，也需要再给容器中添加一条记录。

@RestController
@Slf4j
@RequestMapping("/api")
public class OrderController {
	@Resource
    private OrderCanelService orderCanelService ;
	...
	//前端页面调用的订单新增接口
	@PostMapping("/order")
    @Transactional(rollbackFor = Exception.class)
    public ResponseEntity addOrder(@RequestBody Map<String, Object> params) {
		...
			//构造订单延时类(OrderAutoEntity),这里是伪代码
			OrderAutoEntity orderAutoEntity = new OrderAutoEntity(orderNo, createTime);
            orderAutoService.add(orderAutoEntity);
		...
	}
	...
}

总结说明

我这种操作只支持单机情况，一般还可以进一步优化，利用redis：在新增订单时，除了存到数据库，再保留一份到redis中，这样我们在OrderCanelService 的初始化函数initOrderStatus中就不需要查数据库，每次启动就直接读redis中的数据。这里我就没做这么复杂。