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.主要配置