jsp 异步处理

一. 概述

　　异步处理功能可以节约容器线程。你应该将此功能使用在长时间运行的操作上。此功能的作用是释放正在等待完成的线程，使该线程能够被另一请求所使用。

二. 编写异步Servlet和过滤器

　　WebServlet和WebFilter注解类型可能包含新的 asyncSupport属性。要编写支持异步处理的Servlet或过滤器，需设置asyncSupported属性为true：

@WebServlet(asyncSupported=true ...)

@WebFilter(asyncSupported=true ...)

　　此外，也可以在部署文件里面指定这个描述符。例如，下面的 Servlet 配置为支持异步处理：

<servlet>

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

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

<async-supported>true</async-supported>

</servlet>

　　Servlet或过滤器要支持异步处理，可以通过调用 ServletRequest的startAsync方法来启动一个新线程。这里有两个startAsync的重载方法：

AsyncContext startAsync() throws java.lang.IllegalStateExceptio

n

AsyncContext startAsync(ServletRequest servletRequest,

ServletResponse servletResponse) throws

java.lang.IllegalStateException

　　这两个重载方法都返回一个AsyncContext的实例，这个实例提供各种方法并且包含ServletRequest和 ServletResponse。第一个重载实例比较简单并且使用方便。由此生成的asynccontext实例将包含原生的 ServletRequest和ServletResponse。第二个允许您将原来的ServletRequest和ServletResponse进行重写封装后传给 asynccontext。需要注意的是，你只能传递原生的 ServletRequest和ServletResponse或它们的封装到 startAsync第二种重载实例。

　　注意，startAsync重复调用将返回相同的 asynccontext。若一个Servlet或过滤器调用startAsync时不支持异步处理，将抛出java.lang.illegalstateexception 异常。还请注意，asynccontext的start方法是非阻塞的，所以下一行代码仍将执行，即使还未调度线程启动。

三. 编写异步Servlets

　　写一个异步或异步Servlet或过滤器比较简单。当有一个需要相当长的时间完成的任务时，需要创建一个异步的Servlet或过滤器。在异步Servlet或过滤器类中需要做如下操作：

　　（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()

}

})

　　下面例子显示了支持异步处理的 Servlet。

AsyncDispatchServlet 类

package servlet;

import java.io.IOException;

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(name = "AsyncDispatchServlet", urlPatterns = { "/asyncDispatch" }, asyncSupported = true)

public class AsyncDispatchServlet extends HttpServlet {

    private static final long serialVersionUID = 222L;

    @Override

    public void doGet(final HttpServletRequest request, HttpServletResponse response)

            throws ServletException, IOException {

        final AsyncContext asyncContext = request.startAsync();

        request.setAttribute("mainThread", Thread.currentThread().getName());

        asyncContext.setTimeout();

        asyncContext.start(new Runnable() {

            @Override

            public void run() {

// long-running task

                try {

                    Thread.sleep();

                } catch (InterruptedException e) {

                }

                request.setAttribute("workerThread", Thread.currentThread().getName());

                // 调度到其它资源取完成任务 例如threadNames.jsp页面

                asyncContext.dispatch("/threadNames.jsp");

            }

        });

    }

}

这个Servlet支持异步处理且其长期运行的任务就是简单地休眠三秒钟。为了证明这个长时间运行的任务是在不同的线程中执行的，而不是在主线程中执行的（即执行 Servlet的doGet方法），它将主线程的名字和工作线程的ServletRequest分派到一个 threadNames.jsp页面。该threadNames.jsp页面显示mainThread和WorkerThread变量。它们应打印不同的线程名字。

threadNames.jsp页面

<%@ page language="java" contentType="text/html; charset=UTF-8"

    pageEncoding="UTF-8"%>

<!DOCTYPE html>

<html>

<head>

<meta charset="UTF-8">

<title>Insert title here</title>

</head>

<body>

mainThread: ${mainThread} <br />

workThread: ${workerThread}

</body>

</html>

注意，你需要在任务结束后调用asynccontext的 dispatch或complete，所以它不会等待，直到它超时。

你可以把你的这个URL输入到浏览器来测试 servlet：

　　上图显示了主线程的名称和工作线程的名称。你在你的浏览器中看到的可能是不同的，但打印出的线程名字会有所不同，证明了工作线程与主线程不同.

　　除了调度到其他资源去完成任务，你也可以调用 AsyncContext的complete方法。此方法通知servlet容器该任务已完成。

　　作为第二个例子，思考一下清单 AsyncCompleteServlet Servlet。该Servlet每秒发送一次进度更新，使用户能够监测进展情况。它发送HTML响应和一个简单的JavaScript代码来更新HTML div元素。

package servlet;

import java.io.IOException;

import java.io.PrintWriter;

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;

public class AsyncCompleteServlet extends HttpServlet {

    private static final long serialVersionUID = 78234L;

    @Override

    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        response.setContentType("text/html");

        final PrintWriter writer = response.getWriter();

        writer.println("<html><head><title>" + "Async Servlet</title></head>");

        writer.println("<body><div id='progress'></div>");

        final AsyncContext asyncContext = request.startAsync();

        asyncContext.setTimeout();

        asyncContext.start(new Runnable() {

            @Override

            public void run() {

                System.out.println("new thread:" + Thread.currentThread());

                for (int i = ; i < ; i++) {

                    writer.println("<script>");

                    writer.println("document.getElementById(" + "'progress').innerHTML = '" + (i * ) + "% complete'");

                    writer.println("</script>");

                    writer.flush();

                    try {

                        Thread.sleep();

                    } catch (InterruptedException e) {

                    }

                }

                writer.println("<script>");

                writer.println("document.getElementById(" + "'progress').innerHTML = 'DONE'");

                writer.println("</script>");

                writer.println("</body></html>");

                asyncContext.complete();

            }

        });

    }

}

部署描述符（web.xml文件）

<servlet>

      <servlet-name>AsyncComplete</servlet-name>

      <servlet-class>servlet.AsyncCompleteServlet</servlet-class>

      <async-supported>true</async-supported>

  </servlet>

  <servlet-mapping>

      <servlet-name>AsyncComplete</servlet-name>

      <url-pattern>/async-supported</url-pattern>

  </servlet-mapping>

四. 异步监听器

　　为支持Servlet和过滤器配合执行异步操作，Servlet 3.0还增加了asynclistener接口用于接收异步处理过程中发生事件的通知。AsyncListener接口定义了如下方法，当某些事件发生时调用：

void onStartAsync(AsyncEvent event)

在异步操作启动完毕后调用该方法

void onComplete(AsyncEvent event)

在异步操作完成后调用该方法。

void onError(AsyncEvent event)

在异步操作失败后调用该方法.

void onTimeout(AsyncEvent event)

在异步操作超时后调用该方法，即当它未能在指定的超时时间内完成时。

　　所有四种方法可以分别通过它们的 getAsyncContext、getSuppliedRequest和 getSuppliedResponse方法，从AsyncContext、 ServletRequest、ServletResponse中获取相关的 AsyncEvent。

　　这里有一个例子，MyAsyncListener类实现AsyncListener接口，以便在异步操作事件发生时，它能够得到通知。请注意，和其他网络监听器不同，你不需要通过@WebListener注解来实现。

package listener;

import java.io.IOException;

import javax.servlet.AsyncEvent;

import javax.servlet.AsyncListener;

// 不需要标注@WebListener

public class MyAsyncListener implements AsyncListener {

    @Override

    public void onComplete(AsyncEvent asyncEvent) throws IOException {

        System.out.println("onComplete");

    }

    @Override

    public void onError(AsyncEvent asyncEvent) throws IOException {

        System.out.println("onError");

    }

    @Override

    public void onStartAsync(AsyncEvent asyncEvent) throws IOException {

        System.out.println("onStartAsync");

    }

    @Override

    public void onTimeout(AsyncEvent asyncEvent) throws IOException {

        System.out.println("onTimeout");

    }

}

　　由于AsyncListener类不是用@WebListener注解的，因此必须为AsyncContext手动注册一个AsyncListener监听器，用于接收所需要的事件。通过调用addListener方法为AsyncContext注册一个AsyncListener监听器：

 Class lClass;

        try {

            lClass = Class.forName("listener.MyAsyncListener");

               AsyncListener al = asyncContext.createListener(lClass);

            asyncContext.addListener(al);

        } catch (ClassNotFoundException e1) {

            // TODO Auto-generated catch block

            e1.printStackTrace();

        }

使用asynclistener

package servlet;

import java.io.IOException;

import javax.servlet.AsyncContext;

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 listener.MyAsyncListener;

@WebServlet(name = "AsyncListenerServlet", urlPatterns = { "/asyncListener" }, asyncSupported = true)

public class AsyncListenerServlet extends HttpServlet {

    private static final long serialVersionUID = 62738L;

    @Override

    public void doGet(final HttpServletRequest request, HttpServletResponse response)

            throws ServletException, IOException {

        final AsyncContext asyncContext = request.startAsync();

        asyncContext.setTimeout();

         Class lClass;

        try {

            lClass = Class.forName("listener.MyAsyncListener");

               AsyncListener al = asyncContext.createListener(lClass);

            asyncContext.addListener(al);

        } catch (ClassNotFoundException e1) {

            // TODO Auto-generated catch block

            e1.printStackTrace();

        }

        asyncContext.start(new Runnable() {

            @Override

            public void run() {

                try {

                    Thread.sleep();

                } catch (InterruptedException e) {

                }

                String greeting = "hi from listener";

                System.out.println("wait....");

                request.setAttribute("greeting", greeting);

                asyncContext.dispatch("/test.jsp");

            }

        });

    }

}