servlet3.0 新特性——異步處理

Servlet 3.0 以前,一個普通 Servlet 的主要工做流程大體以下:html

首先,Servlet 接收到請求以後,可能須要對請求攜帶的數據進行一些預處理;java

接着,調用業務接口的某些方法,以完成業務處理;mysql

最後,根據處理的結果提交響應,Servlet 線程結束。web

其中第二步的業務處理一般是最耗時的,這主要體如今數據庫操做,以及其它的跨網絡調用等,在此過程當中,Servlet 線程一直處於阻塞狀態,直到業務方法執行完畢。在處理業務的過程當中,Servlet 資源一直被佔用而得不到釋放,對於併發較大的應用,這有可能形成性能的瓶頸。即便在業務類中開啓一個線程,線程處理後的結果是沒法返回給頁面的,由於servlet執行完畢後,response就關閉了,沒法將後臺更新數據即時更新到頁面端sql

注:servlet3.0 之前一般是採用私有解決方案來提早結束 Servlet 線程,並及時釋放資源。數據庫

 

Servlet 3.0 針對這個問題作了開創性的工做,如今經過使用 Servlet 3.0 的異步處理支持,以前的 Servlet 處理流程能夠調整爲以下的過程:網絡

首先,Servlet 接收到請求以後,可能首先須要對請求攜帶的數據進行一些預處理;併發

接着,Servlet 線程將請求轉交給一個異步線程來執行業務處理,線程自己返回至容器,此時 Servlet 尚未生成響應數據,異步線程處理完業務之後,能夠直接生成響應數據(異步線程擁有 ServletRequest 和 ServletResponse 對象的引用),或者將請求繼續轉發給其它 Servlet。異步

如此一來, Servlet 線程再也不是一直處於阻塞狀態以等待業務邏輯的處理,而是啓動異步線程以後能夠當即返回。async

 

一、異步處理特性能夠應用於 Servlet 和過濾器兩種組件,因爲異步處理的工做模式和普通工做模式在實現上有着本質的區別,所以默認狀況下,Servlet 和過濾器並無開啓異步處理特性,若是但願使用該特性,則必須按照以下的方式啓用:

 

  1. 對於使用傳統的部署描述文件 (web.xml) 配置 Servlet 和過濾器的狀況,Servlet 3.0 爲 <servlet> 和 <filter> 標籤增長了 <async-supported> 子標籤,該標籤的默認取值爲 false,要啓用異步處理支持,則將其設爲 true 便可。以 Servlet 爲例,其配置方式以下所示:
    <servlet> 
        <servlet-name>DemoServlet</servlet-name> 
        <servlet-class>footmark.servlet.Demo Servlet</servlet-class> 
        <async-supported>true</async-supported> 
    </servlet>
  2. 對於使用 Servlet 3.0 提供的 @WebServlet 和 @WebFilter 進行 Servlet 或過濾器配置的狀況,這兩個註解都提供了 asyncSupported 屬性,默認該屬性的取值爲 false,要啓用異步處理支持,只需將該屬性設置爲 true 便可。以 @WebFilter 爲例,其配置方式以下所示:
@WebFilter(urlPatterns = "/demo",asyncSupported = true) 
public class DemoFilter implements Filter{...}

 

 

二、Servlet 3.0 還爲異步處理提供了一個監聽器,使用 AsyncListener 接口表示。它能夠監控以下四種事件:

  1. 異步線程開始時,調用 AsyncListener 的 onStartAsync(AsyncEvent event) 方法;
  2. 異步線程出錯時,調用 AsyncListener 的 onError(AsyncEvent event) 方法;
  3. 異步線程執行超時,則調用 AsyncListener 的 onTimeout(AsyncEvent event) 方法;
  4. 異步執行完畢時,調用 AsyncListener 的 onComplete(AsyncEvent event) 方法;
 
要註冊一個 AsyncListener,只需將準備好的 AsyncListener 對象傳遞給 AsyncContext 對象的 addListener() 方法便可,以下所示:
AsyncContext ctx = req.startAsync(); 
ctx.addListener(new AsyncListener() { 
    public void onComplete(AsyncEvent asyncEvent) throws IOException { 
        // 作一些清理工做或者其餘
    } 
    ... 
});
 
實例:
[java]  view plain  copy
 
  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]  view plain  copy
 
  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. }  
相關文章
相關標籤/搜索