Springboot + DelayQueue延迟队列 实现15分钟内不付款自动取消订单 有手就行！

本文基于java搭建了一个实现 期限时间内 未付款，自动取消订单的简单示例，仅于控制台逻辑实现，所用到的Springboot，delayqueue。

技术介绍

• delayqueue 延迟队列

java延迟队列提供了在指定时间才能获取队列元素的功能，队列头元素是最接近过期的元素。没有过期元素的话，使用poll()方法会返回null值，超时判定是通过getDelay(TimeUnit.NANOSECONDS)方法的返回值小于等于0来判断。延时队列不能存放空元素。

简单理解:

delayqueue就是一个队列，里面有数个queue,每个queue都是一条订单，而且都绑定了订单的过期时间(怎么绑定，看下面代码),越快过期的订单，越会往delayqueue队列的前面排，以此排列，可以通过线程执行take()将过期的queue(到期且未付款的订单)自动清除。

示例代码

pom.xml

其实没什么特别的依赖就是一个时间辅助和lombok

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.4.2</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

application.yml

server:
  port: 8899
order:
  isOpen: 1

util(工具类)

package com.delayqueue.demo.util;
import lombok.Data;
/**
 * @author lyj
 * @version 1.0
 * @date 2021/2/3 16:08
 */
@Data
public class ReturnT {
    private Integer code;
    private String mgs;
    private Object data;
    public ReturnT() {
        this.code = 200;
    }
    public ReturnT(Integer code, String mgs) {
        this.code = code;
        this.mgs = mgs;
    }
    public ReturnT(Integer code, String mgs, Object data) {
        this.code = code;
        this.mgs = mgs;
        this.data = data;
    }
    public static ReturnT getSuccess(){
     return  new ReturnT(200,"执行成功!");
    }
    public static ReturnT getFail(String mgs){
        return  new ReturnT(400,mgs);
    }
}

Order(实体类)

package com.delayqueue.demo.entity;
import lombok.Data;
import java.util.Date;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
/**
 * @author luoyangjie
 * @version 1.0
 * @date 2021/2/3 15:17
 */
@Data
public class Order implements Delayed {
    /**
     * 订单号
     */
    private String orderNo;
    /**
     * 用户id
     */
    private String userId;
    /**
     * 订单状态（0待领取，1已领取，2已勾销）
     */
    private Integer status;
    /**
     * 订单创立时间
     */
    private Date createTime;
    /**
     * 订单失效时间
     */
    private Date cancelTime;
    public Order(String orderNo, String userId, Integer status, Date createTime, Date cancelTime) {
        this.orderNo = orderNo;
        this.userId = userId;
        this.status = status;
        this.createTime = createTime;
        this.cancelTime = cancelTime;
    }
    @Override
    public String toString() {
        return "Order{" +
                "orderNo='" + orderNo + '\'' +
                ", userId='" + userId + '\'' +
                ", status=" + status +
                ", createTime=" + createTime +
                ", cancelTime=" + cancelTime +
                '}';
    }
    /**
     * 取得延迟时间，用失效时间-当前时间，时间单位须要对立
     * @param unit
     * @return
     */
    @Override
    public long getDelay(TimeUnit unit) {
        //上面用到unit.convert()办法，其实在这个小场景不须要用到，只是学习一下如何应用罢了
        return unit.convert(cancelTime.getTime() - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }
    /**
     * 用于提早队列外部比拟排序，以后工夫的延迟时间 - 比拟对象的延迟时间
     * @param o
     * @return
     */
    @Override
    public int compareTo(Delayed o) {
        //这里依据勾销工夫来比拟，如果勾销所剩时间小的，就会优先被队列提取进去
        //注意延迟时间 的绑定就是这绑定的属性
        return this.getCancelTime().compareTo(((Order) o).getCancelTime());
    }
}

注意:订单进入队列绑定的时间属性，就是compareTo方法绑定的。

service

package com.delayqueue.demo.service;
import com.delayqueue.demo.entity.Order;
import com.delayqueue.demo.util.ReturnT;
import java.util.concurrent.DelayQueue;
/**
 * @author luoyangjie
 * @version 1.0
 * @date 2021/2/3 15:19
 */
public interface CancelOrderService {
    /**
     * 勾销订单
     */
    void cancelOrder();
    ReturnT payOrder(String orderNo);
    DelayQueue<Order> getAllOrder();
    /**
     * 获取队列
     * @return
     */
    DelayQueue<Order> getOrder();
}

serviceImpl

package com.delayqueue.demo.service.impl;
import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateUtil;
import com.delayqueue.demo.entity.Order;
import com.delayqueue.demo.service.CancelOrderService;
import com.delayqueue.demo.util.ReturnT;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
import java.util.Date;
import java.util.concurrent.DelayQueue;
/**
 * @author luoyangjie
 * @version 1.0
 * @date 2021/2/3 15:20
 */
@Service
public class CancelOrderServiceImpl implements CancelOrderService {
    /**
     * 是否开启主动勾销性能
     */
    @Value("${order.isOpen}")
    private int isOpen;
    /**
     * 提早队列，用来寄存订单对象
     */
    DelayQueue<Order> queue = new DelayQueue<>();
    @Resource
    private ThreadPoolTaskExecutor executorService;
    @Override
    public void cancelOrder() {
        //新建一个线程，用来模仿定时排查取消过期订单job
        executorService.submit(()->{
            try {
                System.out.println("***********开启主动取消订单job***********,时间：" + DateUtil.date());
                while (isOpen == 1) {
                    try {
                        Order order = queue.take();
                        order.setStatus(2);
                        System.out.println("订单：" + order.getOrderNo() + "付款超时，主动勾销，当前时间：" + DateUtil.date());
                        System.out.println("当前订单延迟队列数量:"+queue.size());
                        System.out.println(queue.toString());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }
    @Override
    public ReturnT payOrder(String orderNo) {
        if (StringUtils.isEmpty(orderNo)){
            return ReturnT.getFail("订单号为空!");
        }
        if (queue == null || queue.isEmpty()){
            return ReturnT.getFail("延迟队列为空!");
        }
        System.out.println(orderNo+"付款中....");
        Boolean flag=true;
        System.out.println("当前 延迟列队数量:"+queue.size());
        for (Order q:queue){
            if (q.getOrderNo().equals(orderNo)){
                queue.remove(q);
                System.out.println(orderNo+"付款完成!延迟列队数量:"+queue.size());
                System.out.println(queue.toString());
                flag=false;
            }
        }
        if (flag){
            return new ReturnT(403,"未找到订单");
        }
        return ReturnT.getSuccess();
    }
    @Override
    public DelayQueue<Order> getAllOrder() {
        return queue;
    }
    @Override
    public DelayQueue<Order> getOrder(){
        executorService.submit(()->{
            try {
                Date date = DateUtil.date();
                System.out.println("开始创建订单.....,时间:"+DateUtil.date());
                queue.add(new Order("SO001", "001", 0, date, DateUtil.offset(date, DateField.SECOND, 3)));
                queue.add(new Order("SO002", "002", 0, DateUtil.offset(date, DateField.SECOND, 3), DateUtil.offset(date, DateField.MINUTE, 1)));
                queue.add(new Order("SO003", "003", 0, DateUtil.offset(date, DateField.SECOND, 6), DateUtil.offset(date, DateField.MINUTE, 2)));
                System.out.println("当前订单延迟队列数量:"+queue.size());
                System.out.println(queue.toString());
                System.out.println("创建订单完毕......,时间:"+DateUtil.date());
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        return queue;
    }
}

controller

package com.delayqueue.demo.controller;
import com.delayqueue.demo.entity.Order;
import com.delayqueue.demo.service.CancelOrderService;
import com.delayqueue.demo.util.ReturnT;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.concurrent.DelayQueue;
/**
 * @author luoyangjie
 * @version 1.0
 * @date 2021/2/3 15:21
 */
@RestController
public class CancelOrderController {
    @Resource
    CancelOrderService cancelOrderService;
    @RequestMapping("/")
    public void cancelOrder(){
        //创建订单
        cancelOrderService.getOrder();
        //取消订单
        cancelOrderService.cancelOrder();
    }
    @RequestMapping("/queue")
    public void getOrder(){
        cancelOrderService.getOrder();
    }
    @RequestMapping("/payOrder")
    public String payOrder(String order){
        ReturnT returnT = cancelOrderService.payOrder(order);
        return returnT.toString();
    }
    @RequestMapping("/getAllOrder")
    public String getAllOrder(){
        DelayQueue<Order> allOrder = cancelOrderService.getAllOrder();
        return allOrder.toString();
    }
}

因为是示例，所以代码量比较少，然后模拟创建三个订单有效时间分别是30s,1min,2min，然后在第一个订单超时的时候实现订单SO003的付款，相当于俩个超时一个付款成功的情况。

点击创建订单
http://localhost:8899/
http://localhost:8899/getAllOrder 查询全部队列订单

结果

到这基本逻辑就实现了。