异步处理rest服务

1.使用Runnable异步处理Rest服务

@RequestMapping("/order")
public Callable order() {

    logger.info("主线程开始");

    Callable<String> result = new Callable<String>() {
        @Override
        public String call() throws Exception {
            logger.info("副线程开始");
            Thread.sleep(1000);
            logger.info("副线程返回");
            return "success";
        }
    };
    logger.info("主线程返回");
    return result;
}

执行结果如下：

我们可以看到，主线程几乎不占用时间，只是去调一下副线程就立马结束，就可以去做别的了，几乎不占用时间。

2.使用DeferredResult异步处理Rest服务

因为Runnable 的异步处理还是依赖于主线程的调用，实际上不满足我们企业中的应用，我们现实中往往是两个应用程序，非同一个进程。如下图所示：线程1和线程2是完全隔离的，不存在调用关系。此时就需要用到DeferredResult去进行异步处理了

1）模拟消息队列MockQueue对象

@Component
public class MockQueue {
private Logger logger = LoggerFactory.getLogger(MockQueue.class);
//下单消息
private String placeOrder;

//订单完成消息
private String completeOrder;

public String getPlaceOrder() {
    return placeOrder;
}

public void setPlaceOrder(String placeOrder) {
    //模拟下单后的处理，鸡模拟应用2
    new Thread(() ->{
        logger.info("接到下单请求，"+placeOrder);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.completeOrder = placeOrder;
        logger.info("下单请求处理完毕，"+placeOrder);
    }).start();
}

public String getCompleteOrder() {
    return completeOrder;
}

public void setCompleteOrder(String completeOrder) {
    this.completeOrder = completeOrder;
}

}

2）传递DeferredResult对象

**

• 在线程1和线程2之间传递DeferredResult对象
  */
  @Component
  public class DeferredResultHolder {

  //map的key就是订单号，value就是每个订单的处理结果
  private Map<String, DeferredResult> map = new HashMap<String, DeferredResult>();

  public Map<String, DeferredResult> getMap() {
  return map;
  }

  public void setMap(Map<String, DeferredResult> map) {
  this.map = map;
  }
  }

3）模拟下单以及生产消息

@RestController
public class AsyncController {

private Logger logger = LoggerFactory.getLogger(AsyncController.class);

@Autowired
private DeferredResultHolder deferredResultHolder;

@Autowired
private MockQueue mockQueue;

@RequestMapping("/order")
public DeferredResult<String> order() throws InterruptedException {

    logger.info("主线程开始");

    //随机生成8位的订单号
    String oderNumber = RandomStringUtils.randomNumeric(8);
    //模拟放进消息队列
    mockQueue.setPlaceOrder(oderNumber);
    //订单处理结果
    DeferredResult<String> result = new DeferredResult<>();
    deferredResultHolder.getMap().put(oderNumber,result);

// Callable result = new Callable() {
// @Override
// public String call() throws Exception {
// logger.info("副线程开始");
// Thread.sleep(1000);
// logger.info("副线程返回");
// return "success";
// }
// };
logger.info("主线程返回");
return result;
}
}

4）模拟监听器消费消息

/**

• 模拟线程2对于消息队列的监听，即查看completeOrder是否有值
• ContextRefreshedEvent:整个spring容器初始化完毕的一个事件
  */

@Component
public class QueueListener implements ApplicationListener {

private Logger logger = LoggerFactory.getLogger(QueueListener.class);

@Autowired
private DeferredResultHolder deferredResultHolder;

@Autowired
private MockQueue mockQueue;

@Override
public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {

    //因为一直在循环，需要单开一个线程，不然启动的时候会阻塞
    new Thread(() -> {
        while(true) {
            if(StringUtils.isNotBlank(mockQueue.getCompleteOrder())) {
                String orderNumber = mockQueue.getCompleteOrder();
                logger.info("返回订单处理结果："+orderNumber);
                //整个异步处理完成，设置返回给浏览器的信息
                deferredResultHolder.getMap().get(orderNumber).setResult("place order success");
                mockQueue.setCompleteOrder(null);
            } else {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }).start();
}

}

运行结果：

3.异步处理配置

针对两种异步方式注册拦截器，不能像之前同步那样用addInterceptors

原文地址：https://www.cnblogs.com/qq-7895/p/11439954.html