Class AsyncEvent，Servlet3.0新特性—异步支持

发表回复

Class AsyncEvent，Servlet3.0新特性—异步支持…

1.servlet2.5中，页面发送一次请求，是顺序执行，即使在servlet里的service中开启一个线程，线程处理后的结果是无法返回给页面的，servlet执行完毕后，response就关闭了，无法将后台更新数据即时更新到页面端

2.现在后台“推”是怎么实现的
2.1定时发送请求，页面有刷新，不好友

2.2Ajax 轮询，然后通过js更新页面数据
相比前者虽然友好，访问量太大时，服务器会增加压力，小型应用可以考虑用

2.3反向Ajax(Comnet)
利用Http1.1长连接的特性，也是通过轮询，但是每次发送请求不会立即返回，而是等待服务器有数据时才返回或者没有等到数据而连接超时返回，相比于ajax轮询，减少了服务端压力，但一个缺点，不是所有浏览器都支持。

3.servlet3.0中提供了异步支持，当数据返回页面后，request并没有关闭，当服务器端有数据更新时，就可以推送了

4.更多关于web异步，请参考这边文章 http://blog.csdn.net/cenwenchu79/article/details/5703430

5.测试servlet3.0异步
SecondServlet.java

Java代码  收藏代码
  1. package com.darren.servlet;
  3. import java.io.IOException;
  4. import java.io.PrintWriter;
  5. import java.util.Date;
  7. import javax.servlet.AsyncContext;
  8. import javax.servlet.AsyncEvent;
  9. import javax.servlet.AsyncListener;
  10. import javax.servlet.ServletException;
  11. import javax.servlet.annotation.WebServlet;
  12. import javax.servlet.http.HttpServlet;
  13. import javax.servlet.http.HttpServletRequest;
  14. import javax.servlet.http.HttpServletResponse;
  17. /**
  18.  * servlet3.0默认是不支持异步的通过asyncSupported=true,打开
  19.  *
  20.  */
  21. @WebServlet(name=”SecondServlet”,urlPatterns={“/secondServlet”},asyncSupported=true)
  22. public class SecondServlet extends HttpServlet {
  24.     @Override
  25.     protected void doGet(HttpServletRequest req, HttpServletResponse resp)
  26.             throws ServletException, IOException {
  27.         PrintWriter out = null;
  29.         resp.setContentType(“text/html”);
  30.         try {
  31.             out = resp.getWriter();
  32.             out.print(“servlets starts:”+new Date()+”<br>”);
  33.             out.flush();
  35.             AsyncContext asyncContext = req.startAsync();
  39.             /**
  40.              * AsyncListener为什么没有适配器呢？需要各个厂家实现？
  41.              */
  42.             asyncContext.addListener(new AsyncListener(){
  44.                 public void onComplete(AsyncEvent asyncEvent) throws IOException {
  45.                     //将流在这里关闭
  46.                     asyncEvent.getSuppliedResponse().getWriter().close();
  47.                     System.out.println(“asynContext finished….”);
  48.                 }
  50.                 public void onError(AsyncEvent arg0) throws IOException {
  51.                     // TODO Auto-generated method stub
  53.                 }
  55.                 public void onStartAsync(AsyncEvent arg0) throws IOException {
  56.                     // TODO Auto-generated method stub
  58.                 }
  60.                 public void onTimeout(AsyncEvent arg0) throws IOException {
  61.                     // TODO Auto-generated method stub
  63.                 }
  65.             });
  69.             new Thread(new MyThread(asyncContext)).start();
  71.             out.print(“servlets ends:”+new Date()+”<br>”);
  72.             out.flush();
  74.         } finally {
  76.             /**
  77.              * 一开是在这里关闭了,关了,后面就用不成了 :）
  78.              *
  79.              */
  81.             /*if(null != out){
  82.                 out.close();
  83.                 out = null;
  84.             }*/
  85.         }
  87.     }
  88. }

 

MyThread.java

Java代码  收藏代码
  1. package com.darren.servlet;
  3. import java.io.IOException;
  4. import java.io.PrintWriter;
  5. import java.util.Date;
  7. import javax.servlet.AsyncContext;
  9. public class MyThread implements Runnable {
  11.     private AsyncContext asyncContext;
  14.     public MyThread(AsyncContext asyncContext) {
  15.         this.asyncContext = asyncContext;
  16.     }
  19.     public void run() {
  21.         PrintWriter out = null;
  23.         try {
  24.             try {
  25.                 Thread.sleep(10000);
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.             out = asyncContext.getResponse().getWriter();
  30.             out.println(“myTask starts:”+new Date()+”<br>”);
  31.             out.flush();
  34.             out.print(“myTask ends:”+new Date()+”<br>”);
  35.             out.flush();
  36.             asyncContext.complete();
  38.         } catch (IOException e) {
  39.             e.printStackTrace();
  40.         }finally{
  42.             /*if(null != out){
  43.                 out.close();
  44.                 out = null;
  45.             }*/
  46.         }
  47.     }
  49. }

 

主要是这个对象AsyncContext,参考J2EE6 API吧

来源：http://darrendu.iteye.com/blog/1444464 本文链接地址: Class AsyncEvent，Servlet3.0新特性—异步支持

No related posts.