使用Redisson优雅关闭订单

在支付系统中，订单通常是具有时效性的，例如在下单30分钟后如果还没有完成支付，那么就要取消订单，不能再执行后续流程。说到这，可能大家的第一反应是启动一个定时任务，来轮询订单的状态是否完成了支付，如果超时还没有完成，那么就去修改订单的关闭字段。当然，在数据量小的时候这么干没什么问题，但是如果订单的数量上来了，那么就会出现读取数据的瓶颈，毕竟来一次全表扫描还是挺费时的。

针对于定时任务的这种缺陷，关闭订单的这个需求大多依赖于延时任务来实现，这里说明一下延时任务与定时任务的最大不同，定时任务有执行周期的，而延时任务在某事件触发后一段时间内执行，并没有执行周期。

对于延时任务，可能大家对于RabbitMQ的延时队列会比较熟悉，用起来也是得心应手，但是你是否知道使用Redis也能实现延时任务的功能呢，今天我们就来看看具体应该如何实现。

使用Redis实现的延时队列，需要借助Redisson的依赖：

 
 
 
 
    
  
  
  
  
    2. 
  
  
  
  
  2.     org.redisson
    3. 
  
  
  
  
  3.     redisson-spring-boot-starter
    4. 
  
  
  
  
  4.     3.10.7
    5. 
  
  
  
  
  5.

首先实现往延时队列中添加任务的方法，为了测试时方便，我们把延迟时间设为30秒。

 
 
 
 
    
  
  
  
  
  1. @Component
    2. 
  
  
  
  
  2. public class UnpaidOrderQueue {
    3. 
  
  
  
  
  3.     @Autowired
    4. 
  
  
  
  
  4.     RedissonClient redissonClient;
    5. 
  
  
  
  
  5. 
  
  
  
  
  6.     public void addUnpaid(String orderId){
    7. 
  
  
  
  
  7.         RBlockingQueue blockingFairQueue = redissonClient.getBlockingQueue("orderQueue");
    8. 
  
  
  
  
  8.         RDelayedQueue delayedQueue = redissonClient.getDelayedQueue(blockingFairQueue);
    9. 
  
  
  
  
  9. 
  
  
  
  
  10.         System.out.println(DateTime.now().toString(JodaUtil.HH_MM_SS)+" 添加任务到延时队列");
    11. 
  
  
  
  
  11.         delayedQueue.offer(orderId,30, TimeUnit.SECONDS);
    12. 
  
  
  
  
  12.     }
    13. 
  
  
  
  
  13. }
    14.

添加一个对队列的监听方法，通过实现CommandLineRunner接口，使它在springboot启动时就开始执行：

 
 
 
 
    
  
  
  
  
  1. @Component
    2. 
  
  
  
  
  2. public class QueueRunner implements CommandLineRunner {
    3. 
  
  
  
  
  3.     @Autowired
    4. 
  
  
  
  
  4.     private RedissonClient redissonClient;
    5. 
  
  
  
  
  5. 
  
  
  
  
  6.     @Autowired
    7. 
  
  
  
  
  7.     private OrderService orderService;
    8. 
  
  
  
  
  8. 
  
  
  
  
  9.     @Override
    10. 
  
  
  
  
  10.     public void run(String... args) throws Exception {
    11. 
  
  
  
  
  11.         new Thread(()->{
    12. 
  
  
  
  
  12.             RBlockingQueue blockingFairQueue = redissonClient.getBlockingQueue("orderQueue");
    13. 
  
  
  
  
  13.             RDelayedQueue delayedQueue = redissonClient.getDelayedQueue(blockingFairQueue);
    14. 
  
  
  
  
  14.             delayedQueue.offer(null, 1, TimeUnit.SECONDS);
    15. 
  
  
  
  
  15.             while (true){
    16. 
  
  
  
  
  16.                 String orderId = null;
    17. 
  
  
  
  
  17.                 try {
    18. 
  
  
  
  
  18.                     orderId = blockingFairQueue.take();
    19. 
  
  
  
  
  19.                 } catch (Exception e) {
    20. 
  
  
  
  
  20.                     continue;
    21. 
  
  
  
  
  21.                 }
    22. 
  
  
  
  
  22.                 if (orderId==null) {
    23. 
  
  
  
  
  23.                     continue;
    24. 
  
  
  
  
  24.                 }
    25. 
  
  
  
  
  25.                 System.out.println(String.format(DateTime.now().toString(JodaUtil.HH_MM_SS)+" 延时队列收到："+orderId));
    26. 
  
  
  
  
  26.                 System.out.println(DateTime.now().toString(JodaUtil.HH_MM_SS)+" 检测订单是否完成支付");
    27. 
  
  
  
  
  27.                 if (orderService.isTimeOut(orderId)) {
    28. 
  
  
  
  
  28.                     orderService.closeOrder(orderId);
    29. 
  
  
  
  
  29.                 }
    30. 
  
  
  
  
  30.             }
    31. 
  
  
  
  
  31.         }).start();
    32. 
  
  
  
  
  32.     }
    33. 
  
  
  
  
  33. }
    34.

在方法中，单独启动了一个线程来进行监听，如果有任务进入延时队列，那么取到订单号后，调用我们OrderService提供的检测是否订单过期的服务，如果过期，那么执行关闭订单的操作。

创建简单的OrderService用于测试，提供创建订单，检测超时，关闭订单方法：

 
 
 
 
    
  
  
  
  
  1. @Service
    2. 
  
  
  
  
  2. public class OrderService {
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.     @Autowired
    5. 
  
  
  
  
  5.     UnpaidOrderQueue unpaidOrderQueue;
    6. 
  
  
  
  
  6. 
  
  
  
  
  7.     public void createOrder(String order){
    8. 
  
  
  
  
  8.         System.out.println(DateTime.now().toString(JodaUtil.HH_MM_SS)+" 创建订单:"+order);
    9. 
  
  
  
  
  9.         unpaidOrderQueue.addUnpaid(order);
    10. 
  
  
  
  
  10.     }
    11. 
  
  
  
  
  11. 
  
  
  
  
  12.     public boolean isTimeOut(String orderId){
    13. 
  
  
  
  
  13.         return true;
    14. 
  
  
  
  
  14.     }
    15. 
  
  
  
  
  15. 
  
  
  
  
  16.     public void closeOrder(String orderId){
    17. 
  
  
  
  
  17.         System.out.println(DateTime.now().toString(JodaUtil.HH_MM_SS)+ " 关闭订单");
    18. 
  
  
  
  
  18.     }
    19. 
  
  
  
  
  19. }
    20.

执行请求，看一下结果：

在订单创建30秒后，检测到延时队列中有任务任务，调用检测超时方法检测到订单没有完成后，自动关闭订单。

除了上面这种延时队列的方式外，Redisson还提供了另一种方式，也能优雅的关闭订单，方法很简单，就是通过对将要过期的key值的监听。

创建一个类继承KeyExpirationEventMessageListener，重写其中的onMessage方法，就能实现对过期key的监听，一旦有缓存过期，就会调用其中的onMessage方法：

 
 
 
 
    
  
  
  
  
  1. @Component
    2. 
  
  
  
  
  2. public class RedisExpiredListener extends KeyExpirationEventMessageListener {
    3. 
  
  
  
  
  3.     public static final String UNPAID_PREFIX="unpaidOrder:";
    4. 
  
  
  
  
  4. 
  
  
  
  
  5.     @Autowired
    6. 
  
  
  
  
  6.     OrderService orderService;
    7. 
  
  
  
  
  7. 
  
  
  
  
  8.     public RedisExpiredListener(RedisMessageListenerContainer listenerContainer) {
    9. 
  
  
  
  
  9.         super(listenerContainer);
    10. 
  
  
  
  
  10.     }
    11. 
  
  
  
  
  11. 
  
  
  
  
  12.     @Override
    13. 
  
  
  
  
  13.     public void onMessage(Message message, byte[] pattern) {
    14. 
  
  
  
  
  14.         String expiredKey = message.toString();
    15. 
  
  
  
  
  15.         if (expiredKey.startsWith(UNPAID_PREFIX)){
    16. 
  
  
  
  
  16.             System.out.println(DateTime.now().toString(JodaUtil.HH_MM_SS)+" " +expiredKey+"已过期");
    17. 
  
  
  
  
  17.             orderService.closeOrder(expiredKey);
    18. 
  
  
  
  
  18.         }
    19. 
  
  
  
  
  19.     }
    20. 
  
  
  
  
  20. }
    21.

因为可能会有很多key的过期事件，因此需要对订单过期的key加上一个前缀，用来判断过期的key是不是属于订单事件，如果是的话那么进行关闭订单操作。

再在写一个测试接口，用于创建订单和接收支付成功的回调结果：

 
 
 
 
    
  
  
  
  
  1. @RestController
    2. 
  
  
  
  
  2. @RequestMapping("order")
    3. 
  
  
  
  
  3. public class TestController {
    4. 
  
  
  
  
  4.     @Autowired
    5. 
  
  
  
  
  5.     RedisTemplate redisTemplate;
    6. 
  
  
  
  
  6. 
  
  
  
  
  7.     @GetMapping("create")
    8. 
  
  
  
  
  8.     public String setTemp(String id){
    9. 
  
  
  
  
  9.         String orderId= RedisExpiredListener.UNPAID_PREFIX+id;
    10. 
  
  
  
  
  10.         System.out.println(DateTime.now().toString(JodaUtil.HH_MM_SS)+" 创建订单:"+orderId);
    11. 
  
  
  
  
  11.         redisTemplate.opsForValue().set(orderId,orderId,30, TimeUnit.SECONDS);
    12. 
  
  
  
  
  12.         return id;
    13. 
  
  
  
  
  13.     }
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.     @GetMapping("fallback")
    16. 
  
  
  
  
  16.     public void successFallback(String id){
    17. 
  
  
  
  
  17.         String orderId= RedisExpiredListener.UNPAID_PREFIX+id;
    18. 
  
  
  
  
  18.         redisTemplate.delete(orderId);
    19. 
  
  
  
  
  19.     }
    20. 
  
  
  
  
  20. }
    21.

在订单支付成功后，一般我们会收到第三方的一个支付成功的异步回调通知。如果支付完成后收到了这个回调，那么我们主动删除缓存的未支付订单，那么也就不会监听到这个订单的orderId的过期失效事件。

但是这种方式有一个弊端，就是只能监听到过期缓存的key，不能获取到对应的value。而通过延时队列的方式，可以通过为RBlockingQueue添加泛型的方式，保存更多订单的信息，例如直接将对象存进队列中：

 
 
 
 
    
  
  
  
  
  1. RBlockingQueue blockingFairQueue = redissonClient.getBlockingQueue("orderQueue");
    2. 
  
  
  
  
  2. RDelayedQueue delayedQueue = redissonClient.getDelayedQueue(blockingFairQueue);
    3.

这样的话我们再从延时队列中获取的时候，能够拿到更多我们需要的属性。综合以上两种方式，监听过期更为简单，但存在的一定的局限性，如果我们只需要对订单进行判断的话那么功能也能够满足我们的需求，如果需要在过期时获取更多的订单属性，那么使用延时队列的方式则更为合适。究竟选择哪种，就要看大家的业务场景了。

当前名称：使用Redisson优雅关闭订单
链接URL：http://www.hantingmc.com/qtweb/news13/465313.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站排名知识

分类信息网

响应式网站建设　　 　app开发　　 　成都成品网站　　 　眉山电信机房　　 　腾讯云香港虚拟主机　　 　虚拟主机　　 　界面设计　　 　成都茶叶销售　　 　阿坝网站设计　　 　移动网站建设　　 　兴发搬家　　 　网站空间　　 　医药医疗网站建设方案　　 　成都网站建设　　 　南充电信机房托管　　 　成都做商城网站　　 　娃娃鱼鱼苗　　 　鑫友邦火锅桌　　 　江油做网站　　 　广东帝美豪门窗