• servlet3.0 异步处理

    转：https://blog.csdn.net/benjamin_whx/article/details/38874657

    13.1、概述

    计算机的内存是有限的。Servlet/JSP容器的设计者很清楚这一点，因此他们提供了一些可以进行配置的设置，以确保容器能够在宿主机器中正常运行。例如，在Tomcat7中，处理进来请求的最多线程数量为200。如果是多处理器的服务器，则可以放心地增加线程数量，不过建议你还是尽量使用这个默认值。

    Servlet或Filter一直占用着请求处理线程，直到它完成任务。如果完成任务花费了很长时间，并发用户的数量就会超过线程数量，容器将会遇到超出线程的风险。如果发生这种情况，TOmcat就会将超出的请求堆放在一个内部服务器Socket中（其他容器的处理方式可能会有所不同）。如果继续进来更多的请求，它们将会遭到拒绝，直到有资源可以处理请求为止。

    异步处理特性可以帮助你节省容器线程。这项特性适用于长时间运行的操作。它的工作是等待任务完成，并释放请求处理线程，以便另一个请求能够使用该线程。注意，异步支持只适用于长时间运行的任务，并且你想让用户知道任务的执行结果。如果只有长时间运行的任务，但用户不需要知道处理的结果，那么则只要提供一个Runnable给Executor，并立即返回。例如，如果需要产生一份报表，并在保镖准备就绪之后通过电子邮件将报表发送出去，那么就不适合使用异步处理特性了。相反，如果需要产生一份报表，并且报表完成之后要展示给用户看，那么就可以使用异步处理。

    13.2、编写异步的Servlet和Filter

    WebServlet和WebFilter注解类型可以包含新的asyncSupport属性，为了编写能够支持异步处理的Servlet和Filter，asyncSupported属性必须设为true：

    @WebServlet(asyncSupported=true...)

    @WebFilter(asyncSupported=true...)

    另一种在配置文件中配置

    <servlet>

    <servlet-name>AsyncServlet</servlet-name>

    <servlet-class>servlet.MyAsyncServlet</servlet-class>

    </servlet>

    13.3、编写异步的Servlet

    编写异步的Serlvet或Filter相对比较简单。如果你有一个任务需要相对比较长时间才能完成，最好创建一个异步的Servlet或者Filter，在异步的Servlet或者Filter类中需要完成以下工作：

    1、在ServletRequest中调用startAsync方法。startAsync会返回一个AsyncContext。

    2、在AsyncContext中调用setTimeout()方法，设置一个容器必须等待指定任务完成的毫秒数。这个步骤是可选的，但是如果没有设置这个时限，将会采用容器的默认时间。如果任务没能在规定实限内完成，将会抛出异常。

    3、调用asyncContext.start方法，传递一个执行长时间任务的Runnable。

    4、任务完成时，通过Runnable调用asyncContext.complete方法或者asyncContext.dispatch方法。

    下面是异步Servlet的doGet或者doPost方法的主要内容：

    final AsyncContext asyncContext = servletRequest.startAsync();

    asyncContext.setTimeout( ... );

    asyncContext.start(new Runnable(){

    @Override

     public void run(){

    //long running task

    asyncContext.complete() or asyncContext.dispatch()

    }

    })

    下面是个例子：

    AsyncDispatchServlet.java

    1.  
      package servlet;
    2.  
       
    3.  
      import java.io.IOException;
    4.  
       
    5.  
      import javax.servlet.AsyncContext;
    6.  
      import javax.servlet.ServletException;
    7.  
      import javax.servlet.annotation.WebServlet;
    8.  
      import javax.servlet.http.HttpServlet;
    9.  
      import javax.servlet.http.HttpServletRequest;
    10.  
      import javax.servlet.http.HttpServletResponse;
    11.  
      @WebServlet(name="AsyncDispatchServlet",
    12.  
      urlPatterns={"/asyncDispatch"},
    13.  
      asyncSupported=true)
    14.  
      public class AsyncDispatchServlet extends HttpServlet {
    15.  
       
    16.  
      private static final long serialVersionUID = 1L;
    17.  
      @Override
    18.  
      public void doGet(final HttpServletRequest request,
    19.  
      HttpServletResponse response)
    20.  
      throws ServletException, IOException{
    21.  
      final AsyncContext asyncContext = request.startAsync() ;
    22.  
      request.setAttribute("mainThread", Thread.currentThread().getName());
    23.  
      asyncContext.setTimeout(5000);
    24.  
      asyncContext.start(new Runnable(){
    25.  
       
    26.  
      @Override
    27.  
      public void run() {
    28.  
      try {
    29.  
      Thread.sleep(3000);
    30.  
      } catch (InterruptedException e) {
    31.  
      e.printStackTrace();
    32.  
      }
    33.  
      request.setAttribute("workerThread", Thread.currentThread().getName());
    34.  
      asyncContext.dispatch("/ThreadNames.jsp");
    35.  
      }
    36.  
       
    37.  
      });
    38.  
      }
    39.  
      }


    ThreadNames.jsp

    1.  
      <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
    2.  
      <%
    3.  
      String path = request.getContextPath();
    4.  
      String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
    5.  
      %>
    6.  
       
    7.  
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    8.  
      <html>
    9.  
      <head>
    10.  
      <base href="<%=basePath%>">
    11.  
       
    12.  
      <title>Asynchronous Servlet</title>
    13.  
       
    14.  
      <meta http-equiv="pragma" content="no-cache">
    15.  
      <meta http-equiv="cache-control" content="no-cache">
    16.  
      <meta http-equiv="expires" content="0">
    17.  
      <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    18.  
      <meta http-equiv="description" content="This is my page">
    19.  
      <!--
    20.  
      <link rel="stylesheet" type="text/css" href="styles.css">
    21.  
      -->
    22.  
       
    23.  
      </head>
    24.  
       
    25.  
      <body>
    26.  
      Main Thread：${mainThread}
    27.  
      <br/>
    28.  
      Worker Thread：${workerThread}
    29.  
      </body>
    30.  
      </html>


    运行结果：

    下面这个例子的Servlet每秒钟发送一次进程更新，以便用户能够追踪进程。它发送HTML响应和一个简单的javaScript代码，用来更新一个HTML div元素。

    AsyncCompleteServlet.java

    1.  
      package servlet;
    2.  
       
    3.  
      import java.io.IOException;
    4.  
      import java.io.PrintWriter;
    5.  
       
    6.  
      import javax.servlet.AsyncContext;
    7.  
      import javax.servlet.ServletException;
    8.  
      import javax.servlet.http.HttpServlet;
    9.  
      import javax.servlet.http.HttpServletRequest;
    10.  
      import javax.servlet.http.HttpServletResponse;
    11.  
       
    12.  
      public class AsyncCompleteServlet extends HttpServlet {
    13.  
       
    14.  
      private static final long serialVersionUID = 1L;
    15.  
       
    16.  
      @Override
    17.  
      public void doGet(HttpServletRequest request, HttpServletResponse response)
    18.  
      throws ServletException, IOException {
    19.  
      response.setContentType("text/html");
    20.  
      final PrintWriter writer = response.getWriter() ;
    21.  
      writer.println("<html><head><title>" +
    22.  
      "Async Servlet</title></head>");
    23.  
      writer.println("<body><div id='progress'></div>");
    24.  
      final AsyncContext asyncContext = request.startAsync() ;
    25.  
      asyncContext.setTimeout(60000);
    26.  
      asyncContext.start(new Runnable(){
    27.  
       
    28.  
      @Override
    29.  
      public void run() {
    30.  
      System.out.println("new thread:" + Thread.currentThread());
    31.  
      for(int i=0; i<10; i++){
    32.  
      writer.println("<script>");
    33.  
      writer.println("document.getElementById(" +
    34.  
      "'progress').innerHTML = '" +
    35.  
      (i*10) + "% complete'");
    36.  
      writer.println("</script>") ;
    37.  
      writer.flush();
    38.  
      try {
    39.  
      Thread.sleep(1000);
    40.  
      } catch (InterruptedException e) {
    41.  
      e.printStackTrace();
    42.  
      }
    43.  
      }
    44.  
      writer.println("<script>");
    45.  
      writer.println("document.getElementById(" +
    46.  
      "'progress').innerHTML='DONE'");
    47.  
      writer.println("</script>");
    48.  
      writer.println("</body></html>");
    49.  
      asyncContext.complete();
    50.  
      }
    51.  
       
    52.  
      });
    53.  
      }
    54.  
      }


    部署配置文件

    1.  
      <?xml version="1.0" encoding="UTF-8"?>
    2.  
      <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
    3.  
      <display-name>AsyncServlet</display-name>
    4.  
      <servlet>
    5.  
      <servlet-name>AsyncComplete</servlet-name>
    6.  
      <servlet-class>servlet.AsyncCompleteServlet</servlet-class>
    7.  
      <async-supported>true</async-supported>
    8.  
      </servlet>
    9.  
      <servlet-mapping>
    10.  
      <servlet-name>AsyncComplete</servlet-name>
    11.  
      <url-pattern>/asyncComplete</url-pattern>
    12.  
      </servlet-mapping>
    13.  
      </web-app>

    运行结果：

    13.4、异步监听器

    除了支持Servlet和Filter执行异步操作之外，Servlet3.0还新增了一个AsyncListener接口，以便通知用户在异步处理期间发生的情况。AsyncListener接口定义了以下方法，当某个事件发生时，其中某一个方法就会被调用。

    void onStartAsync(AsyncEvent event)

    在刚启动一个异步操作时调用这个方法

    void onComplete(AsyncEvent event)

    当一个异步操作已经完成时调用这个方法

    void onError(AsyncEvent event)

    当一个异步操作失败时调用这个方法

    void onTimeout(AsyncEvent event)

    当一个异步操作已经超时的时候调用这个方法，即当它没能在规定时限内完成的时候。

    这4个方法都会收到一个AsyncEvent事件，你可以分别通过调用它的getAsyncContext、getSuppliedReqeust和getSuppliedResponse方法从中获得相关的AsyncContext、ServletRequest和ServletResponse实例。

    下面的例子和其他Web监听器不同的是，它没有用@WebListener标注AsyncListener的实现。

    MyAsyncListener.java

    1.  
      package listener;
    2.  
       
    3.  
      import java.io.IOException;
    4.  
       
    5.  
      import javax.servlet.AsyncEvent;
    6.  
      import javax.servlet.AsyncListener;
    7.  
       
    8.  
      public class MyAsyncListener implements AsyncListener{
    9.  
       
    10.  
      @Override
    11.  
      public void onComplete(AsyncEvent arg0) throws IOException {
    12.  
      // TODO Auto-generated method stub
    13.  
      System.out.println("MyAsyncListener.onComplete()");
    14.  
      }
    15.  
       
    16.  
      @Override
    17.  
      public void onError(AsyncEvent arg0) throws IOException {
    18.  
      // TODO Auto-generated method stub
    19.  
      System.out.println("MyAsyncListener.onError()");
    20.  
      }
    21.  
       
    22.  
      @Override
    23.  
      public void onStartAsync(AsyncEvent arg0) throws IOException {
    24.  
      // TODO Auto-generated method stub
    25.  
      System.out.println("MyAsyncListener.onStartAsync()");
    26.  
      }
    27.  
       
    28.  
      @Override
    29.  
      public void onTimeout(AsyncEvent arg0) throws IOException {
    30.  
      // TODO Auto-generated method stub
    31.  
      System.out.println("MyAsyncListener.onTimeout()");
    32.  
      }
    33.  
       
    34.  
      }


    AsyncListenerServlet.java

      1.  
        package servlet;
      2.  
         
      3.  
        import java.io.IOException;
      4.  
         
      5.  
        import javax.servlet.AsyncContext;
      6.  
        import javax.servlet.ServletException;
      7.  
        import javax.servlet.annotation.WebServlet;
      8.  
        import javax.servlet.http.HttpServlet;
      9.  
        import javax.servlet.http.HttpServletRequest;
      10.  
        import javax.servlet.http.HttpServletResponse;
      11.  
         
      12.  
        import listener.MyAsyncListener;
      13.  
        @WebServlet(name="AsyncListenerServlet",
      14.  
        urlPatterns={"/asyncListener"},
      15.  
        asyncSupported=true)
      16.  
        public class AsyncListenerServlet extends HttpServlet{
      17.  
         
      18.  
        private static final long serialVersionUID = 1L;
      19.  
         
      20.  
        @Override
      21.  
        public void doGet(final HttpServletRequest request, HttpServletResponse response)
      22.  
        throws ServletException, IOException {
      23.  
        final AsyncContext asyncContext = request.startAsync() ;
      24.  
        asyncContext.setTimeout(5000);
      25.  
        asyncContext.addListener(new MyAsyncListener());
      26.  
        asyncContext.start(new Runnable(){
      27.  
         
      28.  
        @Override
      29.  
        public void run() {
      30.  
        try {
      31.  
        Thread.sleep(3000);
      32.  
        } catch (InterruptedException e) {
      33.  
        e.printStackTrace();
      34.  
        }
      35.  
        String greeting = "hi from listener" ;
      36.  
        System.out.println("wait...");
      37.  
        request.setAttribute("greeting", greeting);
      38.  
        asyncContext.dispatch("/index.jsp");
      39.  
        }
      40.  
         
      41.  
        });
      42.  
        }
      43.  
        }
  • 相关阅读:
    scrapy学习（完全版）
    Python中模块与包的导入（朴实易懂版的总结）
    urllib.request.urlretrieve()用于下载制定url内容到本地
    IDEA自定义liveTemplates(方法模板、类模板)
    MySQL建表DDL规范(欢迎补充)
    15分钟搭建RocketMQ源码调试环境
    2500-使用MyBatis操作MySQL进行批量更新的注意事项
    手动注入bean到spring容器
    1000-ms-HashMap 线程安全安全问题
    1000-ms-maven相关问题
  • 原文地址：https://www.cnblogs.com/wangle1001986/p/9304594.html
Copyright © 2020-2023  润新知