Servlet3.0的异步

servlet之前的操作同时同步的，就是按照这样的一个流程来走的：

1.请求根据一个路径路由到一个servlet中，

2.servlet获取一系列的参数

3.执行一系列的逻辑（花费时间所占的比重也更大）

4.返回结果

上面的问题出现在这一系列的操作都是同步的，所以这个请求必定是堵塞到所以任务都完成之后才返回的，

这样将会很浪费资源，因为线程堵塞在那里，仅仅是等待任务的完成。但是在servlet3.0之后，我们基本上可以

是这样做的

1.请求根据一个路径路由到一个servlet中，

2.将逻辑放入到异步队列中去

3.返回结果

4.异步队列处理任务，得出结果，返回给页面

而servet3.0对于异步的处理主要涉及的有两个特性，一个是新增的类AsyncContext，另外的一个就是asyncSupported属性

①如果我们想要让我们的servlet支持异步的话，那么asyncSupported这个属性是一定需要设置的，对于注解的类型来说，我们直接设置属性

@WebServlet(asyncSupported=true,urlPatterns={"/async"})

就可以了，对于老版本的配置问价来说，只需要在配置web.xml 的servlet那里增加一个

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

还有一个就是对于动态的servlet，设置

dynamic.setAsyncSupported(true);
就可以了②而对于AsyncContext 需要记住的东西还是蛮多的,但是它主要的是保留了请求和相应的引用，在前面提到的返回结果之后的操作就是通过在异步环境下，对这两个引用进行操作。

要获取这个就需要使用request在3.0之后增加的方法，startAsync(..) ，这个方法就是返回一个AsyncContext实体对象，这里包含了request和response的引用，至于我们异步的处理方式，就有很多种了，我们可以直接定义一个工作队列，异步的方式一个个的进行处理，又或者是直接使用AsyncContext.start(Runnable)方法启动一个新的线程去进行处理逻辑

AsyncContext主要的方法：getRequest（） 获得请求即request,我们可以在异步的环境像在service中使用一样

getReponse() 和上面差不多一个意思

hasOriginalRequestAndResponse（）这个方法表示的是我们使用的AsyncContext是使用原始的请求获取的，还是通过封装过的请求和相应创建的简单的讲就是 原始的类型表示的是调用startAsync()。但是封装的就是startAsync(ServletRequest, ServletResponse)或者其他类型啦，

dispatch()方法，这个方法有有好几个重载，表示的是转发，和req.getRequestDispatcher()有点类似，但是比较丰富如果使用的是startAsync(ServletRequest, ServletResponse)初始化AsyncContext，且传入的请求是HttpServletRequest的一个实例，则使用HttpServletRequest.getRequestURI()返回的URI进行分派。否则分派的是容器最后分派的请求URI。下面的代码是网上的：
// 请求到 /url/A
AsyncContext ac = request.startAsync();
...
ac.dispatch(); // 异步分派到 /url/A  

// 请求到 /url/A
// 转发到 /url/B
request.getRequestDispatcher(“/url/B”).forward(request, response);
// 从FORWARD的目标内启动异步操作
AsyncContext ac = request.startAsync();
ac.dispatch(); // 异步分派到 /url/A  

// 请求到 /url/A
// 转发到 /url/B
request.getRequestDispatcher(“/url/B”).forward(request, response);
// 从FORWARD的目标内启动异步操作
AsyncContext ac = request.startAsync(request, response);
ac.dispatch(); //异步分派到 /url/B

dispatch(String path) 这个方法就是转发到指定的url上去

complete()：在我们使用了request.startAsync(..)获得AsyncContext之后，在完成异步操作以后，需要调用这个方法结束异步的操作。如果请求分派到一个不支持异步操作的Servlet，或者由AsyncContext.dispatch调用的目标servlet之后没有调用complete，则complete方法会由容器调用。但是对于比合法操作来说，比如没有调用startAsync放方法，却代用complete() ,那么就会抛出IllegalStateException的异常，同时在调用complete()之前，调用dispath（）方法是不起作用的，当然了，因为这个时候异步还没结束嘛，当然不会又什么作用了。

setTimeOut(..) 设置超时的时间 表示的是异步处理的最大时间，如果是一个负数的话，那么表示永远不会超时

start(Runnable run) Runnable表示的就是异步处理的任务。我们在做的时候 会AsyncContext  带进去 因为所以的操作 都需要依靠他呢

addListener(AsyncListener listener);增加监听器  就是监听AsyncContext各种状态发现变化的，主要有

前面三个都比较好理解，最后异步监听器将以它们添加到请求时的顺序得到通知。

下面是AsyncContext的一般使用方式

package com.hotusm.servlet.async;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.TimeUnit;

import javax.servlet.AsyncContext;
import javax.servlet.AsyncEvent;
import javax.servlet.AsyncListener;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(urlPatterns={"/url"},asyncSupported=true)
public class AsynDemoServlet extends HttpServlet{

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //resp.setHeader("Connection", "Keep-Alive");
        resp.setContentType("text/html;charset=utf-8");

        System.out.println(req.isAsyncSupported()+"  "+req.isAsyncStarted());
        /*req.getAsyncContext(); 表示的是最近的那个被request创建或者是
         * 重转发的AsyncContext
        */

        final AsyncContext ac = req.startAsync();

            //设置超时的时间
            ac.setTimeout(5*1000L);

            //这种方式
            ac.start(new Runnable() {

                public void run() {

                    try {
                        TimeUnit.SECONDS.sleep(3L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    try {
                        PrintWriter writer = ac.getResponse().getWriter();
                        writer.write("1");
                        writer.flush();

                        //这是测试  同一个AsyncContext在没有调用complete 之前能不能多次的
                        //调用request 和response
                        PrintWriter writer1 = ac.getResponse().getWriter();
                        writer1.write("2");
                        writer1.flush();

                        ServletRequest request = ac.getRequest();

                        request.setAttribute("isAsyn", true);

                        /*
                         * 2.在调用完complete之后 表示这个异步已经结束了 如果在调用
                         * getRequest 或者是getResponse的话 都会抛出IllegalStateException
                         *
                         * */
                        ac.complete();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        //设置监听
        ac.addListener(new AsyncListenerImpl());

        // 在同一个request中不能同时调用多次
        //req.startAsync();
        PrintWriter out = resp.getWriter();
        out.write("hello async");
        out.write("<br/>");
        //调用flush 不然还是不会输出  因为没有将内容刷出去
        out.flush();
    }

    static class AsyncListenerImpl implements AsyncListener{

        public void onComplete(AsyncEvent event) throws IOException {

            System.out.println("onComplete");
        }

        public void onTimeout(AsyncEvent event) throws IOException {
            System.out.println("onTimeout");
            event.getAsyncContext().complete();
        }

        public void onError(AsyncEvent event) throws IOException {
            System.out.println("onError");
        }

        public void onStartAsync(AsyncEvent event) throws IOException {
            System.out.println("onStartAsync");
        }
    }
}

当我们上面的url的时候  会马上返回hello async,然后在大概三秒钟之后，输出12

上面的方式只是使用了start(Runnable run);的方式.我们也可以将AsyncContext放到一个工作队列中去，然后另外的一个线程池去做处理。

示例代码：

package com.hotusm.servlet.async;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Map;
import java.util.concurrent.LinkedBlockingQueue;

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={"/async1"},asyncSupported=true)
public class AsyncDispatchServlet1 extends HttpServlet{

    private LinkedBlockingQueue<AsyncContext> works=new LinkedBlockingQueue<AsyncContext>(100);

    @Override
    public void init() throws ServletException {　　   //因为这里是测试 所以就开了5个线程来进行处理  但是真实的情况下  肯定是设计一个伸缩性的方案
        new Thread(new HelperWork()).start();
        new Thread(new HelperWork()).start();
        new Thread(new HelperWork()).start();
        new Thread(new HelperWork()).start();
    }
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setHeader("Connection", "Keep-Alive");
        resp.addHeader("Cache-Control", "private");
        resp.addHeader("Pragma", "no-cache");
        resp.setContentType("text/html;charset=utf-8");
        try {
            works.put(req.startAsync());
        } catch (Exception e) {

        }
        PrintWriter writer = resp.getWriter();
        writer.write("等待异步完成");
        writer.flush();
    }

    private class HelperWork implements Runnable{

        public void run() {
            try {
                AsyncContext ac = works.take();

　　　　　　　　　　//模拟业务消耗
　　　　　　　　　　TimeUnit.SECONDS.sleep(2L)

HttpServletRequest request = (HttpServletRequest)ac.getRequest();

                Map<String, String[]> maps = request.getParameterMap();
                System.out.println(maps);

                HttpServletResponse response = (HttpServletResponse)ac.getResponse();
                PrintWriter writer = response.getWriter();
                writer.write(maps.toString());
                writer.flush();
                ac.complete();
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}

上面只是一种思路，我们还可以放入到线程池中进行处理等等。

然后再讲一下怎么通过ajax怎么异步的通信，我们只需要在第一次访问servlet的时候，保留AsyncContext的引用，之后通过这个的输出和页面做交互就可以了。





				


				
时间： 2024-10-11 19:59:10 

		


		


	

	
	

		


		
Servlet3.0的异步的相关文章


								

		

			

                Servlet3.0对异步处理的支持
			

		

		

									

				Servlet工作流程 Servlet 3.0 之前,一个普通 Servlet 的主要工作流程大致如下: Servlet 接收到请求之后,可能需要对请求携带的数据进行一些预处理: 调用业务接口的某些方法,以完成业务处理: 最后,根据处理的结果提交响应,Servlet 线程结束. servlet是单例多线程的,当servlet线程池满了的时候,后续访问该Servlet的请求只能进行等待 其中第二步的业务处理通常是最耗时的,这主要体现在数据库操作,以及其它的跨网络调用等,在此过程中,Servlet			

		

	

				

		

			

                [Servlet3.0]Servlet异步处理
			

		

		

									

				所谓异步处理就是指数据发送方发送数据给数据接收方后,不必等待数据接收方作出响应,可以继续发送下一个数据的通信方式. Servlet 3.0版本提供了相关异步处理的功能,具体实现方式如下: 需要使用注解在对应Servlet配置asyncSupported=true,表示当前Servlet支持异步. 通过Request对象的startAsync(Request, Response)方法获取异步上下文对象. 通过异步上下文对象调用start(new Runnable(){})方法开始异步处理,Runn			

		

	

				

		

			

                Servlet3.0中的异步请求
			

		

		

									

				package com.itheima.async; import java.io.IOException; import javax.servlet.AsyncContext; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; i			

		

	

				

		

			

                Servlet 3.0 对异步处理的支持
			

		

		

									

				Servlet 3.0 实现了对异步处理的支持 通过利用注解@WebServlet(urlPatterns="/AServlet" AysnsSupported=true) 让后new一个上下文对象 代码如下 AsyncContext ac= request.startAysnc(request,response) 传入一个Runnable  对象 ac.start(new Runnable(){ // 加入代码 });   上述表示Servlet3.0 对异步处理的支持			

		

	

				

		

			

                Servlet3.0的新特性
			

		

		

									

				注意:Servlet3.0的项目一定要使用Tomcat7.0才能看到效果!! 1.新增标注支持     在Servlet3.0的部署描述文件web.xml的顶层标签<web-app>中有一个metadata-complete属性,如果把该属性的值设置为true,则容器在部署时只依赖于web.xml部署文件中的配置,会忽略所以的标注(同时也会跳过web-fragment.xml的扫描,即禁用可插性支持):如果把该属性的值设置为false或者不配置该属性,则表示启用标注支持和可插性支持.    			

		

	

				

		

			

                关于servlet3.0中的异步servlet
			

		

		

									

				刚看了一下维基百科上的介绍,servlet3.0是2009年随着JavaEE6.0发布的: 到现在已经有六七年的时间了,在我第一次接触java的时候(2011年),servlet3.0就已经出现很久了,但是到现在,里边的一些东西还是没有能够好好地了解一下 最近在研究java的长连接,在了解jetty中的continuations机制的时候也重新了解了一下servlet3.0中的异步servlet机制,通过看几个博客,加上自己的一些测试,算是搞明白了一些,在这里记录一下: 在服务器的并发请求数量比			

		

	

				

		

			

                servlet3.0 新特性——异步处理
			

		

		

									

				Servlet 3.0 之前,一个普通 Servlet 的主要工作流程大致如下: 首先,Servlet 接收到请求之后,可能需要对请求携带的数据进行一些预处理: 接着,调用业务接口的某些方法,以完成业务处理: 最后,根据处理的结果提交响应,Servlet 线程结束. 其中第二步的业务处理通常是最耗时的,这主要体现在数据库操作,以及其它的跨网络调用等,在此过程中,Servlet 线程一直处于阻塞状态,直到业务方法执行完毕.在处理业务的过程中,Servlet 资源一直被占用而得不到释放,对于并发较大			

		

	

				

		

			

                servlet3.0 异步处理
			

		

		

									

				转:https://blog.csdn.net/benjamin_whx/article/details/38874657 13.1.概述 计算机的内存是有限的.Servlet/JSP容器的设计者很清楚这一点,因此他们提供了一些可以进行配置的设置,以确保容器能够在宿主机器中正常运行.例如,在Tomcat7中,处理进来请求的最多线程数量为200.如果是多处理器的服务器,则可以放心地增加线程数量,不过建议你还是尽量使用这个默认值. Servlet或Filter一直占用着请求处理线程,直到它完成任务.			

		

	

				

		

			

                利用servlet3.0上传，纯原生上传，不依赖任何第三方包
			

		

		

									

				tomcat7里面自带的servlet3.0.jar,支持很多新特性,例如,annotation配置servlet,上传,异步等等.... 如果你的tomcat版本低于7的话,单独在项目中引入servlet3.0.jar的话,有可能会出错,具体没研究过,可能是不兼容吧.所以要使用servlet3.0新特性的话,尽量使用tomcat7 不多说了,贴上代码 @WebServlet(name = "uploadServlet", urlPatterns = "/uploadServ