Servlet3.0中Servlet的使用

目錄

1.註解配置

2.非同步呼叫

3.檔案上傳

       相對於之前的版本，Servlet3.0中的Servlet有以下改進：

l  支援註解配置。

l  支援非同步呼叫。

l  直接有對檔案上傳的支援。

       在這篇文章中我將主要講這三方面的應用示例。

1.註解配置

       在以往我們的Servlet都需要在web.xml檔案中進行配置（Servlet3.0同樣支援），但是在Servlet3.0中引入了註解，我們只需要在對應的Servlet類上使用@WebServlet註解進行標記，我們的應用啟動之後就可以訪問到該Servlet。對於一個@WebServlet而言，有一個屬性是必須要的，那就是它的訪問路徑。@WebServlet中有兩個屬性可以用來表示Servlet的訪問路徑，分別是value和urlPatterns。value和urlPatterns都是陣列形式，表示我們可以把一個Servlet對映到多個訪問路徑，但是value和urlPatterns不能同時使用。如果同時使用了value和urlPatterns，我們的Servlet是無法訪問到的。下面是一個使用@WebServlet的簡單Servlet示例。

1. import java.io.IOException;  
2. import javax.servlet.ServletException;  
3. import javax.servlet.annotation.WebServlet;  
4. import javax.servlet.http.HttpServlet;  
5. import javax.servlet.http.HttpServletRequest;  
6. import javax.servlet.http.HttpServletResponse;  
7. /** 
8.  * 
9.  * Servlet3.0支援使用註解配置Servlet。我們只需在Servlet對應的類上使用@WebServlet進行標註，
    
10.  * 我們就可以訪問到該Servlet了，而不需要再在web.xml檔案中進行配置。@WebServlet的urlPatterns 
11.  * 和value屬性都可以用來表示Servlet的部署路徑，它們都是對應的一個數組。 
12.  */  
13. @WebServlet(name="exampleServlet", urlPatterns="/servlet/example")  
14. public class ExampleServlet extends HttpServlet {  
15.    private static final long serialVersionUID = 1L;  
16.    @Override  
17.    protected
     void doGet(HttpServletRequest request,  
18.          HttpServletResponse response) throws ServletException, IOException {  
19.       this.doPost(request, response);  
20.    }  
21.    @Override  
22.    protected void doPost(HttpServletRequest request,  
23.          HttpServletResponse response) throws ServletException, IOException {  
24.       response.getWriter().write("Hello User.");  
25.    }  
26. }  

初始化引數

       使用@WebServlet時也可以配置初始化引數，它是通過@WebServlet的initParams引數來指定的。initParams是一個@WebInitParam陣列，每一個@WebInitParam代表一個初始化引數。

1. import java.io.IOException;  
2. import java.util.Enumeration;  
3. import javax.servlet.ServletException;  
4. import javax.servlet.annotation.WebInitParam;  
5. import javax.servlet.annotation.WebServlet;  
6. import javax.servlet.http.HttpServlet;  
7. import javax.servlet.http.HttpServletRequest;  
8. import javax.servlet.http.HttpServletResponse;  
9. /** 
10.  * 帶初始化引數的Servlet 
11.  * WebServlet的屬性initParams可以用來指定當前Servlet的初始化引數，它是一個數組， 
12.  * 裡面每一個@WebInitParam表示一個引數。 
13.  */  
14. @WebServlet(value="/servlet/init-param", initParams={@WebInitParam(name="param1", value="value1")})  
15. public class WebInitParamServlet extends HttpServlet {  
16.    /** 
17.     * 
18.     */  
19.    private static final long serialVersionUID = 1L;  
20.    @Override  
21.    protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
22.          throws ServletException, IOException {  
23.       this.doPost(req, resp);  
24.    }  
25.    @Override  
26.    protected void doPost(HttpServletRequest req, HttpServletResponse resp)  
27.          throws ServletException, IOException {  
28.       Enumeration<String> paramNames = this.getServletConfig().getInitParameterNames();  
29.       String paramName;  
30.       while (paramNames.hasMoreElements()) {  
31.          paramName = paramNames.nextElement();  
32.          resp.getWriter().append(paramName + " = " + this.getServletConfig().getInitParameter(paramName));  
33.       }  
34.       resp.getWriter().close();  
35.    }  
36. }  

2.非同步呼叫

       在Servlet3.0中，在Servlet內部支援非同步處理。它的邏輯是當我們請求一個Servlet時，我們的Servlet可以先返回一部分內容給客戶端。然後在Servlet內部非同步處理另外一段邏輯，等到非同步處理完成之後，再把非同步處理的結果返回給客戶端。這意味著當我們的Servlet在處理一段比較費時的業務邏輯時，我們可以先返回一部分資訊給客戶端，然後非同步處理費時的業務，而不必讓客戶端一直等待所有的業務邏輯處理完。等到非同步處理完之後，再把對應的處理結果返回給客戶端。

       非同步呼叫是通過當前HttpServletRequest的startAsync()方法開始的，它返回一個AsyncContext。之後我們可以呼叫AsyncContext的start()方法來新起一個執行緒進行非同步呼叫。在新執行緒內部程式的最後我們最好是呼叫一下當前AsyncContext的complete()方法，否則非同步呼叫的結果需要等到設定的超時時間過後才會返回到客戶端。另外當非同步呼叫超時以後會接著呼叫非同步任務，即新起的執行緒。

1. import java.io.IOException;  
2. import java.io.PrintWriter;  
3. import javax.servlet.AsyncContext;  
4. import javax.servlet.ServletException;  
5. import javax.servlet.annotation.WebServlet;  
6. import javax.servlet.http.HttpServlet;  
7. import javax.servlet.http.HttpServletRequest;  
8. import javax.servlet.http.HttpServletResponse;  
9. /** 
10.  * 支援非同步返回的Servlet 
11.  * 對於Servlet的非同步返回，首先我們必須指定@WebServlet的asyncSupported屬性為true（預設是false），同時在它之前的Filter 
12.  * 的asyncSupported屬性也必須是true，否則傳遞過來的request就是不支援非同步呼叫的。 
13.  * 
14.  */  
15. @WebServlet(value="/servlet/async", asyncSupported=true)  
16. public class AsyncServlet extends HttpServlet {  
17.    /** 
18.     * 
19.     */  
20.    private static final long serialVersionUID = 1L;  
21.    @Override  
22.    protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
23.          throws ServletException, IOException {  
24.       this.doPost(req, resp);  
25.    }  
26.    @Override  
27.    protected void doPost(HttpServletRequest req, HttpServletResponse resp)  
28.          throws ServletException, IOException {  
29.       resp.setContentType("text/plain;charset=UTF-8");  
30.       final PrintWriter writer = resp.getWriter();  
31.       writer.println("非同步之前輸出的內容。");  
32.       writer.flush();  
33.       //開始非同步呼叫，獲取對應的AsyncContext。  
34.       final AsyncContext asyncContext = req.startAsync();  
35.       //設定超時時間，當超時之後程式會嘗試重新執行非同步任務，即我們新起的執行緒。  
36.       asyncContext.setTimeout(10*1000L);  
37.       //新起執行緒開始非同步呼叫，start方法不是阻塞式的，它會新起一個執行緒來啟動Runnable介面，之後主程式會繼續執行  
38.       asyncContext.start(new Runnable() {  
39.          @Override  
40.          public void run() {  
41.             try {  
42.                 Thread.sleep(5*1000L);  
43.                 writer.println("非同步呼叫之後輸出的內容。");  
44.                 writer.flush();  
45.                 //非同步呼叫完成，如果非同步呼叫完成後不呼叫complete()方法的話，非同步呼叫的結果需要等到設定的超時  
46.                 //時間過了之後才能返回到客戶端。  
47.                 asyncContext.complete();  
48.             } catch (Exception e) {  
49.                 e.printStackTrace();  
50.             }  
51.          }  
52.       });  
53.       writer.println("可能在非同步呼叫前輸出，也可能在非同步呼叫之後輸出，因為非同步呼叫會新起一個執行緒。");  
54.       writer.flush();  
55.    }  
56. }  

       對於一個Servlet如果要支援非同步呼叫的話我們必須指定其asyncSupported屬性為true（預設是false）。使用@WebServlet註解標註的Servlet我們可以直接指定其asyncSupported屬性的值為true，如：

@WebServlet(value=”/servlet/async”, asyncSupported=true)。而對於在web.xml檔案中進行配置的Servlet來說，我們需要在配置的時候指定其asyncSupported屬性為true。

1. <servlet>  
2.    <servlet-name>xxx</servlet-name>  
3.    <servlet-class>xxx</servlet-class>  
4.    <async-supported>true</async-supported>  
5. </servlet>  
6. <servlet-mapping>  
7.    <servlet-name>xxx</servlet-name>  
8.    <url-pattern>xxx</url-pattern>  
9. </servlet-mapping>  

       Servlet的非同步呼叫程式的關鍵是要呼叫當前HttpServletRequest的startAsync()方法。至於利用返回的AsyncContext來新起一個執行緒進行非同步處理就不是那麼的必須了，因為在HttpServletRequest startAsync()之後，我們可以自己新起執行緒進行非同步處理。

1. @WebServlet(value="/servlet/async", asyncSupported=true)  
2. public class AsyncServlet extends HttpServlet {  
3.    /** 
4.     * 
5.     */  
6.    private static final long serialVersionUID = 1L;  
7.    @Override  
8.    protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
9.          throws ServletException, IOException {  
10.       this.doPost(req, resp);  
11.    }  
12.    @Override  
13.    protected void doPost(HttpServletRequest req, HttpServletResponse resp)  
14.          throws ServletException, IOException {  
15.       resp.setContentType("text/plain;charset=UTF-8");  
16.       final PrintWriter writer = resp.getWriter();  
17.       writer.println("非同步之前輸出的內容。");  
18.       writer.flush();  
19.       //開始非同步呼叫，獲取對應的AsyncContext。  
20.       final AsyncContext asyncContext = req.startAsync();  
21.       //設定超時時間，當超時之後程式會嘗試重新執行非同步任務，即我們新起的執行緒。  
22.       asyncContext.setTimeout(10*1000L);  
23.       Runnable r = new Runnable() {  
24.          @Override  
25.          public void run() {  
26.             try {  
27.                 Thread.sleep(5*1000L);  
28.                 writer.println("非同步呼叫之後輸出的內容。");  
29.                 writer.flush();  
30.                 //非同步呼叫完成  
31.                 asyncContext.complete();  
32.             } catch (Exception e) {  
33.                 e.printStackTrace();  
34.             }  
35.          }   
36.       };  
37.       Thread t = new Thread(r);  
38.       //開啟自己的執行緒進行非同步處理  
39.       t.start();  
40.       writer.println("可能在非同步呼叫前輸出，也可能在非同步呼叫之後輸出，因為非同步呼叫會新起一個執行緒。");  
41.       writer.flush();  
42.    }  
43. }  

非同步呼叫監聽器

       當我們需要對非同步呼叫做一個詳細的監聽的時候，比如監聽它是否超時，我們可以通過給AsyncContext設定對應的監聽器AsyncListener來實現這一功能。AsyncListener是一個介面，裡面定義了四個方法，分別是針對於非同步呼叫開始、結束、出錯和超時的。

1. import java.io.IOException;  
2. import java.io.PrintWriter;  
3. import javax.servlet.AsyncContext;  
4. import javax.servlet.AsyncEvent;  
5. import javax.servlet.AsyncListener;  
6. import javax.servlet.ServletException;  
7. import javax.servlet.annotation.WebServlet;  
8. import javax.servlet.http.HttpServlet;  
9. import javax.servlet.http.HttpServletRequest;  
10. import javax.servlet.http.HttpServletResponse;  
11. /** 
12.  * 支援非同步返回的Servlet 
13.  * 對於Servlet的非同步返回，首先我們必須指定@WebServlet的asyncSupported屬性為true（預設是false），同時在它之前的Filter 
14.  * 的asyncSupported屬性也必須是true，否則傳遞過來的request就是不支援非同步呼叫的。 
15.  * 
16.  */  
17. @WebServlet(value="/servlet/async2", asyncSupported=true)  
18. public class AsyncServlet2 extends HttpServlet {  
19.    /** 
20.     * 
21.     */  
22.    private static final long serialVersionUID = 1L;  
23.    @Override  
24.    protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
25.          throws ServletException, IOException {  
26.       this.doPost(req, resp);  
27.    }  
28.    @Override  
29.    protected void doPost(HttpServletRequest req, HttpServletResponse resp)  
30.          throws ServletException, IOException {  
31.       resp.setContentType("text/plain;charset=UTF-8");  
32.       final PrintWriter writer = resp.getWriter();  
33.       writer.println("非同步之前輸出的內容。");  
34.       writer.flush();  
35.       //開始非同步呼叫，獲取對應的AsyncContext。  
36.       final AsyncContext asyncContext = req.startAsync();  
37.       //設定當前非同步呼叫對應的監聽器  
38.       asyncContext.addListener(new MyAsyncListener());  
39.       //設定超時時間，當超時之後程式會嘗試重新執行非同步任務，即我們新起的執行緒。  
40.       asyncContext.setTimeout(10*1000L);  
41.       //新起執行緒開始非同步呼叫，start方法不是阻塞式的，它會新起一個執行緒來啟動Runnable介面，之後主程式會繼續執行  
42.       asyncContext.start(new Runnable() {  
43.          @Override  
44.          public void run() {  
45.             try {  
46.                 Thread.sleep(5*1000L);  
47.                 writer.println("非同步呼叫之後輸出的內容。");  
48.                 writer.flush();  
49.                 //非同步呼叫完成  
50.                 asyncContext.complete();  
51.             } catch (Exception e) {  
52.                 e.printStackTrace();  
53.             }  
54.          }  
55.       });  
56.       writer.println("可能在非同步呼叫前輸出，也可能在非同步呼叫之後輸出，因為非同步呼叫會新起一個執行緒。");  
57.       writer.flush();  
58.    }  
59.    /** 
60.     * 非同步呼叫對應的監聽器 
61.     * @author Yeelim 
62.     * @date 2014-2-8 
63.     * @mail [email protected] 
64.     */  
65.    private class MyAsyncListener implements AsyncListener {  
66.       @Override  
67.       public void onComplete(AsyncEvent event) throws IOException {  
68.          System.out.println("非同步呼叫完成……");  
69.          event.getSuppliedResponse().getWriter().println("非同步呼叫完成……");  
70.       }  
71.       @Override  
72.       public void onError(AsyncEvent event) throws IOException {  
73.          System.out.println("非同步調用出錯……");  
74.          event.getSuppliedResponse().getWriter().println("非同步調用出錯……");  
75.       }  
76.       @Override  
77.       public void onStartAsync(AsyncEvent event) throws IOException {  
78.          System.out.println("非同步呼叫開始……");  
79.          event.getSuppliedResponse().getWriter().println("非同步呼叫開始……");  
80.       }  
81.       @Override  
82.       public void onTimeout(AsyncEvent event) throws IOException {  
83.          System.out.println("非同步呼叫超時……");  
84.          event.getSuppliedResponse().getWriter().println("非同步呼叫超時……");  
85.       }  
86.    }  
87. }  

注：

       對於正常執行的非同步呼叫而言上述程式碼中開始是沒有監聽到的，只有在非同步呼叫超時，重新執行非同步任務的時候才有監聽到非同步呼叫的開始。不過如果需要監聽非同步第一次開始的話，我們可以在非同步呼叫開始的時候做相應的監聽器監聽到非同步呼叫開始時需要做的內容。

3.檔案上傳

       在Servlet3.0中上傳檔案變得非常簡單。我們只需通過request的getPart(String partName)獲取到上傳的對應檔案對應的Part或者通過getParts()方法獲取到所有上傳檔案對應的Part。之後我們就可以通過part的write(String fileName)方法把對應檔案寫入到磁碟。或者通過part的getInputStream()方法獲取檔案對應的輸入流，然後再對該輸入流進行操作。要使用request的getPart()或getParts()方法對上傳的檔案進行操作的話，有兩個要注意的地方。首先，用於上傳檔案的form表單的enctype必須為multipart/form-data；其次，對於使用註解宣告的Servlet，我們必須在其對應類上使用@MultipartConfig進行標註，而對於在web.xml檔案進行配置的Servlet我們也需要指定其multipart-config屬性，如：

1. <servlet>  
2.    <servlet-name>xxx</servlet-name>  
3.    <servlet-class>xxx.xxx</servlet-class>  
4.    <multipart-config></multipart-config>  
5. </servlet>  
6. <servlet-mapping>  
7.    <servlet-name>xxx</servlet-name>  
8.    <url-pattern>/servlet/xxx</url-pattern>  
9. </servlet-mapping>  

       不管是基於註解的@MultipartConfig，還是基於web.xml檔案配置的multipart-config，我們都可以給它們設定幾個屬性。

l  file-size-threshold：數字型別，當檔案大小超過指定的大小後將寫入到硬碟上。預設是0，表示所有大小的檔案上傳後都會作為一個臨時檔案寫入到硬碟上。

l  location：指定上傳檔案存放的目錄。當我們指定了location後，我們在呼叫Part的write(String fileName)方法把檔案寫入到硬碟的時候可以，檔名稱可以不用帶路徑，但是如果fileName帶了絕對路徑，那將以fileName所帶路徑為準把檔案寫入磁碟。

l  max-file-size：數值型別，表示單個檔案的最大大小。預設為-1，表示不限制。當有單個檔案的大小超過了max-file-size指定的值時將丟擲IllegalStateException異常。

l  max-request-size：數值型別，表示一次上傳檔案的最大大小。預設為-1，表示不限制。當上傳時所有檔案的大小超過了max-request-size時也將丟擲IllegalStateException異常。

上面的屬性是針對於web.xml中配置Servlet而言的，其中的每一個屬性都對應了multipart-config元素下的一個子元素。對於基於註解配置的Servlet而言，@MultipartConfig的屬性是型別的，我們只需把上述對應屬性中間的槓去掉，然後把對應字母大寫即可，如maxFileSize。

       下面給出Servlet3.0中檔案上傳的一個示例。

Html：

1. <form method="post" action="servlet/upload" enctype="multipart/form-data">  
2.    <input type="file" name="upload"/>  
3.    <input type="submit" value="upload"/>  
4. </form>  

對應Servlet：

1. @WebServlet("/servlet/upload")  
2. @MultipartConfig  
3. public class FileUploadServlet extends HttpServlet {  
4.    /** 
5.     * 
6.     */  
7.    private static final long serialVersionUID = 1L;  
8.    @Override  
9.    protected void doPost(HttpServletRequest req, HttpServletResponse resp)  
10.          throws ServletException, IOException {  
11.       req.setCharacterEncoding("UTF-8");  
12.       Part part = req.getPart("upload");  
13.       //格式如：form-data; name="upload"; filename="YNote.exe"  
14.       String disposition = part.getHeader("content-disposition");  
15.       System.out.println(disposition);  
16.       String fileName = disposition.substring(disposition.lastIndexOf("=")+2, disposition.length()-1);  
17.       String fileType = part.getContentType();  
18.       long fileSize = part.getSize();  
19.       System.out.println("fileName: " + fileName);  
20.       System.out.println("fileType: " + fileType);  
21.       System.out.println("fileSize: " + fileSize);  
22.       String uploadPath = req.getServletContext().getRealPath("/upload");  
23.       System.out.println("uploadPath" + uploadPath);  
24.       part.write(uploadPath + File.separator +fileName);  
25.    }  
26. }  

       對於Servlet3.0中的檔案上傳還有一個需要注意的地方，當我們把Part寫入到硬碟以後，我們原先的Part（也就是之前的臨時檔案）可能已經刪了，這個時候如果我們再次去訪問Part的內容的話，那它就是空的，系統會丟擲異常說找不到對應的檔案。