zoukankan      html  css  js  c++  java

  • Servlet 3特性：异步Servlet

    本文由 ImportNew - 彭秦进 翻译自 journaldev。欢迎加入翻译小组。转载请见文末要求。

    理解异步Servlet之前，让我们试着理解为什么需要它。假设我们有一个Servlet需要很多的时间来处理，类似下面的内容：

    LongRunningServlet.java

    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
    package com.journaldev.servlet;
     
    import java.io.IOException;
    import java.io.PrintWriter;
     
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
     
    @WebServlet("/LongRunningServlet")
    public class LongRunningServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
     
        protected void doGet(HttpServletRequest request,
                HttpServletResponse response) throws ServletException, IOException {
            long startTime = System.currentTimeMillis();
            System.out.println("LongRunningServlet Start::Name="
                    + Thread.currentThread().getName() + "::ID="
                    + Thread.currentThread().getId());
     
            String time = request.getParameter("time");
            int secs = Integer.valueOf(time);
            // max 10 seconds
            if (secs > 10000)
                secs = 10000;
     
            longProcessing(secs);
     
            PrintWriter out = response.getWriter();
            long endTime = System.currentTimeMillis();
            out.write("Processing done for " + secs + " milliseconds!!");
            System.out.println("LongRunningServlet Start::Name="
                    + Thread.currentThread().getName() + "::ID="
                    + Thread.currentThread().getId() + "::Time Taken="
                    + (endTime - startTime) + " ms.");
        }
     
        private void longProcessing(int secs) {
            // wait for given time before finishing
            try {
                Thread.sleep(secs);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
     
    }

    如果我们的URL是：http://localhost:8080/AsyncServletExample/LongRunningServlet?time=8000

    得到响应为“Processing done for 8000 milliseconds! !“。现在，如果你会查看服务器日志，会得到以下记录:

    1
    2
    LongRunningServlet Start::Name=http-bio-8080-exec-34::ID=103
    LongRunningServlet Start::Name=http-bio-8080-exec-34::ID=103::Time Taken=8002 ms.

    所以Servlet线程实际运行超过 8秒，尽管大多数时间用来处理其它Servlet请求或响应。

    这可能导致线程饥饿——因为我们的Servlet线程被阻塞，直到所有的处理完成。如果服务器的请求得到了很多过程，它将达到最大Servlet线程限制和进一步的请求会拒绝连接错误。

    Servlet 3.0之前，这些长期运行的线程容器特定的解决方案，我们可以产生一个单独的工作线程完成耗时的任务，然后返回响应客户。Servlet线程返回Servlet池后启动工作线程。Tomcat 的 Comet、WebLogic FutureResponseServlet 和 WebSphere Asynchronous Request Dispatcher都是实现异步处理的很好示例。

    容器特定解决方案的问题在于，在不改变应用程序代码时不能移动到其他Servlet容器。这就是为什么在Servlet3.0提供标准的方式异步处理Servlet的同时增加异步Servlet支持。

    实现异步Servlet

    让我们看看步骤来实现异步Servlet，然后我们将提供异步支持Servlet上面的例子：

    1. 首先Servlet,我们提供异步支持 Annotation @WebServlet  的属性asyncSupported 值为true。
    2. 由于实际实现委托给另一个线程，我们应该有一个线程池实现。我们可以一个通过Executors framework 创建线程池和使用servlet context listener来初始化线程池。
    3. 通过ServletRequest.startAsync方法获取AsyncContext的实例。AsyncContext提供方法让ServletRequest和ServletResponse对象引用。它还提供了使用调度方法将请求转发到另一个 dispatch() 方法。
    4. 编写一个可运行的实现,我们将进行重处理，然后使用AsyncContext对象发送请求到另一个资源或使用ServletResponse编写响应对象。一旦处理完成，我们通过AsyncContext.complete()方法通知容器异步处理完成。
    5. 添加AsyncListener实现AsyncContext对象实现回调方法，我们可以使用它来提供错误响应客户端装进箱的错误或超时，而异步线程处理。在这里我们也可以做一些清理工作。

    一旦我们将完成我们的项目对于异步Servlet示例，项目结构看起来会像下面的图片：

    在监听中初始化线程池

    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
    package com.journaldev.servlet.async;
     
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
     
    import javax.servlet.ServletContextEvent;
    import javax.servlet.ServletContextListener;
    import javax.servlet.annotation.WebListener;
     
    @WebListener
    public class AppContextListener implements ServletContextListener {
     
        public void contextInitialized(ServletContextEvent servletContextEvent) {
     
            // create the thread pool
            ThreadPoolExecutor executor = new ThreadPoolExecutor(100, 200, 50000L,
                    TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(100));
            servletContextEvent.getServletContext().setAttribute("executor",
                    executor);
     
        }
     
        public void contextDestroyed(ServletContextEvent servletContextEvent) {
            ThreadPoolExecutor executor = (ThreadPoolExecutor) servletContextEvent
                    .getServletContext().getAttribute("executor");
            executor.shutdown();
        }
     
    }

    实现很直接，如果你不熟悉ThreadPoolExecutor 框架请读线程池的ThreadPoolExecutor 。关于listeners 的更多细节，请阅读教程Servlet Listener。

    工作线程实现

    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
    package com.journaldev.servlet.async;
     
    import java.io.IOException;
    import java.io.PrintWriter;
     
    import javax.servlet.AsyncContext;
     
    public class AsyncRequestProcessor implements Runnable {
     
        private AsyncContext asyncContext;
        private int secs;
     
        public AsyncRequestProcessor() {
        }
     
        public AsyncRequestProcessor(AsyncContext asyncCtx, int secs) {
            this.asyncContext = asyncCtx;
            this.secs = secs;
        }
     
        @Override
        public void run() {
            System.out.println("Async Supported? "
                    + asyncContext.getRequest().isAsyncSupported());
            longProcessing(secs);
            try {
                PrintWriter out = asyncContext.getResponse().getWriter();
                out.write("Processing done for " + secs + " milliseconds!!");
            } catch (IOException e) {
                e.printStackTrace();
            }
            //complete the processing
            asyncContext.complete();
        }
     
        private void longProcessing(int secs) {
            // wait for given time before finishing
            try {
                Thread.sleep(secs);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    注意：在请求和响应时使用AsyncContext对象，然后在完成时调用 asyncContext.complete() 方法。

    AsyncListener 实现

    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
    package com.journaldev.servlet.async;
     
    import java.io.IOException;
    import java.io.PrintWriter;
     
    import javax.servlet.AsyncEvent;
    import javax.servlet.AsyncListener;
    import javax.servlet.ServletResponse;
    import javax.servlet.annotation.WebListener;
     
    @WebListener
    public class AppAsyncListener implements AsyncListener {
     
        @Override
        public void onComplete(AsyncEvent asyncEvent) throws IOException {
            System.out.println("AppAsyncListener onComplete");
            // we can do resource cleanup activity here
        }
     
        @Override
        public void onError(AsyncEvent asyncEvent) throws IOException {
            System.out.println("AppAsyncListener onError");
            //we can return error response to client
        }
     
        @Override
        public void onStartAsync(AsyncEvent asyncEvent) throws IOException {
            System.out.println("AppAsyncListener onStartAsync");
            //we can log the event here
        }
     
        @Override
        public void onTimeout(AsyncEvent asyncEvent) throws IOException {
            System.out.println("AppAsyncListener onTimeout");
            //we can send appropriate response to client
            ServletResponse response = asyncEvent.getAsyncContext().getResponse();
            PrintWriter out = response.getWriter();
            out.write("TimeOut Error in Processing");
        }
     
    }

    通知的实现在 Timeout()方法，通过它发送超时响应给客户端。

    Async Servlet 实现

    这是我们的异步Servlet实现，注意使用AsyncContext和ThreadPoolExecutor进行处理。

    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
    package com.journaldev.servlet.async;
     
    import java.io.IOException;
    import java.util.concurrent.ThreadPoolExecutor;
     
    import javax.servlet.AsyncContext;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
     
    @WebServlet(urlPatterns = "/AsyncLongRunningServlet", asyncSupported = true)
    public class AsyncLongRunningServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
     
        protected void doGet(HttpServletRequest request,
                HttpServletResponse response) throws ServletException, IOException {
            long startTime = System.currentTimeMillis();
            System.out.println("AsyncLongRunningServlet Start::Name="
                    + Thread.currentThread().getName() + "::ID="
                    + Thread.currentThread().getId());
     
            request.setAttribute("org.apache.catalina.ASYNC_SUPPORTED", true);
     
            String time = request.getParameter("time");
            int secs = Integer.valueOf(time);
            // max 10 seconds
            if (secs > 10000)
                secs = 10000;
     
            AsyncContext asyncCtx = request.startAsync();
            asyncCtx.addListener(new AppAsyncListener());
            asyncCtx.setTimeout(9000);
     
            ThreadPoolExecutor executor = (ThreadPoolExecutor) request
                    .getServletContext().getAttribute("executor");
     
            executor.execute(new AsyncRequestProcessor(asyncCtx, secs));
            long endTime = System.currentTimeMillis();
            System.out.println("AsyncLongRunningServlet End::Name="
                    + Thread.currentThread().getName() + "::ID="
                    + Thread.currentThread().getId() + "::Time Taken="
                    + (endTime - startTime) + " ms.");
        }
     
    }

    Run Async Servlet

    现在，当我们将上面运行servlet URL：

    http://localhost:8080/AsyncServletExample/AsyncLongRunningServlet?time=8000

    得到响应和日志：

    1
    2
    3
    4
    AsyncLongRunningServlet Start::Name=http-bio-8080-exec-50::ID=124
    AsyncLongRunningServlet End::Name=http-bio-8080-exec-50::ID=124::Time Taken=1 ms.
    Async Supported? true
    AppAsyncListener onComplete

    如果运行时设置time=9999，在客户端超时以后会得到响应超时错误处理和日志：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    AsyncLongRunningServlet Start::Name=http-bio-8080-exec-44::ID=117
    AsyncLongRunningServlet End::Name=http-bio-8080-exec-44::ID=117::Time Taken=1 ms.
    Async Supported? true
    AppAsyncListener onTimeout
    AppAsyncListener onError
    AppAsyncListener onComplete
    Exception in thread "pool-5-thread-6" java.lang.IllegalStateException: The request associated with the AsyncContext has already completed processing.
        at org.apache.catalina.core.AsyncContextImpl.check(AsyncContextImpl.java:439)
        at org.apache.catalina.core.AsyncContextImpl.getResponse(AsyncContextImpl.java:197)
        at com.journaldev.servlet.async.AsyncRequestProcessor.run(AsyncRequestProcessor.java:27)
        at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
        at java.lang.Thread.run(Thread.java:680)

    注意：Servlet线程执行完，很快就和所有主要的处理工作是发生在其他线程。

    这是所有异步Servlet内容，希望你喜欢它。下载 AsyncServletExample 工程

    原文链接： journaldev 翻译： ImportNew.com - 彭秦进
    译文链接： http://www.importnew.com/8864.html
    [ 转载请保留原文出处、译者和译文链接。]

    关于作者： 彭秦进
  • 相关阅读:
    php+Nginx 安装手册
    PostgreSQL 生成uuid
    登陆服务器错误： Disconnected:No supported authentication methods available
    安装Tengine
    netty解决方法 io.netty.util.IllegalReferenceCountException: refCnt: 0, increment: 1
    IntelliJ Idea 2016,2017,2018 注册码 免费激活方法
    jdbc连接"Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. The driver is automatically registered via the SPI and manual loading of the driv"
    mysql错误:you are using update mode and you tried to update a table without a where that uses a key column to disable safe mode
    spring介绍;安装;使用
    设置maven仓库阿里镜像
  • 原文地址：https://www.cnblogs.com/clds/p/5006572.html
Copyright © 2011-2022 走看看