本文基于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 查询全部队列订单
结果
到这基本逻辑就实现了。