Servlet3.0+Spring-Boot 测试新特性-异步处理Servlet、Filter

骑猪看日落 2021-08-26 21:54 408阅读 0赞

### 概念部分参考：[https://blog.csdn.net/qq\_24598601/article/details/82824937][https_blog.csdn.net_qq_24598601_article_details_82824937] ###

基于原文的一些问题，修复和改进了一些地方的描述和事例

### 一、浅谈Servlet     ###

在Servlet 3.0 之前，一个普通 Servlet 的主要工作流程大致如下：

![Servlet 的主要工作流程][Servlet]

其中黄色阶段通常是最耗时的，因为业务处理一般涉及数据库操作，还会受到网络等的影响，而在此过程中，Servlet 线程一直处于阻塞状态，直到业务处理完毕。在处理业务的过程中，Servlet 资源一直被占用而得不到释放，对于并发较大的应用，这有可能造成性能的瓶颈。对此，在以前通常是采用私有解决方案来提前结束 Servlet 线程，并及时释放资源。  
为解决这个问题，Servlet 3.0 就开始支持异步处理了，这与 Ajax 异步不一样，之前的 Servlet 处理流程可以调整为如下的过程：

![Servlet3.0 处理流程][Servlet3.0]

首先，Servlet 接收到请求之后，可能首先需要对请求携带的数据进行一些预处理；接着，Servlet 线程将请求转交给一个异步线程来执行业务处理，**线程本身返回至容器，此时 Servlet 还没有生成响应数据，异步线程处理完业务以后，可以直接生成响应数据（异步线程拥有 ServletRequest 和 ServletResponse 对象的引用）**，或者将请求继续转发给其它 Servlet。如此一来， Servlet 线程不再是一直处于阻塞状态以等待业务逻辑的处理，而是启动异步线程之后可以立即返回。

### 二、启用异步处理 ###

异步处理特性可以应用于 Servlet 和过滤器两种组件。在默认情况下，Servlet 和过滤器并没有开启异步处理特性，因为异步处理的工作模式和普通工作模式在实现上有着本质的区别，因此如果希望使用该特性，则必须按照如下的方式启用：

1. 在 web.xml 文件中启动  
  Servlet3.0 默认是没有 web.xml 文件的，但 Servlet3.0 也是支持 web.xml 文件的，较 Servlet之前的版本，Servlet 3.0 在 <servlet>和 <filter> 标签中增加了 <async-supported> 子标签，该标签默认是 false 。如果想启用异步支持，只需要置为 true 即可。例如：

<servlet> 
        <servlet-name>asynServlet</servlet-name> 
        <servlet-class>com.servlet.AsynServlet</servlet-class> 
        <async-supported>true</async-supported> 
    </servlet>
    
    <filter>
        <filter-name>asynFilter</filter-name>
        <filter-class>com.filter.AsynFilter</filter-class>
        <async-supported>true</async-supported>
    </filter>

2. 通过注解开启异步支持  
  Servlet 3.0 提供的 @WebServlet 和 @WebFilter 进行 Servlet 或 Filter 配置的情况，这两个注解都提供了 asyncSupported 属性，默认该属性的取值为 false。如果想启用异步支持，只需要置为 true 即可。例如：

@WebServlet(value="/asyn-servlet",asyncSupported=true)
    public class ServletAsyn extends HttpServlet {...}
    
    @WebFilter(value="/*",asyncSupported=true)
    public class FilterAsyn implements Filter {...}

###    三、异步处理的代码实现方式 ###

Servlet 和 Filter 使用异步支持的实现方式是一模一样的操作。这里只以 Servlet 的实现方式为例。

1. 模拟注册发信息到邮件的简单的异步处理 Servlet 示例代码：

package thinking.in.spring.boot;
    
    
    import javax.servlet.AsyncContext;
    import javax.servlet.AsyncEvent;
    import javax.servlet.AsyncListener;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    @WebServlet(value="/asyn-servlet",asyncSupported=true)
    public class ServletAsyn extends HttpServlet {
        private static final long serialVersionUID = 1L;
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            System.out.println("Servlet is start");
    
            //1.获得异步上下文对象
            AsyncContext asyncContext = request.startAsync();
            asyncContext.addListener(new AsyncListener() {
    
                @Override
                public void onTimeout(AsyncEvent event) throws IOException {
                    System.out.println("超时了：");
                    //做一些超时后的相关操作
                }
    
                @Override
                public void onStartAsync(AsyncEvent event) throws IOException {
                    // TODO Auto-generated method stub
                    System.out.println("线程开始");
                }
    
                @Override
                public void onError(AsyncEvent event) throws IOException {
                    System.out.println("发生错误：");
                }
    
                @Override
                public void onComplete(AsyncEvent event) throws IOException {
                    System.out.println("执行完成");
                    //这里可以做一些清理资源的操作
    
                }
            });
            
            //2.启动一个耗时的子线程
            ThreadTask tt = new ThreadTask(asyncContext);
            //3.可设置异步超时对象，需在启动异步上下文对象前设置
            /*
             * 设置超时后，若子线程的执行时间超过设置的描述，则会抛出异常：
             * 此时分2种情况：
             * 1、主线程中带有response write（"xxx"），则页面显示正常，展示xxx，但程序后台会报错
             * java.lang.IllegalStateException: The request associated with the AsyncContext has already completed processing.
             * 2、主线程中不带有response write输出内容，页面直接报错
             * 切记servlet主线程response write后，flush一次，否则也会报错
             *
             * 若设置的超时时间大于子线程的运行时间，则servlet正常执行，优先输出servlet主线程的response write，
             * 待子线程执行完后，展示输出子线程的内容，后续截图中会给出效果
             */
            asyncContext.setTimeout(100000);
            //4.开启异步上下文对象
            asyncContext.start(tt);
    
            //主线程结束向客户端发送消息
            System.out.println("currentThread = " + Thread.currentThread().getName() + "Servlet is end");
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().append("信息已发送到邮箱");
            response.getWriter().flush();
            //response.reset();
        }
    
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            doGet(request, response);
        }
    
    
    }

异步线程的执行类：

package thinking.in.spring.boot;
    
    import javax.servlet.AsyncContext;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpSession;
    import java.util.Date;
    
    public class ThreadTask implements Runnable{
    
        private AsyncContext ac;  //定义一个异步上下文
    
        public ThreadTask(AsyncContext ac) {
            super();
            this.ac = ac;
        }
    
        @Override
        public void run() {
            /*
             * 服务端异步典型应用是注册时向邮箱发送验证码
             */
            try {
                //进行异步的一些处理
                HttpServletRequest requst = (HttpServletRequest) ac.getRequest();
                HttpSession session = requst.getSession();
                System.out.println("asyn-task start" + new Date());
                for(int i=5;i>0; i--) {
                    System.out.println(i);
                    Thread.sleep(1000);
                }
                //将结果放到session等方式
                session.setAttribute("message", "This is the result of asyn");
                System.out.println("currentThread = " + Thread.currentThread().getName() + " asyn-task end" + new Date());
    
                //通知主线程已经处理完成
                /*
                 * 除了使用 ac.complete() 方法，结束这次异步处理，通知主线程及listener已经处理完
                 * 还可以使用 ac.dispatch() 方法重定向到一个页面
                 */
                ac.dispatch("/test");
                //ac.complete();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    }

由于是用spring-boot搭建的简单项目，所以 **/test** 跳转去了一个配置好的 RequestMapping，配置了一个简单的thymeleaf用作跳转页面。注：由于在springboot的框架内，所以需要加上 @ServletComponentScan 扫描 @WebServlet 注解  
主程序和maven配置如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
      </parent>
      <groupId>thinking-in-spring-boot</groupId>
      <artifactId>first-spring-boot-application</artifactId>
      <packaging>jar</packaging>
      <version>1.0.0-SNAPSHOT</version>
      <name>first-spring-boot-application</name>
      <url>http://maven.apache.org</url>
      <dependencies>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
          <version>2.0.2.RELEASE</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
    
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>3.8.1</version>
          <scope>test</scope>
        </dependency>
    
        <dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
          <version>1.16.10</version>
        </dependency>
      </dependencies>
    </project>

package thinking.in.spring.boot;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.web.servlet.ServletComponentScan;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.servlet.ModelAndView;
    
    import javax.servlet.http.HttpServletRequest;
    
    /**
     * Hello world!
     *
     */
    @Controller
    @SpringBootApplication
    @ServletComponentScan
    public class App
    {
    
        @RequestMapping("/")
        @ResponseBody
        public String index(){
            return "welcome zszhou";
        }
    
        public static void main( String[] args )
        {
            SpringApplication.run(App.class,args);
        }
    
    
        @GetMapping(value = "/test")
        public ModelAndView test(HttpServletRequest req) {
            // UserEntity userEntity = getCurrentUser(req);
            UserEntity user = new UserEntity();
            user.setLoginName("tom");
            user.setId(234);
            user.setBindType(1);
            ModelAndView mv = new ModelAndView();
            mv.addObject("user", user);
            mv.setViewName("/show.html");
            return mv;
        }
    }

目录结构：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70][]

show.html：

<!DOCTYPE html>
    <html xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>Show User</title>
    </head>
    <body>
    <table>
        <tr>
            <td>姓名</td>
            <td>密码</td>
        </tr>
        <tr>
            <td th:text="${user.loginName}"></td>
            <td th:text="${user.loginName}"></td>
        </tr>
    </table>
    </body>
    </html>

application.properties：

#spring.mvc.view.prefix=/WEB-INF/
    #spring.mvc.view.suffix=.jsp
    
    ###ThymeLeaf配置
    spring:
    thymeleaf:
    #模板的模式，支持 HTML, XML TEXT JAVASCRIPT
    mode: HTML5
    #编码 可不用配置
    encoding: UTF-8
    #内容类别,可不用配置
    content-type: text/html
    #开发配置为false,避免修改模板还要重启服务器
    cache: false
    #配置模板路径，默认是templates，可以不用配置
    prefix: classpath:/templates

**后台日志：明显看出是2个线程，servlet主线程和任务子线程。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70 1][]

访问：[http://127.0.0.1:8080/asyn-servlet?mmmm][http_127.0.0.1_8080_asyn-servlet_mmmm]

浏览器优先展示如下效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70 2][]

此时，浏览器还在加载中，5秒后，子任务完成，跳转至 /test 后，页面追加了 test中的html 内容：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70 3][]

这种方式类似于，可以提前输出实时的后台进度，拿上传文件打比方的话，可以在页面中显示  
1、上传中 ----------  
2、子任务文件实际传输中  
3、上传完成  
整个进度在浏览器中可以实时展现。。。。。。。。。

四、对异步处理过程的监听

除此之外，Servlet 3.0 还为异步处理提供了一个监听器，使用 AsyncListener 接口表示。它可以监控如下四种事件：  
（1）异步线程开始时，调用 AsyncListener 的 onStartAsync(AsyncEvent event) 方法；  
（2）异步线程出错时，调用 AsyncListener 的 onError(AsyncEvent event) 方法；  
（3）异步线程执行超时，则调用 AsyncListener 的 onTimeout(AsyncEvent event) 方法；  
（4）异步执行完毕时，调用 AsyncListener 的 onComplete(AsyncEvent event) 方法。  
  如果要注册一个 AsyncListener，只需将准备好的 AsyncListener 对象传递给 AsyncContext 对象的 addListener() 方法即可，如下所示：

AsyncContext ac = request.startAsync();
    ac.addListener(new AsyncListener() {
                @Override
                public void onComplete(AsyncEvent arg0) throws IOException {
                    // TODO Auto-generated method stub
                }
    
                @Override
                public void onError(AsyncEvent arg0) throws IOException {
                    // TODO Auto-generated method stub
                }
    
                @Override
                public void onStartAsync(AsyncEvent arg0) throws IOException {
                    // TODO Auto-generated method stub
                }
    
                @Override
                public void onTimeout(AsyncEvent arg0) throws IOException {
                    // TODO Auto-generated method stub
                }
                
            });

[https_blog.csdn.net_qq_24598601_article_details_82824937]: https://blog.csdn.net/qq_24598601/article/details/82824937
[Servlet]: /images/20210527/6d766bd8ded24cc8ac253dab9fdfed58.png
[Servlet3.0]: /images/20210527/3bad61a9e42b4d4995f44d505346bb29.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70]: /images/20210527/931ef6c8af274159b9fb02ac1d1992d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70 1]: /images/20210527/bfd5301819324c3fa905fb5c44147502.png
[http_127.0.0.1_8080_asyn-servlet_mmmm]: http://127.0.0.1:8080/asyn-servlet?mmmm
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70 2]: /images/20210527/ec3616b97ed7422fa837244bff77121d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70 3]: /images/20210527/e23d841ff56f40f68cf87a4b4bb572fd.png