`
dacoolbaby
  • 浏览: 1265873 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

[转]Servlet3特征 异步Servlet

    博客分类：
  • Java
javaservlet3
阅读更多

转自：http://www.importnew.com/8864.html

理解异步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/AsyncServletExample/LongRunningServlet?time=8000

 

得到响应为“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 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示例，项目结构看起来会像下面的图片：



 在监听中初始化线程池

 

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。

 

工作线程实现

 

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 实现

 

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进行处理。

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

得到响应和日志：

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，在客户端超时以后会得到响应超时错误处理和日志：
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

 

原文链接： journaldev 翻译： ImportNew.com - 彭秦进
译文链接： http://www.importnew.com/8864.html

 

  • 大小: 19.5 KB
分享到：
| 慎用堆表
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Servlet3.0新特性,Servlet3新特性,Servlet3注解,Servlet3异步处理【蕃薯耀】

    首先，Servlet3.0最显著的特征之一是广泛使用注解（Annotation）。传统的Servlet配置通常需要在web.xml文件中进行繁琐的手动设置。而Servlet3.0引入了如`@WebServlet`、`@WebFilter`和`@WebListener`等注解，允许...

    异步servlet

    异步Servlet是Java Servlet API的一个重要特性，它允许在Servlet容器中执行异步处理，显著提高了Web应用程序的性能和响应性。在传统的Servlet中，请求处理是同步的，即Servlet容器接收请求，调用Servlet的service...

    基于jsp+servlet+Ajax异步登陆模拟web项目

    【基于jsp+servlet+Ajax异步登陆模拟web项目】是一个典型的Web开发实例，它整合了三种核心技术：JavaServer Pages（JSP）、Servlet以及Asynchronous JavaScript and XML（Ajax）。这个项目的核心目的是实现用户登录...

    java servlet 3 异步调用 异步处理 注册监听

    在提供的`Servlet3_0_asyncDemo`压缩包文件中，可能包含了一个简单的异步处理示例。这个示例可能演示了如何创建一个Servlet，启用异步处理，启动异步上下文，并注册监听器来监控异步操作的生命周期。通过对这个示例...

    servlet3异步请求

    而Servlet3异步处理则改变了这种模式，请求处理可以被挂起，释放线程去处理其他请求，当后台任务完成后再回调，这样就避免了线程的长时间占用。 要开始使用Servlet3的异步请求，首先你需要一个支持Servlet 3.0及...

    浅谈servlet3异步原理与实践

    Servlet异步处理流程图.png 接收到request请求之后，由tomcat工作线程从HttpServletRequest中获得一个异步上下文AsyncContext对象，然后由tomcat工作线程把AsyncContext对象传递给业务处理线程，同时tomcat工作线程...

    Servlet3.0 异步处理 页面推送 Comet 实例

    首先，我们需要创建一个异步Servlet。在Servlet的`doGet`或`doPost`方法中，我们可以调用`AsyncContext.start()`来启动一个新的线程，这个线程将在后台执行耗时的操作。例如： ```java protected void doGet...

    servlet 3.0 异步 推送 聊天室

    Servlet 3.0引入了一种全新的特性，即异步处理能力，这极大地提高了Web应用程序的性能和响应性，尤其是在处理长时间运行的任务时。在传统的Servlet中，请求处理线程会一直占用，直到整个请求生命周期结束，这可能...

    Servlet图片批量上传ajax异步上传

    在IT行业中，Web开发是不可或缺的一部分，而Servlet、图片批量上传和Ajax异步技术则是构建高效、用户友好的Web应用的关键技术。以下是对这些知识点的详细说明： **Servlet上传** Servlet是Java EE平台中用于扩展...

    Spring Boot实现异步请求（Servlet 3.0）

    3. 使用 @EnableAsync 注解统一配置异步处理 4. 使用 AsyncContext 对象获取异步请求的上下文对象 5. 使用 setTimeout 方法设定最大超时时间 6. 使用两种方式测试异步任务：原生 Servlet 方式和 Spring Boot 自带的...

    3-6Tomcat处理源码实现与异步Servlet源码实现（1）.mp4

    3-6Tomcat处理源码实现与异步Servlet源码实现（1）.mp4

    正在研究servlet3的朋友们，有谁需要servlet3 api（英文版）的吗, 见附件

    Servlet3引入了异步处理能力，允许Servlet在接收到请求后启动一个异步操作，然后将控制权返回给容器。这使得开发者能够更好地处理长时间运行的任务，例如网络I/O或后台计算，而不会阻塞其他请求。 2. **注解驱动的...

    Servlet3-sources-code

    **Servlet3源码解析** Servlet技术是Java Web开发中的核心组件，它允许开发者编写服务器端程序来处理HTTP请求。Servlet3.0是Servlet规范的一个重要版本，引入了许多新特性和改进，大大提升了开发效率和应用的灵活性...

    servlet3 api 文档

    Servlet3 API文档是Java Web开发领域中的重要参考资料，它详细阐述了Servlet的相关接口、类以及方法，为开发者提供了全面的指南。Servlet技术是用于构建动态Web应用程序的核心组件，它允许服务器端处理HTTP请求并...

    Spring+ajax+servlet异步完成登录名是否存在

    本文将深入探讨如何使用Spring、Ajax和Servlet实现登录名存在的异步检查，从而在用户输入时实时验证用户名是否已被占用，避免用户等待服务器返回完整的登录页面。我们首先会介绍相关技术的基本概念，然后逐步解析...

    test-servlet3-without-webxml.rar

    在Servlet 3.0之前，我们通常需要一个`web.xml`部署描述符文件来配置Servlet，但在Servlet 3.0之后，我们可以实现"无web.xml"的部署方式，这就是`test-servlet3-without-webxml.rar`这个压缩包文件所体现的主题。...

    jquery+servlet 异步获取数据 并显示出来（很有收获的哦！）

    这篇博客"jquery+servlet 异步获取数据并显示出来"探讨了如何结合两者实现异步数据获取，提升用户体验。 首先，我们要理解什么是异步数据获取。在Web应用中，传统的同步方式会导致页面刷新，用户界面会暂时冻结，...

Magicbox
Global site tag (gtag.js) - Google Analytics