010 异步处理Rest服务

一：任务

1.任务

　　使用Runnable异步处理Rest服务

　　使用DefaultResult异步处理Rest服务

　　异步处理的配置

2.原理图说明

　　

二：Callable进行异步处理

1.程序

　　新建一个anysc的包

 package com.cao.web.async;

 import java.util.concurrent.Callable;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;

 @RestController
 public class AsyncController {
     private Logger logger=LoggerFactory.getLogger(getClass());

     @RequestMapping("/order")
     public Callable<String> order() throws Exception {
         logger.info("主线程开始");
         //业务逻辑放在副线程中
         Callable<String> result=new Callable<String>() {

             @Override
             public String call() throws Exception {
                 logger.info("副线程开始");
                 Thread.sleep(5000);
                 logger.info("副线程返回");
                 return "success";
             }

         };

         logger.info("主线程返回");

         return result;
     }

 }

2.效果

　　重点关注时间

　　

三：使用DeferredResult

1.问题

　　方式一是有问题的，因为副线程是需要主线程调用起来的。

　　是写在主线程中的。

　　有些场景是不合适的。

　　线程间使用DeferredResult沟通起来。

2.场景如下：

　　

3.程序

　　程序太多，有点复杂

　　控制器

 package com.cao.web.async;

 import java.util.concurrent.Callable;

 import org.apache.commons.lang.RandomStringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.context.request.async.DeferredResult;

 @RestController
 public class AsyncController {
     private Logger logger=LoggerFactory.getLogger(getClass());
     @Autowired
     private Queue queue;

     @Autowired
     private DeferredResultHolder deferredResultHolder;

     /**
      * 主要是验证Callable
      * @return
      * @throws Exception
      */
     @RequestMapping("/order")
     public Callable<String> order() throws Exception {
         logger.info("主线程开始");
         //业务逻辑放在副线程中
         Callable<String> result=new Callable<String>() {

             @Override
             public String call() throws Exception {
                 logger.info("副线程开始");
                 Thread.sleep(5000);
                 logger.info("副线程返回");
                 return "success";
             }

         };

         logger.info("主线程返回");

         return result;
     }
     /**
      * 主要是验证
      * @return
      * @throws Exception
      */
     @RequestMapping("/newOrder")
     public DeferredResult<String> newOrder() throws Exception {
         logger.info("主线程开始");
         //
         String oderNumber=RandomStringUtils.randomNumeric(8);
         queue.setPlaceOrder(oderNumber);
         DeferredResult<String> result=new DeferredResult<>();
         deferredResultHolder.getMap().put(oderNumber, result);
         logger.info("主线程返回");

         return result;
     }

 }

　　queue.java

 package com.cao.web.async;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;

 @Component
 public class Queue {
     private String placeOrder;
     private String completeOrder;

     private Logger logger=LoggerFactory.getLogger(getClass());

     public String getPlaceOrder() {
         return placeOrder;
     }
     public void setPlaceOrder(String placeOrder) throws Exception {
         new Thread(() -> {
             logger.info("接到下单请求");
             try {
                 Thread.sleep(2000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             // 表示处理完成，应用2将结果返回给了completeOrder
             this.completeOrder = placeOrder;
             logger.info("下单请求处理完毕" + placeOrder);
         }

         ).start();

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

 }

　　deferredResultHolder.java

 package com.cao.web.async;

 import java.util.HashMap;
 import java.util.Map;

 import org.springframework.stereotype.Component;
 import org.springframework.web.context.request.async.DeferredResult;

 @Component
 public class DeferredResultHolder {
     //一个是订单号，一个是订单号的处理结果
     private Map<String,DeferredResult<String>> map=new HashMap<>();
     public Map<String,DeferredResult<String>> getMap(){
         return map;
     }
     public void setMap(Map<String,DeferredResult<String>> map) {
         this.map=map;
     }
 }

　　QueueListener.java

 package com.cao.web.async;

 import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.log;

 import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationListener;
 import org.springframework.context.event.ContextRefreshedEvent;
 import org.springframework.stereotype.Component;

 @Component
 public class QueueListener implements ApplicationListener<ContextRefreshedEvent>{
     @Autowired
     private Queue queue;

     @Autowired
     private DeferredResultHolder deferredResultHolder;

     private Logger logger=LoggerFactory.getLogger(getClass());

     @Override
     public void onApplicationEvent(ContextRefreshedEvent event) {
         new Thread(() -> {
             while (true) {
                 if (StringUtils.isNotBlank(queue.getCompleteOrder())) {
                     String orderNumber = queue.getCompleteOrder();
                     logger.info("返回订单处理结果" + orderNumber);
                     deferredResultHolder.getMap().get(orderNumber).setResult("place order success");
                     queue.setCompleteOrder(null);
                 } else {
                     try {
                         Thread.sleep(100);
                     } catch (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                 }
             }
         }).start();

     }

 }

　　

4.效果

　　前端效果

　　

　　控制台效果

　　

三：异步线程的配置

1.说明

　　对于拦截器，与同步的拦截器不一样，仍然需要配置、

2.主要配置