理解Spring MVC中的异步处理请求（上）

最新推荐文章于 2024-09-10 17:26:31 发布
最新推荐文章于 2024-09-10 17:26:31 发布
阅读量813 收藏 2
点赞数
分类专栏： SpringMVC 文章标签： n

理解Spring MVC中的异步处理请求（上）

 

运行环境声明

  • Java SE 8
  • Tomcat 8.5.5(Servlet 3.1)
  • Spring Framework 4.3.3.RELEASE

 

Spring MVC的两种异步处理方式

 

1.异步处理结束后才开始生成HTTP响应

这种方式是把耗时逻辑任务的执行与服务器的管理线程相分离，从而实现多线程的并行。因为HTTP响应在异步处理结束之后才生成，因此从客户端看来与同步处理无异。

2.在异步处理时已经开始生成HTTP响应

通过这种方式，可以在异步处理的任意时刻向客户端发送信息。显然，这种方式是基于HTTP/1.1的分块传输编码（Chunked transfer encoding），因此客户端必须支持分块传输编码。

本文将只说明第1种异步处理方式，第2种方式将放在下篇讲述。

 

Spring MVC的同步处理代码示例

package com.example.component;

import java.time.LocalDateTime;

public class Console {
    public static void println(Object target) {
        System.out.println(LocalDateTime.now() + " " + Thread.currentThread() + ": " + target);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

 

package com.example.component;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;

@Controller
@RequestMapping("/standard")
public class StandardController {

    @RequestMapping(method = RequestMethod.GET)
    public String get(@RequestParam(defaultValue = "0") long waitSec, Model model) {

        Console.println("Start get.");

        model.addAttribute("acceptedTime", LocalDateTime.now());

        heavyProcessing(waitSec, model);

        Console.println("End get.");

        return "complete";
    }

    private void heavyProcessing(long waitSec, Model model) {

        if (waitSec == 999) {
            throw new IllegalStateException("Special parameter for confirm error.");
        }

        try {
            TimeUnit.SECONDS.sleep(waitSec);
        } catch (InterruptedException e) {
            Thread.interrupted();
        }

        model.addAttribute("completedTime", LocalDateTime.now());

    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

  
complete.jsp文件放在Spring MVC默认的位置——/WEB-INF中。

<% //src/main/webapp/WEB-INF/complete.jsp %>
<%@ page import="com.example.component.Console" %>
<% Console.println("Called complete.jsp"); %>
<% Console.println(request.getDispatcherType()); %>

<html>
<body>
<h2>Processing is complete !</h2>
<p>Accept timestamp is ${acceptedTime}</p>
<p>Complete timestamp is ${completedTime}</p>
<p><a href="${pageContext.request.contextPath}/">Go to Top</a></p>
</body>
</html>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

  
因为Handler只返回一个逻辑视图名称，需要ViewResolver把该逻辑视图名称解析为真正的视图View对象。

package com.example.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@EnableWebMvc // 如果使用Spring Boot，不能加上这句，否则将导致AutoConfigure失效
@ComponentScan("com.example.component")
@Configuration
public class WebMvcConfig extends WebMvcConfigurerAdapter {
    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.jsp(); // 启用ViewResolver
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

  
使用CURL或者浏览器访问，将得到由complete.jsp生成的HTML代码。

$ curl -D - http://localhost:8080/standard?waitSec=1
  • 1

 

HTTP/1.1 200 
Set-Cookie: JSESSIONID=469B8E011EAE404434D889F2E20B1CFA;path=/;HttpOnly
Content-Type: text/html;charset=ISO-8859-1
Content-Language: ja-JP
Content-Length: 204
Date: Tue, 04 Oct 2016 15:22:48 GMT





<html>
<body>
<h2>Processing is complete !</h2>
<p>Accept timestamp is 2016-10-05T00:22:46.929</p>
<p>Complete timestamp is 2016-10-05T00:22:47.933</p>
<p><a href="/">Go to Top</a></p>
</body>
</html>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

服务器控制台的输出信息：

2016-10-05T00:22:46.929 Thread[http-nio-8080-exec-1,5,main]: Start get.
2016-10-05T00:22:47.933 Thread[http-nio-8080-exec-1,5,main]: End get.
2016-10-05T00:22:48.579 Thread[http-nio-8080-exec-1,5,main]: Called complete.jsp
2016-10-05T00:22:48.579 Thread[http-nio-8080-exec-1,5,main]: FORWARD
  • 1
  • 2
  • 3
  • 4

 

Spring MVC的异步处理代码示例

首先使用最普通的方法 java.util.concurrent.Callable 实现多线程。

package com.example.component;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import java.time.LocalDateTime;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

@Controller
@RequestMapping("/async")
public class AsyncController {

    @RequestMapping(method = RequestMethod.GET)
    public Callable<String> get(@RequestParam(defaultValue = "0") long waitSec, Model model) {

        Console.println("Start get.");

        model.addAttribute("acceptedTime", LocalDateTime.now());

        // 在Callable的call方法内实现异步处理逻辑
        // 因为Callable是函数式接口，因此可以与Java8的lambda表达式隐式转换
        Callable<String> asyncProcessing = () -> {

            Console.println("Start Async processing.");

            heavyProcessing(waitSec, model);

            Console.println("End Async processing.");

            return "complete";
        };

        Console.println("End get.");

        return asyncProcessing;
    }

    private void heavyProcessing(long waitSec, Model model) {

        if (waitSec == 999) {
            throw new IllegalStateException("Special parameter for confirm error.");
        }

        try {
            TimeUnit.SECONDS.sleep(waitSec);
        } catch (InterruptedException e) {
            Thread.interrupted();
        }

        model.addAttribute("completedTime", LocalDateTime.now());

    }

    @ExceptionHandler(Exception.class)
    public String handleException() {
        return "error";
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64

  
同时需要配置DispatcherServlet和各种Filter支持异步处理。

<!-- src/main/webapp/WEB-INF/web.xml -->
<servlet>
    <servlet-name>appServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- ... -->
    <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>
    <!-- ... -->
</filter>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

  
此时，服务器的控制台信息将变为如下：

2016-10-05T00:28:24.161 Thread[http-nio-8080-exec-1,5,main]: Start get.
2016-10-05T00:28:24.163 Thread[http-nio-8080-exec-1,5,main]: End get.
2016-10-05T00:28:24.168 Thread[MvcAsync1,5,main]: Start Async processing.
2016-10-05T00:28:25.172 Thread[MvcAsync1,5,main]: End Async processing.
2016-10-05T00:28:25.663 Thread[http-nio-8080-exec-2,5,main]: Called complete.jsp
2016-10-05T00:28:25.663 Thread[http-nio-8080-exec-2,5,main]: FORWARD
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

从上面可以看出，异步处理部分不再由Tomcat的管理线程(http-nio-8080-exec-xx)执行，而交给Spring MVC专门生成的另一个新线程（MvcAsync1）。

 

使用线程池

上面的例子中，因为没有使用线程池，因此每次响应一个请求都要新创建一个线程来执行它，显得十分低效。

@EnableWebMvc //如果使用Spring Boot，不能加上这句，否则将导致AutoConfigure失效
@ComponentScan("com.example.component")
@Configuration
public class WebMvcConfig extends WebMvcConfigurerAdapter {
    // ...
    @Override
    public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
        configurer.setTaskExecutor(mvcAsyncExecutor()); // 自定义线程池
    }

    // 让Spring的DI容器来管理ThreadPoolTaskExecutor的生命周期
    @Bean
    public AsyncTaskExecutor mvcAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setMaxPoolSize(10);
        return executor;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

此时服务器的控制台输出信息为：

2016-10-05T00:35:20.574 Thread[http-nio-8080-exec-1,5,main]: Start get.
2016-10-05T00:35:20.576 Thread[http-nio-8080-exec-1,5,main]: End get.
2016-10-05T00:35:20.580 Thread[mvcAsyncExecutor-1,5,main]: Start Async processing.
2016-10-05T00:35:21.583 Thread[mvcAsyncExecutor-1,5,main]: End Async processing.
2016-10-05T00:35:22.065 Thread[http-nio-8080-exec-2,5,main]: Called complete.jsp
2016-10-05T00:35:22.065 Thread[http-nio-8080-exec-2,5,main]: FORWARD
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

异步处理线程变成了我们自己定义的mvcAsyncExecutor-1池化线程。

 

使用DeferredResult和@Async注解

如果不是以线程函数的返回值作为最终处理的结果，或者想更灵活地返回处理结果，而不必与线程函数的返回值绑定在一起，使编程更方便，可以考虑使用DeferredResult。同时DeferredResult可以注册超时时间和对应的超时返回结果，十分方便。只需将控制器的代码修改为：

@Controller
@RequestMapping("/async")
public class AsyncController {

    // ...

    @RequestMapping(path = "deferred", method = RequestMethod.GET)
    public DeferredResult<String> getReferred(@RequestParam(defaultValue = "0") long waitSec, Model model) {

        Console.println("Start get.");

        model.addAttribute("acceptedTime", LocalDateTime.now());

        // 超时时间为10s，超时返回"ERROR"。
        DeferredResult<String> deferredResult = new DeferredResult<>(10000, "ERROR");
        //要把该deferredResult的引用传给对应的异步函数处理
        asyncHelper.asyncProcessing(model, waitSec, deferredResult);

        Console.println("End get.");

        return deferredResult; // 注意：返回值是该DeferredResult
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
package com.example.component;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import org.springframework.ui.Model;
import org.springframework.web.context.request.async.DeferredResult;

import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;

@Component
public class AsyncHelper {

    @Async // 该注解十分方便，能使其变成异步函数（相当于一个线程的run函数）
    public void asyncProcessing(Model model, long waitSec, DeferredResult<String> deferredResult) {
        Console.println("Start Async processing.");

        sleep(waitSec);

        model.addAttribute("completedTime", LocalDateTime.now());

        deferredResult.setResult("complete"); // 此时就通知MVC异步处理已经完成，可以生成HTTP响应。因此后面的代码不会造成HTTP响应的延迟

        Console.println("End Async processing.");
    }

    private void sleep(long timeout) {
        try {
            TimeUnit.SECONDS.sleep(timeout);
        } catch (InterruptedException e) {
            Thread.interrupted();
        }
    }
}
胜佑
关注
专栏目录
详解Spring MVC的异步模式（高性能的关键）
08-31
本篇文章主要介绍了详解Spring MVC的异步模式（高性能的关键），小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringMVC的异步
梁老师教你编程序
12-20 2647
注意：在Controller中使用时，一定要注意做好接口的线程池隔离，让慢的接口使用固定数量的线程池， 否则从tomcat减少的线程会转移到应用里，导致拥塞，在部分接口下游异常的情况的情况下，会出现影响正常接口的服务.所以，需要注意的一个错误用法是，如果a方法调用它同类中的标注@Async的b方法，是不会异步执行的，因为从a方法进入调用的都是该类对象本身，不会进入代理类。1，@Async注解在使用时，如果不指定线程池的名称，则使用Spring默认的线程池，Spring默认的线程池为。
Spring MVC的异步模式（ResponseBodyEmitter、SseEmitter、StreamingResponseBody）
fyk的博客
09-10 1482
通过spring mvc异步接口，实现后端分段向前端发送信息。
SpringMVC异步处理
weixin_47404925的博客
09-18 947
SpringMVC异步处理：一般分两种处理方法 第一种是：局部异常处理，第二种是：全局异常处理 一、局部异常处理 在Controller层里面使用@ExceptionHandler注解：这种方式处理的异常只针对@ExceptionHandler所在的那个Controller方法，局限性比较大。对于Controller之外出现的异常无法处理。 在配置当前Controller的异常处理【-@ExceptionHandler[(可以指定处理的指定异常类.class)]】，对于文件上传的异常，默认这里是无法处理的
Spring mvc异步处理
art_code的博客
04-14 846
Spring mvc异步处理 基于Servlet3.0的异步处理，springmvc的异步处理 控制器返回callable， spring mvc异步处理，将callable提交到TaskExecutor 使用一个隔离线程进行执行 DispatcherServlet和所有的Filter退出web容器的线程，但是response保持打开状态 Callable返回结果， Sprin...
SpringMVC 如何实现异步处理
weixin_42225963的博客
07-16 583
SpringMVC 如何实现异步处理
详解spring mvc对异步请求的处理
08-31
Spring MVC从3.2版本开始，引入了对异步请求的支持，这主要建立在Servlet 3.0及其以上版本的异步处理功能之上。下面将详细介绍如何在Spring MVC中配置和实现异步请求。 ### 1. 配置Web应用以支持异步处理 首先，你...
最全的Spring MVC注解例子，异步请求，错误处理
01-11
在这个“最全的Spring MVC注解例子”中，我们将深入探讨Spring MVC的核心注解，以及如何实现异步请求处理和错误管理。 1. **Spring MVC核心注解** - `@Controller`：标记一个类为处理HTTP请求的控制器。这是Spring...
Spring MVC中处理ajax请求的跨域问题与注意事项详解
08-28
本文将深入探讨Spring MVC中处理Ajax跨域问题的方法以及需要注意的事项。 **为何出现跨域** 跨域是由浏览器的安全策略——同源策略（Same-origin policy）导致的。它限制了一个源（协议+域名+端口）的文档或脚本...
Spring MVC异步模式
08-14
最后，我们可以通过查看源码进一步理解Spring MVC异步处理的实现细节。`AsyncWebRequest`对象用于封装异步请求的信息，而`AsyncManager`提供了启动和结束异步操作的方法。在实际开发中，我们还可以自定义`...
spring mvc对异步请求的处理
weixin_33991727的博客
05-13 116
在spring mvc3.2及以上版本增加了对请求的异步处理，是在servlet3的基础上进行封装的。 1、修改web.xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="h
53SpringMVC异步处理
java1592724884的博客
09-15 218
SpringMVC 的控制器是单例的，这意味着对同一个类中的处理方法发送的所有请求，都会共享同一个实例，因此控制器方法不适合处理耗时的方法。 当控制器确实需要处理耗时方法时，建议采用异步方法来处理。即让控制器方法返回一个Callable对象，SpirngMVC 会启动新的线程来执行该Callable对象，而Callable对象的call方法的返回值才会被当成真正的处理方法返回值返回给DispatcherServlet，进而进行视图解析。 栗子： 用户请求url： /query?name=lyx&pr
Spring Web MVC：异步请求
听海边涛声
03-20 1055
Spring Web MVC：异步请求
springMVC异步调用
1663988740
06-26 249
异步调用 发送异步请求（回顾） <a href="javascript:void(0);" id="testAjax">访问controller</a> <script type="text/javascript" src="/js/jquery-3.3.1.min.js"></script> <script type="text/javascript"> $(function(){ $("#testAjax").click(fun
Spring MVC系列之异步请求
lonelymanontheway的博客
04-29 1759
DeferredResult、AsyncRestTemplate、WebClient、AsyncWebRequest、CallableProcessingInterceptor、DeferredResultProcessingInterceptor、CallableInterceptorChain、DeferredResultInterceptorChain、WebAsyncTask、WebAsyncManager、WebAsyncUtils、RequestMappingHandlerAdapter
springmvc异步处理请求
weixin_42145727的博客
05-26 572
springmvc异步处理请求的两种实现方式
SpringMVC异步处理的 5 种方式
程序之心
03-02 759
作者：丁仪 来源：https://chengxuzhixin.com/blog/post/SpringMVC-yi-bu-chu-li-de-5-zhong-fang-shi.html 前段时间研究了下 diamond 的原理，其中有个重要的知识点是长连接的实现，用到了 servlet 的异步处理。异步处理最大的好处是可以提高并发量，不阻塞当前线程。其实 Spring MVC 也支持了异步处理，本文记录下相关的技术点。 异步处理 demo 如果要启用异步返回，需要开启 @Enable...
SpringMVC异步处理learning
MICKEY@STUDY
03-12 366
web应用服务器(tomcat等)的连接线程池实际上是有限制的；每一个连接请求都会耗掉线程池的一个连接数；倘若请求操作需要耗时，对连接长时间占用，就会导致所获取的这个连接无法及时被释放。如果此类连接数占用过多，服务器就很可能无法及时响应后续的每个请求。极端情况则有可能耗尽web应用服务器线程池的所有连接，导致服务“宕机”！！ 为解决耗时任务占用应用服务器连接数，而客户端又...
7、Spring MVC 之 处理异步请求
热门推荐
carl.zhao的专栏
08-04 2万+
Spring MVC 3.2开始引入Servlet 3中的基于异步的处理request.往常是返回一个值,而现在是一个Controller方法可以返回一个java.util.concurrent.Callable对象和从Spring MVC的托管线程生产返回值.同时Servlet容器的主线程退出和释放,允许处理其他请求。
怎样在Spring MVC中发送异步注册请求？
最新发布
10-23
在Spring MVC中发送异步注册请求，可以借助于第三方库如`Spring WebFlux`或者直接使用原生的`RestTemplate`配合WebClient（Spring 5.0及以上版本）。以下是使用WebClient的示例： 首先，你需要引入依赖： ```xml ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值