使用redis,延时队列完成7天自动收货
1:设置项目启动执行把redis中所有的订单状态为未收货的订单存入队列中(避免系统关闭启动队列中的数据丢失。队列中的数据丢失无法做到检测数据是否超时)
重要
@Service
public class OrderInitializingBean implements InitializingBean{
public static OrderDelayQueueThread OrderDelayQueueThread = null;
@Autowired
private RedisTemplate redisTemplate;
@Autowired
private TbOrderMapper orderService;
@SuppressWarnings("unchecked")
@Override
public void afterPropertiesSet() throws Exception {
Map<String, Object> entries = redisTemplate.opsForHash().entries(CFSConfig.orderDelayBean);
if (OrderDelayQueueThread == null) {
OrderDelayQueueThread = new OrderDelayQueueThread(orderService, redisTemplate);
Thread thread = new Thread(OrderDelayQueueThread);
thread.start();
}
if (!StringUtils.isEmpty(entries) && entries.size()>0) {
for (String key : entries.keySet()) {
OrderDelayedTask delayQueueOrder = (OrderDelayedTask) entries.get(key);
OrderDelayQueueThread.putDelayQueueForRedis(delayQueueOrder);
}
}
}
}
2:正常逻辑卖家发货把订单数据存入redis和队列中进行检测
/**
* 发货(卖家发货订单数据存入redis和延时队列中:延时队列设置时长为7天)
*/
@Override
public Boolean deliverGoods(String[] ids) {
for (String id : ids) {
TbOrder tbOrder = orderMapper.selectByPrimaryKey(id);
if("1".equals(tbOrder.getStatus())) {
tbOrder.setStatus("2");
tbOrder.setConsignTime(new Date());//发货时间
orderMapper.updateByPrimaryKey(tbOrder);
//调用线程,添加延时队列
//项目启动自动执行
OrderInitializingBean.OrderDelayQueueThread.add(id);//调用线程的add方法添加数据
}else {
return false;
}
}
return true;
}
3:队列中的方法:
add(卖家发货调用add方法吧订单存入redis和队列中并设置超时时间)
run(线程启动执行,此处是订单超时时做修改订单状态为收货状态,并删除redis中的订单信息)
removeDelay(用户在7天之内点击收货,调用次方法删除队列和redis中的订单信息,不再进行检测)
putDelayQueueForRedis(项目在自启动时取出redis中的订单信息调用此方法存入队列中继续进行检测[详细请看OrderInitializingBean.afterPropertiesSet方法])
/**
* 使用线程吧订单数据存入redis和队列中并设置时间
*/
public class OrderDelayQueueThread implements Runnable{
private static TbOrderMapper orderService;
private static RedisTemplate redisTemplate;
private static AtomicBoolean isrun = new AtomicBoolean(true);
private static DelayQueue delayQueue = new DelayQueue();
public OrderDelayQueueThread(TbOrderMapper orderService,RedisTemplate redisTemplate) {
super();
this.orderService = orderService;
this.redisTemplate=redisTemplate;
}
public static DelayQueue getDelayQueue() {
return delayQueue;
}
public static void setDelayQueue(DelayQueue delayQueue) {
OrderDelayQueueThread.delayQueue = delayQueue;
}
//订单数据存入redis和队列中并设置时间
@SuppressWarnings("unchecked")
public void add(String orderId) {
Map<String, Object> map=new HashMap<String, Object>();
TbOrder findOrderOne = orderService.selectByPrimaryKey(orderId);
String jsonString = JSON.toJSONString(findOrderOne);
OrderDelayedTask orderDelayedTask = new OrderDelayedTask(jsonString,604800000);//7天
map.put(orderId, orderDelayedTask);
redisTemplate.opsForHash().putAll(CFSConfig.orderDelayBean, map);//订单信息添加到redis中
delayQueue.offer(orderDelayedTask);// 添加到队列中 5分种
}
@Override
public void run() {
try {
while (isrun.get()) {
Delayed take = delayQueue.take();//从队列中取出
if (!StringUtils.isEmpty(take)) {
OrderDelayedTask orderDelayedTask = (OrderDelayedTask) take;
String orderJson = orderDelayedTask.getOrderJson();
TbOrder tbOrder = JSONObject.parseObject(orderJson, TbOrder.class);
if ("2".equals(tbOrder.getStatus())) {// 判断订单是否是已经发货的订单
TbOrder findOrderOne = orderService.selectByPrimaryKey(tbOrder.getOrderId());
if ("2".equals(findOrderOne.getStatus())) {
findOrderOne.setStatus("3");//修改订单状态为已经收获
findOrderOne.setBuyerMessage("收货超时系统自动收货");
orderService.updateByPrimaryKey(findOrderOne);//修改订单的状态
redisTemplate.opsForHash().delete(CFSConfig.orderDelayBean, tbOrder.getOrderId());//删除redis中的数据
}
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* 删除队列中的数据(在7天内用户点击收货调用方法删除redis数据和队列中的数据不进行检测)
* @param tbOrder
* @return
*/
public static boolean removeDelay(TbOrder tbOrder) {
//用户点击确认收货,取出队列中的数据,删除redis种的订单,修改订单的状态
if (isrun.get()) {
Object[] objectArray = delayQueue.toArray();
if (objectArray!=null && objectArray.length>0) {
for (Object object: objectArray) {
OrderDelayedTask orderDelayedTask=(OrderDelayedTask) object;
String tbOrderJson = JSON.toJSONString(tbOrder);
redisTemplate.opsForHash().delete(CFSConfig.orderDelayBean, tbOrder.getOrderId());
boolean remove = delayQueue.remove(orderDelayedTask);
return remove;
}
}
}
return false;
}
public void putDelayQueueForRedis(OrderDelayedTask orderDelayedTask) {
delayQueue.offer(orderDelayedTask);
}
3:使用延时队列必须实现Delayed接口,重写俩个方法getDelay和getDelay。OrderDelayedTask类是存入延时队列中的数据,包括开始时间(start:当前系统获取到的时间),订单信息(orderJson),延时时间(time)!!!
注意:OrderDelayedTask需要存入redis中一定要记得实现Serializable
重要
public class OrderDelayedTask implements Delayed,Serializable{
private String orderJson ;
private long start = System.currentTimeMillis();//开始时间
private long time ;
public OrderDelayedTask(String orderJson, long time) {
super();
this.orderJson = orderJson;
this.time = time;
}
public String getOrderJson() {
return orderJson;
}
public void setOrderJson(String orderJson) {
this.orderJson = orderJson;
}
@Override
public String toString() {
return "OrderDelayedTask [orderJson=" + orderJson + ", start=" + start + ", time=" + time + "]";
}
/**
* 需要实现的接口,获得延迟时间 用过期时间-当前时间
* @param unit
* @return
*/
@Override
public long getDelay(TimeUnit unit) {
return unit.convert((start+time) - System.currentTimeMillis(),TimeUnit.MILLISECONDS);
}
/**
* 用于延迟队列内部比较排序 当前时间的延迟时间 - 比较对象的延迟时间
* @param o
* @return
*/
@Override
public int compareTo(Delayed o) {
OrderDelayedTask o1 = (OrderDelayedTask) o;
return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
}