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;  
2.   
3. import java.io.IOException;  
4. import java.io.PrintWriter;  
5. import java.util.Date;  
6.   
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;  
15.   
16.   
17. /** 
18.  * servlet3.0默认是不支持异步的通过asyncSupported=true,打开 
19.  *  
20.  */  
21. @WebServlet(name="SecondServlet",urlPatterns={"/secondServlet"},asyncSupported=true)  
22. public class SecondServlet extends HttpServlet {  
23.   
24.     @Override  
25.     protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
26.             throws ServletException, IOException {  
27.         PrintWriter out = null;  
28.           
29.         resp.setContentType("text/html");  
30.         try {  
31.             out = resp.getWriter();  
32.             out.print("servlets starts:"+new Date()+"<br>");  
33.             out.flush();  
34.               
35.             AsyncContext asyncContext = req.startAsync();  
36.               
37.               
38.           
39.             /** 
40.              * AsyncListener为什么没有适配器呢？需要各个厂家实现？ 
41.              */  
42.             asyncContext.addListener(new AsyncListener(){  
43.   
44.                 public void onComplete(AsyncEvent asyncEvent) throws IOException {  
45.                     //将流在这里关闭  
46.                     asyncEvent.getSuppliedResponse().getWriter().close();  
47.                     System.out.println("asynContext finished....");  
48.                 }  
49.   
50.                 public void onError(AsyncEvent arg0) throws IOException {  
51.                     // TODO Auto-generated method stub  
52.                       
53.                 }  
54.   
55.                 public void onStartAsync(AsyncEvent arg0) throws IOException {  
56.                     // TODO Auto-generated method stub  
57.                       
58.                 }  
59.   
60.                 public void onTimeout(AsyncEvent arg0) throws IOException {  
61.                     // TODO Auto-generated method stub  
62.                       
63.                 }  
64.                   
65.             });  
66.               
67.               
68.               
69.             new Thread(new MyThread(asyncContext)).start();  
70.               
71.             out.print("servlets ends:"+new Date()+"<br>");  
72.             out.flush();  
73.               
74.         } finally {  
75.               
76.             /** 
77.              * 一开是在这里关闭了,关了,后面就用不成了 :） 
78.              *  
79.              */  
80.               
81.             /*if(null != out){ 
82.                 out.close(); 
83.                 out = null; 
84.             }*/  
85.         }  
86.           
87.     }  
88. }  

 

  MyThread.java

Java代码   

1. package com.darren.servlet;  
2.   
3. import java.io.IOException;  
4. import java.io.PrintWriter;  
5. import java.util.Date;  
6.   
7. import javax.servlet.AsyncContext;  
8.   
9. public class MyThread implements Runnable {  
10.   
11.     private AsyncContext asyncContext;  
12.       
13.       
14.     public MyThread(AsyncContext asyncContext) {  
15.         this.asyncContext = asyncContext;  
16.     }  
17.   
18.   
19.     public void run() {  
20.           
21.         PrintWriter out = null;  
22.           
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();  
32.               
33.               
34.             out.print("myTask ends:"+new Date()+"<br>");  
35.             out.flush();  
36.             asyncContext.complete();  
37.               
38.         } catch (IOException e) {  
39.             e.printStackTrace();  
40.         }finally{  
41.               
42.             /*if(null != out){ 
43.                 out.close(); 
44.                 out = null; 
45.             }*/  
46.         }  
47.     }  
48.   
49. }  

 

主要是这个对象AsyncContext,参考J2EE6 API吧http://docs.oracle.com/javaee/6/api/