Servlet JSP Tutorial -- 1.14 Async Servlet Example

本是古典何须时尚 2022-06-01 00:42 156阅读 0赞

在 Servlet 3 中引入了异步 servlet。这是处理长时间运行线程的线程饥饿问题的好方法。

## Async Servlet ##

在我们了解什么是异步Servlet之前，让我们试着理解为什么我们需要它。

假设我们有一个需要花费大量时间的 Servlet，像下面这样。

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/LongRunningServlet?time=8000`的servlet，我们在秒后得到“Processing done for 8000 milliseconds!!”的响应。心在如果你查看服务器日期，你将会发现：

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 容器，这就是为什么在 Servlet 3.0 中添加了异步S ervlet 支持，为 servlet 中的异步处理提供标准方法的原因。

### Asynchronous Servlet Implementation ###

让我们看看实现异步servlet的步骤，然后我们将提供异步支持的 servlet 给上述栗子。

1.  首先，我们想要提供异步支持的 servlet 应该具有`@WebServlet`注释，`asyncSupported`值为`true`。
2.  由于实际的工作是委托给另一个线程的，我们应该有一个线程池的实现。我们可以使用`Executors`框架创建线程池，并使用servlet context listener 来启动线程池。
3.  我们需要通过`ServletRequest.startAsync()`方法获取`AsyncContext`的实例。`AsyncContext`提供了获取`ServletReques`t和`ServletResponse`对象引用的方法。它还提供了使用`dispatch()`方法将请求转发到另一个资源的方法。
4.  我们应该有一个`Runnable`实现，在这个实现中我们将执行繁重的处理，然后使用`AsyncContext`对象将请求分派到另一个资源或使用`ServletResponse`对象写入响应。一旦处理完成，我们应该调用`AsyncContext.complete()`方法让容器知道异步处理完成。
5.  我们可以将`AsyncListener`实现添加到`AsyncContex`t对象来实现回调方法 - 我们可以使用它来为异步线程处理时的错误或超时提供错误响应。我们也可以在这里做一些清理活动。

一旦我们完成我们的Async servlet示例项目，它将如下图所示。

### Initializing Worker Thread Pool in Servlet Context Listener ###

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();
        }
    
    }

实现非常简单，如果你不熟悉`Executors`框架，请阅读[Thread Pool Executor][]。

有关监听器的更多详细信息，请通过 [Servlet Listener Example][]。

### Worker Thread Implementation ###

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`的使用，以及它在获取请求和响应对象方面的用法，然后用`complete()`方法调用完成异步处理。

### AsyncListener Implementation ###

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");
        }
    
    }

注意我们向客户端发送超时响应的`onTimeout()`方法的实现。

### Async Servlet Example implementation ###

这里是我们的异步servlet的实现，请注意使用`AsyncContext`和T`hreadPoolExecutor`进行处理。

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 web application ###

现在，当我们运行servlet的URL为`http://localhost:8080/AsyncLongRunningServlet?time=8000`时，我们得到的响应和日志相同：

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

如果我们以9999的时间运行，会发生超时，客户端的响应是“TimeOut Error in Processing”和日志中的响应：

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线程快速完成执行，所有主要的处理工作正在其他线程中进行。

这就是 Async Servlet 的所有内容，我希望你喜欢它。

[Thread Pool Executor]: https://www.journaldev.com/1069/threadpoolexecutor-java-thread-pool-example-executorservice
[Servlet Listener Example]: http://blog.csdn.net/oktfolio/article/details/79019656