转载： https://blog.csdn.net/yingxiake/article/details/51193319

因为服务器请求处理线程的总数是有限的，如果类似的请求多了，所有的处理线程处于阻塞的状态，那新的请求也就无法处理了，也就所谓影响了服务器的吞吐能力。要更加好地发挥服务器的全部性能，就要使用异步：

由于Spring MVC的良好封装，异步功能使用起来出奇的简单。传统的同步模式的Controller是返回ModelAndView，而异步模式则是返回DeferredResult<ModelAndView>。

springmvc3.2之后支持异步请求，能够在controller中返回一个Callable或者DeferredResult。当返回Callable的时候，大概的执行过程如下：

1. 当controller返回值是Callable的时候，springmvc就会启动一个线程将Callable交给TaskExecutor去处理

2. 然后DispatcherServlet还有所有的spring拦截器都退出主线程，然后把response保持打开的状态

3. 当Callable执行结束之后，springmvc就会重新启动分配一个request请求，获取异步执行的返回结果，然后返回视图

DeferredResult的执行过程和Callable差不多，唯一不同的时候，DeferredResult是由应用程序其他线程执行返回结果，而Callable是由TaskExecutor执行返回结果。

springmvc配置异步请求

1.需要在web.xml加上servlet3.0的scheme库

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"> ... </web-app>

2.在web.xml的servlet还有filter添加<asyncsupported>true</async-supported>子节点

<!-- springMVC的Servlet配置 -->
<servlet>
    <servlet-name>dispatcher</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath*:META-INF/dispatcher-context.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> <async-supported>true</async-supported> </servlet> <!-- 编码拦截 --> <filter> <filter-name>CharacterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <async-supported>true</async-supported> <init-param> <param-name>encoding</param-name> <param-value>UTF-8</param-value> </init-param> <init-param> <param-name>forceEncoding</param-name> <param-value>true</param-value> </init-param> </filter>

3.然后就可以在controller中执行异步请求了

利用Callable执行异步请求，并返回视图

@RequestMapping("/mvc25")
public Callable<String> mvc25() {

    return new Callable<String>() { @Override public String call() throws Exception { Thread.sleep(2000); return "task/task"; } }; }

利用Callable执行异步请求，并把请求结果通过@response由httpmessageconverter进行转化返回客户端

@RequestMapping("/mvc26")
@ResponseBody
public Callable<String> mvc26() { return new Callable<String>() { @Override public String call() throws Exception { Thread.sleep(2000); return "hello task"; } }; }

可以自定义客户端超时间

@RequestMapping("/mvc27")
@ResponseBody
public WebAsyncTask<String> mvc27() { Callable<String> callable = new Callable<String>() { @Override public String call() throws Exception { Thread.sleep(10000); return "hello task"; } }; return new WebAsyncTask<String>(10000, callable); }

如果在线程的执行过程中，遇到异常，处理过程和普通请求的一样，你可以用@ExceptionHandler来处理或者定义全局的HandlerExceptionResolver来处理

@RequestMapping("/mvc28")
@ResponseBody
public Callable<String> mvc28() { Callable<String> callable = new Callable<String>() { @Override public String call() throws Exception { Thread.sleep(2000); throw new RuntimeException(); } }; return callable; } @ExceptionHandler(RuntimeException.class) @ResponseBody public JSONObject handlerException(){ JSONObject jsonObject = new JSONObject(); jsonObject.put("aaa", 123); return jsonObject ; }

还可以通过返回DeferredResult返回，DeferredResult的作用是返回一个实例给其他线程来处理这个异步请求。

@RequestMapping("/mvc29")
@ResponseBody
public DeferredResult<String> mvc29() { DeferredResult<String> deferredResult = new DeferredResult<String>(); dealInOtherThread(deferredResult); return deferredResult; } private void dealInOtherThread(DeferredResult<String> deferredResult) { try { Thread.sleep(2000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } deferredResult.setResult("hello task"); }

dealInOtherThread处理完成，setResult的时候就会触发springmvc分配一个request到DispatcherServlet，然后DispatcherServlet处理DeferredResult的返回结果，并返回视图。

DeferredResult还提供了其他返回来处理线程请求，例如onTimeout(Runnable) 还有onCompletion(Runnable)，onTimeout可以注册一个线程回调，当请求延时的时候的回调函数，onCompletion可以注册一个请求完成的回调函数。

WebAsyncTask 超时处理：

@RequestMapping(value="/longtimetask", method = RequestMethod.GET)
public WebAsyncTask longTimeTask(){
    System.out.println("/longtimetask被调用 thread id is : " + Thread.currentThread().getId());
    Callable<ModelAndView> callable = new Callable<ModelAndView>() {
        public ModelAndView call() throws Exception {
            Thread.sleep(3000); //假设是一些长时间任务
            ModelAndView mav = new ModelAndView("longtimetask");
            mav.addObject("result", "执行成功");
            System.out.println("执行成功 thread id is : " + Thread.currentThread().getId());
            return mav;
        }
    };
 
    WebAsyncTask asyncTask = new WebAsyncTask(2000, callable);
    asyncTask.onTimeout(
            new Callable<ModelAndView>() {
                public ModelAndView call() throws Exception {
                    ModelAndView mav = new ModelAndView("longtimetask");
                    mav.addObject("result", "执行超时");
                    System.out.println("执行超时 thread id is ：" + Thread.currentThread().getId());
                    return mav;
                }
            }
    );
    return asyncTask ;

超时归超时，超时并不会打断正常执行流程，但注意，出现超时后我们给客户端返回了“超时”的结果，那接下来即便正常处理流程成功，客户端也收不到正常处理成功所产生的结果了，这带来的问题就是：客户端看到了“超时”，实际上操作到底有没有成功，客户端并不知道，但通常这也不是什么大问题，因为用户在浏览器上再刷新一下就好了
}