Request异步请求处理PART2

为什么需要异步请求处理？

当客户端发送一个请求，服务端接受到这个请求，由于该请求在服务器端需要复杂或耗时比较长的处理，有时候需要开启其他线程进行请求的处理。

此时就可以通过使用异步请求处理的功能。

如何在Servlet中使用异步请求处理？

1.首先，在web.xml中的servlet中配置,如果有filter拦截到的servlet需要异步请求处理，则filter配置中也需要配置这个参数。这样才能支持异步请求处理。

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

2.通过request.startAsync()或request.startAsync(request, response)来初始化异步请求上下文对象AsyncContext。

AsyncContext asyncContextOriginal =request.startAsync();

AsyncContext asyncContextWapper =request.startAsync(request, response);

上面两种的取得AsyncContext的区别：

1.request.startAsync();使用的是原始的ServeltReqeust和ServletResponse对象，即没有使用ServletRequestWrapper或ServletResponseWrapper

实例，这样即使过滤器或者其他方面使用了包装器，得到的AsyncContext也是用原始的ServeltReqeust和ServletResponse对象，不会产生包装效果。

2.request.startAsync(request, response);则不一样，参数request，response可以是包装后的，产生包装效果。

3.AsyncContext 介绍

如果Servlet或过滤器的asyncSupported被标示为true，则它们支持异步请求处理，在不支持异步处理的Servlet或过滤器中调用startAsync（)，会抛出

IllegalStateException.

当在支持异步处理的Servlet或过滤器中调用请求对象的startAsync()方法时，该次请求会离开容器所分配的线程，这意味这必须响应处理流程会返回，也就是若有

过滤器，也会依序返回(也就是各自完成的doFilter()方法)，但最终的响应被延迟。

可以调用AsyncContext的complete()方法完成响应，而后调用forward()方法，将响应转发给别的Servlet/JSP处理。

或者直接使用AsyncContext.dispatcher()或AsyncContext.dispatcher(String path)方法转发。

不可同时调用complete和dispatcher方法

如果对AsyncContext的起始、完成、超时或错误发生等事件有兴趣，可以实现AsyncListener，使用AsyncContext的addListener()方法加入该监听器。

开启异步请求处理

1.filter中设置

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

<filter-mapping>
<filter-name>myFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter>
<filter-name>myFilter1</filter-name>
<filter-class>com.zghw.servlet.demo.MyFilter1</filter-class>
<async-supported>true</async-supported>
</filter>

2.servlet中设置

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

<servlet>
<servlet-name>myRequestServlet2</servlet-name>
<servlet-class>com.zghw.servlet.demo.MyRequestServlet2</servlet-class>
<load-on-startup>1</load-on-startup>
<async-supported>true</async-supported>
</servlet>
<servlet-mapping>
<servlet-name>myRequestServlet2</servlet-name>
<url-pattern>/myrs2/*</url-pattern>
</servlet-mapping>

主要功能代码

package com.zghw.servlet.demo;

import java.io.IOException;

import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
* 请求异步处理 可以先释放容器分配给请求的线程与相关资源，减轻系统负担，原先释放了容器所分配线程的请求。
* 其响应将被延后，可以在处理完成(例如长时间运算完成、所需资源以获得)时在对客户端进行响应。
*/
public class MyRequestServlet2 extends HttpServlet {
private static final long serialVersionUID = 1L;

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

boolean isAsyncStarted = request.isAsyncStarted();
f("当前请求是否开启异步？" + isAsyncStarted);
boolean isAsyncSupported = request.isAsyncSupported();
f("当前请求是否支持异步？" + isAsyncSupported);
if (!isAsyncStarted && isAsyncSupported) {
// 把这个请求放入到异步模式中，如多线程，使用原始的request和response即没有包装过的来初始化一个AsyncContext
// AsyncContext asyncContextOriginal =request.startAsync();
// 使用包装后的request和response初始化AsyncContext对象
final AsyncContext asyncContextWapper = request.startAsync(request,
response);
// asyncContextOrigin = request.getAsyncContext();
// 当请求参数时name=张三，使用request.startAsync();取得AsyncContext使用了没有包装的原始的ServeltReqeust和ServletResponse
// 得到的参数"张三"是乱码，没有使用MyServletRequestWrapper，虽然filter使用了但并不会起作用
// String
// name=asyncContextOriginal.getRequest().getParameter("name");

// 而使用request.startAsync(request,
// response);取得AsyncContext使用了包装后的ServeltReqeust和ServletResponse
// 解析中文参数"张三"时，使用了MyServletRequestWrapper来转换编码
String name = asyncContextWapper.getRequest().getParameter("name");

// 为请求异步处理添加一个事件监听器
asyncContextWapper.addListener(new MyAsyncListener(), request,
response);
// 设置超时时间单位毫秒
asyncContextWapper.setTimeout(5000);
// 设置一个线程任务到线程池中，并启动该线程异步处理任务
asyncContextWapper.start(new Runnable() {
@Override
public void run() {
try {
System.out.println("处理任务开始");
// 模拟任务
Thread.sleep(3000);
System.out.println("任务完成");

// 代表request对应的request中请求url或分发的url进行转发
// 如请求/url/A则转向这个URL，了解详情看这个方法上的注释
// asyncContextWapper.dispatch();

// 转发到对应的路径
asyncContextWapper
.dispatch("/myAsyncDispatcherServlet");

// 转发的目标路径在设置的ServletContext中
// asyncContextWapper.dispatch(getServletContext(),
// "/myAsyncDispatcherServlet");

// 设置异步请求完成，当进行了dispatch转发，这里就不能在使用complete()方法。
// asyncContextWapper.complete();
} catch (InterruptedException e) {
e.printStackTrace();
}

}
});
// 创建AsyncContext是否使用原始的ServletRequest和ServletResponse对象
boolean hasOriginal = asyncContextWapper
.hasOriginalRequestAndResponse();
f(hasOriginal);

f("" + name);
}
}

protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}

static void f(Object obj) {
System.out.println(obj);
}
}

异步处理监听器

package com.zghw.servlet.demo;

import java.io.IOException;

import javax.servlet.AsyncContext;
import javax.servlet.AsyncEvent;
import javax.servlet.AsyncListener;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

/**
* 请求异步处理监听器，监听异步处理启动、完成、超时或错误事件。
*
* @author zghw
*
*/
public class MyAsyncListener implements AsyncListener {
/**
* 请求异步处理启动时触发
*/
@Override
public void onStartAsync(AsyncEvent event) throws IOException {
System.out.println("MyAsyncListener onStartAsync");
ServletRequest req = event.getSuppliedRequest();
ServletResponse res = event.getSuppliedResponse();
AsyncContext asyncContext = event.getAsyncContext();
}

/**
* 请求异步完成后触发
*/
@Override
public void onComplete(AsyncEvent event) throws IOException {
System.out.println("MyAsyncListener onComplete");
AsyncContext asyncContext = event.getAsyncContext();
ServletRequest req = event.getSuppliedRequest();
ServletResponse res = event.getSuppliedResponse();
String contextPath = (String) req
.getAttribute(AsyncContext.ASYNC_CONTEXT_PATH);
f(contextPath);
String pathInfo = (String) req
.getAttribute(AsyncContext.ASYNC_PATH_INFO);
f(pathInfo);
String queryString = (String) req
.getAttribute(AsyncContext.ASYNC_QUERY_STRING);
f(queryString);
String requestURI = (String) req
.getAttribute(AsyncContext.ASYNC_REQUEST_URI);
f(requestURI);
String servletPath = (String) req
.getAttribute(AsyncContext.ASYNC_SERVLET_PATH);
f(servletPath);
}

/**
* 请求异步超时触发
*/
@Override
public void onTimeout(AsyncEvent event) throws IOException {
System.out.println("MyAsyncListener onTimeout");
}

/**
* 请求异步处理失败完成
*/
@Override
public void onError(AsyncEvent event) throws IOException {
System.out.println("MyAsyncListener onError");
}

static void f(Object obj) {
System.out.println(obj);
}
}

转发后的Servlet

package com.zghw.servlet.demo;

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("/myAsyncDispatcherServlet")
public class MyAsyncDispatcherServlet extends HttpServlet{
static void f(Object obj) {
System.out.println(obj);
}
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
AsyncContext asyncContext=request.getAsyncContext();
//请求异步dipatcher转发过来的无法获得AsyncContext中的request和response
//ServletRequest req = asyncContext.getRequest();
//ServletResponse res = asyncContext.getResponse();
}
}