天天看點
傳回

一文快速回顧 Servlet、Filter、Listener

作者：搬山道猿

什麼是Servlet？

前置知識：

Web 伺服器：可以指硬體上的，也可以指軟體上的。從硬體的角度來說， Web 伺服器指的就是一台存儲了網絡服務軟體的計算機；從軟體的角度來說， Web 伺服器指的是一種軟體，比如 Tomcat。

Servlet 容器：目前主流的 Servlet 容器軟體包括 Tomcat、Jetty、Jboss 等。

Web 伺服器 ≠ Servlet 容器，Tomcat 是一種 Web 伺服器，同時它還是一個 Servlet 容器。

翻開 Servlet 源碼，有這樣的一句話：

A servlet is a small Java program that runs within a Web server. Servlets receive and respond to requests from Web clients, usually across HTTP, the HyperText Transfer Protocol.

一個 Servlet 就是一個小型的運作在 Web 伺服器裡面的 Java 程式。每個 Servlet 都會接收并且響應來自 Web 用戶端的每一個請求，請求指的是 HTTP 請求（超文本傳輸協定）。

Servlet （ Server Applet）可以說是一種在 Web 伺服器中的 Java 應用程式，這種程式與我們平常寫的 Java 程式的差別在于，它封裝了對 HTTP 請求的處理，同時需要 Servlet 容器的支援。

本質上，Servlet 就是按 Servlet 規範編寫的 Java 類，特别之處就是它可以處理相關的 HTTP 請求。它的規範，或者說标準，是由 Sun 定義的，具體的細節是在 Servlet 容器中實作的，沒錯，比如 Tomcat（老夥計又出來了）。

Servlet 的孩子們

在 javax.servlet 包中，定義了 Servlet 、ServletConfig 這兩個接口，這兩個接口定義了 Servlet 的基本方法以及相關的配置資訊。

Servlet 接口：

public interface Servlet {

    // 初始化的方法，當Servlet對象執行個體化後，Servlet容器會調用該方法來完成初始化工作
    public void init(ServletConfig config) throws ServletException;

    // 服務的方法，用于處理用戶端（浏覽器）發送的請求，并傳回響應，簡單點，處理業務邏輯的
    public void service(ServletRequest req, ServletResponse res)
            throws ServletException, IOException;

    // 銷毀的方法，當Servlet對象将要從Servlet容器中移除時，Servlet容器會調用該方法，就會将Servlet對象進行垃圾回收，釋放記憶體資源
    public void destroy();
    
    // 用于擷取Servlet對象的配置資訊，傳回ServletConfig對象
    public ServletConfig getServletConfig();
    
    // 用于擷取Servlet自身的資訊，比如作者，版本
    public String getServletInfo();
}

init()、service()、destroy()，這 3 個方法的定義，也是定義了 Servlet 的生命周期，這個後面講。

ServletConfig 接口：

public interface ServletConfig {

    // 擷取Servlet對象的名稱
    public String getServletName();

    // 擷取Servlet對象的上下文
    public ServletContext getServletContext();

    // 根據初始化的參數名擷取其參數值
    public String getInitParameter(String name);

    // 擷取所有初始化的參數名的枚舉集合
    public Enumeration<String> getInitParameterNames();
}

還定義了一個名為 GenericServlet 的抽象類，這個抽象類實作了 Servlet、ServletConfig 和 Serializable 接口，它為 Servlet、ServletConfig 提供了一些實作，但沒有對 HTTP 請求處理進行實作，對于 HTTP 請求的處理，是由 GenericServlet 的子類—— HttpServlet 實作的。

HttpServlet 也是一個抽象類，它對 HTTP 請求中的 GET、POST 等請求提供了具體的實作，是以一般情況下，咱們自己寫的 Servlet 基本都是去繼承 HttpServlet，進而進行下一步操作。

HttpServlet 抽象類：

public abstract class HttpServlet extends GenericServlet {
    
    ...
    
    // 并沒有具體實作，是以我們自己寫的時候需要重寫這些方法，來實作我們處理 HTTP 請求的邏輯
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_get_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
        }
    }
    
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_post_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
        }
    }

}

Servlet 和 JSP 的關系

  • Servlet 先出現，JSP 後出現。
  • Servlet 可以處理頁面的問題，傳回頁面給用戶端，但是它主要用于處理業務邏輯。由于沒有 JSP 的時候，頁面和邏輯都是 Servlet 處理的，代碼耦合度是非常高的，操作也是很複雜，是以 JSP 的出現就是解決這種問題，将 HTML、CSS、JS 直接寫到 JSP 頁面中。

在 IDEA 中建立 Servlet 程式

建立 Web 項目并進行配置

建立一個 Web 項目，File -> New -> Project... -> Java -> Java EE -> Web Application

一文快速回顧 Servlet、Filter、Listener
  1. 在 web/WEB-INF 下面建立兩個檔案夾，即 classes 和 lib 目錄。
  2. 按 Ctrl + Alt + Shift + S 進入 Project Structure 進行配置（配置剛剛建立的兩個目錄）。
  3. 配置編譯後的 class 檔案輸出路徑。
  4. 配置依賴項（Web 應用依賴的 Jar 包）位置。
一文快速回顧 Servlet、Filter、Listener
  1. 将 tomcat/lib 目錄下的 servlet-api.jar 複制到剛剛建立的 lib 目錄下（是吧，具體的細節是在 Servlet 容器中實作的）
  2. 配置 Tomcat
一文快速回顧 Servlet、Filter、Listener

還可以配置通路位址（目前項目的通路路徑），通過 Application context 這個配置項進行配置，我這裡一開始預設是 demo_servlet_war_exploded ，修改成 demo_servlet，于是通路路徑會變成 localhost:8080/demo_servlet

一文快速回顧 Servlet、Filter、Listener

編寫 Servlet

在你喜歡的地方建立一個 Servlet，不過目前我把它放在 cn.god23bin.demo.controller 包下。

HelloServlet：繼承 HttpServlet，并重寫 doGet() 和 doPost() 方法。

public class HelloServlet extends HttpServlet {
    /**
     * 處理 GET 方式的 HTTP 請求
     * @param req 請求對象
     * @param resp 響應對象
     * @throws ServletException 異常對象
     * @throws IOException IO異常對象
     * @return 傳回 HTML 頁面
     */
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        resp.setCharacterEncoding("UTF-8");
        PrintWriter out = resp.getWriter();
        out.println("<html>");
        out.println("   <head><title>Hello Servlet</title></head>");
        out.println("   <body>Servlet 執行個體對象： "+ this.getClass() + "</body>");
        out.println("</html>");
        out.flush();
        out.close();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

為什麼我們隻需要重寫 doGet()/doPost()，不需要重寫 service() 方法？

因為 HttpServlet 的 service() 方法已經具體實作了，在該方法判斷請求是什麼類型的（通過 if else 進行判斷，判斷 GET、POST、PUT、DELETE 等），然後再分出一個個單獨的方法來調用，是以我們隻需要重寫 doGet()/doPost() 就行了。

配置 Servlet

想要 Servlet 正常運作，那麼需要進行配置，告知 Web 伺服器哪一個請求調用哪一個 Servlet 對象進行處理。專業的說法：「注冊 Servlet」

在 Servlet 3.0 之前，是通過 web.xml 對 Servlet 進行配置的，3.0 開始，可以通過注解進行配置。

web.xml 的方式

在我們建立這個 Web 應用的時候，該版本為 Servlet 4.0，可以從這個 web.xml 中看到版本資訊。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

</web-app>

使用 xml 配置檔案進行配置，主要用到這麼幾個标簽：

  • <servlet>：聲明一個 Servlet 對象
  • <servlet-name>：指定 Servlet 的名稱，命名的作用
  • <servlet-class>：指定 Servlet 對象的全限定類名（全路徑、完整的位置）
  • <servlet-mapping>：聲明 Servlet 對象後，需要映射通路 Servlet 的 URL（統一資源定位符）
  • <url-pattern>：指定映射通路的 URL，一般自己根據業務進行編寫請求的路徑 
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>cn.god23bin.demo.controller.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

</web-app>

此時，啟動 Tomcat，通路 http://localhost:8080/demo_servlet/hello，得到 Servlet 處理的傳回結果：

Servlet 執行個體對象： class cn.god23bin.demo.controller.HelloServlet

@WebServlet 的方式

@WebServlet 注解，直接加在自己編寫的 Servlet 類上，通過它的屬性進行配置，比如 name 屬性，urlPatterns 屬性和 initParams 屬性。這裡配置了兩個請求映射路徑 /no_web 和 /web_no，這兩個路徑都由目前的 Servlet 對象來處理。

@WebServlet(name = "NoServlet", urlPatterns = {"/no_web", "/web_no"})
public class NoWebXmlServlet extends HttpServlet {
    /**
     * 處理 GET 方式的 HTTP 請求
     * @param req 請求對象
     * @param resp 響應對象
     * @throws ServletException 異常對象
     * @throws IOException IO異常對象
     * @return 傳回 HTML 頁面
     */
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        resp.setCharacterEncoding("UTF-8");
        PrintWriter out = resp.getWriter();
        out.println("<html>");
        out.println("   <head><title>No Web XML Servlet</title></head>");
        out.println("   <body>Servlet 執行個體對象-使用注解的方式配置的： "+ this.getClass() + "</body>");
        out.println("</html>");
        out.flush();
        out.close();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

此時通路 http://localhost:8080/demo_servlet/no_web 和 http://localhost:8080/demo_servlet/web_no 都會得到 Servlet 處理的傳回結果：

Servlet 執行個體對象-使用注解的方式配置的： class cn.god23bin.demo.controller.NoWebXmlServlet
一文快速回顧 Servlet、Filter、Listener

這兩個如何選擇？

按目前的形勢，看個人喜歡，我是喜歡寫注解的方式來進行配置。

關于對請求和響應的封裝

每當有一個 HTTP 請求過來，Servlet 容器就會将目前 HTTP 請求的資訊封裝為一個 HttpServletRequest 對象，而每一個 HttpServletResponse 對象将會轉成 HTTP 響應傳回給用戶端。

HttpServletRequest 接口

在 Servlet API 中，定義了一個 HttpServletRequest 接口，它繼承自 ServletRequest 接口。HttpServletRequest 對象專門用于封裝 HTTP 請求消息。

HTTP 請求消息分為請求行、請求頭和請求體三部分，是以 HttpServletRequest 接口中定義了擷取請求行、請求頭和請求體的相關方法。

  1. 擷取請求行資訊

HTTP 請求的請求行中包含請求方法、請求資源名、請求路徑等資訊，HttpServletRequest 接口定義了一系列擷取請求行資訊的方法，如下表：

傳回值類型 方法聲明 描述
String getMethod() 該方法用于擷取 HTTP 請求方式（如 GET、POST 等）。
String getRequestURI() 該方法用于擷取請求行中的資源名稱部分，即位于 URL 的主機和端口之後，參數部分之前的部分。
String getQueryString() 該方法用于擷取請求行中的參數部分，也就是 URL 中 “?” 以後的所有内容。
String getContextPath() 傳回目前 Servlet 所在的應用的名字（上下文）。對于預設（ROOT）上下文中的 Servlet，此方法傳回空字元串""。
String getServletPath() 該方法用于擷取 Servlet 所映射的路徑。
String getRemoteAddr() 該方法用于擷取用戶端的 IP 位址。
String getRemoteHost() 該方法用于擷取用戶端的完整主機名，如果無法解析出客戶機的完整主機名，則該方法将會傳回用戶端的 IP 位址。
  1. 擷取請求頭資訊

當浏覽器發送請求時，需要通過請求頭向伺服器傳遞一些附加資訊，例如用戶端可以接收的資料類型、壓縮方式、語言等。為了擷取請求頭中的資訊， HttpServletRequest 接口定義了一系列用于擷取 HTTP 請求頭字段的方法，如下表：

傳回值類型 方法聲明 描述
String getHeader(String name) 該方法用于擷取一個指定頭字段的值。 如果請求消息中包含多個指定名稱的頭字段，則該方法傳回其中第一個頭字段的值。
Enumeration getHeaders(String name) 該方法傳回指定頭字段的所有值的枚舉集合， 在多數情況下，一個頭字段名在請求消息中隻出現一次，但有時可能會出現多次。
Enumeration getHeaderNames() 該方法傳回請求頭中所有頭字段的枚舉集合。
String getContentType() 該方法用于擷取 Content-Type 頭字段的值。
int getContentLength() 該方法用于擷取 Content-Length 頭字段的值 。
String getCharacterEncoding() 該方法用于傳回請求消息的字元集編碼 。
  1. 擷取請求參數資訊

在實際開發中，我們經常需要擷取使用者送出的表單資料，例如使用者名和密碼等。為了友善擷取表單中的請求參數，ServletRequest 定義了一系列擷取請求參數的方法，如下表：

傳回值類型 方法聲明 功能描述
String getParameter(String name) 傳回指定參數名的參數值。
String [ ] getParameterValues (String name) 以字元串數組的形式傳回指定參數名的所有參數值（HTTP 請求中可以有多個相同參數名的參數）。
Enumeration getParameterNames() 以枚舉集合的形式傳回請求中所有參數名。
Map getParameterMap() 用于将請求中的所有參數名和參數值裝入一個 Map 對象中傳回。

測試 API 

@WebServlet(name = "ReqInfoServlet", urlPatterns = "/reqInfo")
public class ReqInfoServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=UTF-8");
        PrintWriter out = resp.getWriter();
        out.println(
                "請求行------------------------------------<br/>" +
                "請求方式："     + req.getMethod() + "<br/>" +
                "用戶端的 IP 位址："    + req.getRemoteAddr() + "<br/>" +
                "應用名字（上下文）："  + req.getContextPath() + "<br/>" +
                "URI："                + req.getRequestURI() + "<br/>" +
                "請求字元串："          + req.getQueryString() + "<br/>" +
                "Servlet所映射的路徑：" + req.getServletPath() + "<br/>" +
                "用戶端的完整主機名："   + req.getRemoteHost() + "<br/>"
        );
        out.println("<br/>");
        out.println("請求頭------------------------------------<br/>");
        // 獲得所有請求頭字段的枚舉集合
        Enumeration<String> headers = req.getHeaderNames();
        while (headers.hasMoreElements()) {
            // 獲得請求頭字段的值
            String value = req.getHeader(headers.nextElement());
            out.write(headers.nextElement() + ":" + value + "<br/>");
        }
        out.println("<br/>");
        out.println("請求參數----------------------------------<br/>");
        out.println("keyword：" + req.getParameter("keyword"));
        out.println("value：" + req.getParameter("value"));
        out.flush();
        out.close();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}
一文快速回顧 Servlet、Filter、Listener

HttpServletResponse 接口

在 Servlet API 中，定義了一個 HttpServletResponse 接口，它繼承自 ServletResponse 接口。HttpServletResponse 對象專門用來封裝 HTTP 響應消息。

HTTP 響應消息由響應行、響應頭、響應體三部分組成，是以 HttpServletResponse 接口中定義了向用戶端發送響應狀态碼、響應頭、響應體的方法。

  1. 響應行相關的方法

當 Servlet 傳回響應消息時，需要在響應消息中設定狀态碼。是以，HttpServletResponse 接口定義了發送狀态碼的方法，如下表：

傳回值類型 方法 描述
void setStatus（int status） 用于設定 HTTP 響應消息的狀态碼，并生成響應狀态行。
void sendError（int sc） 用于發送表示錯誤資訊的狀态碼。
  1. 響應頭相關的方法

HttpServletResponse 接口中定義了一系列設定 HTTP 響應頭字段的方法，如下表：

傳回值類型 方法 描述
void addHeader(String name,String value) 用于增加響應頭字段，其中，參數 name 用于指定響應頭字段的名稱，參數 value 用于指定響應頭字段的值。
void setHeader (String name,String value) 用于設定響應頭字段，其中，參數 name 用于指定響應頭字段的名稱，參數 value 用于指定響應頭字段的值。
void addIntHeader(String name,int value) 用于增加值為 int 類型的響應頭字段，其中，參數 name 用于指定響應頭字段的名稱，參數 value 用于指定響應頭字段的值，類型為 int。
void setIntHeader(String name, int value) 用于設定值為 int 類型的響應頭字段，其中，參數 name 用于指定響應頭字段的名稱，參數 value 用于指定響應頭字段的值，類型為 int。
void setContentType(String type) 用于設定 Servlet 輸出内容的 MIME 類型以及編碼格式。
void setCharacterEncoding(String charset) 用于設定輸出内容使用的字元編碼。
  1. 響應體相關的方法

由于在 HTTP 響應消息中，大量的資料都是通過響應體傳遞的。是以 ServletResponse 遵循以 I/O 流傳遞大量資料的設計理念，在發送響應消息體時，定義了兩個與輸出流相關的方法。

傳回值類型 方法 描述
ServletOutputStream getOutputStream() 用于擷取位元組輸出流對象。
PrintWriter getWriter() 用于擷取字元輸出流對象。
注意：getOutputStream() 和 getWriter() 方法互相排斥，不可同時使用，否則會發生 IllegalStateException 異常。

這裡就自己去手動測試一波吧！

Servlet 的生命周期

生命周期，從 Servlet 建立到開始工作處理請求，再到被銷毀進行垃圾回收的過程。從 Service 接口提供的方法也展現出來了。

  • Servlet 初始化後，Servlet 容器就會調用 init () 方法。
  • Servlet 調用 service() 方法來處理用戶端的請求。
  • Servlet 要銷毀前，Servlet 容器就會調用 destroy() 方法。
  • 最後，Servlet 是由 JVM 的垃圾回收器進行垃圾回收的。

init() 方法被設計成隻調用一次，它在第一次建立 Servlet 時被調用，在後續每次使用者請求時不再被調用。是以，它是用于一次性初始化。

service() 方法是執行實際任務的主要方法。每次伺服器接收到一個 Servlet 請求時，伺服器會産生一個新的線程并調用服務。service() 方法檢查 HTTP 請求類型，并在适當的時候調用 doGet、doPost、doPut，doDelete 等方法。

destroy() 方法隻會被調用一次，在 Servlet 生命周期結束時被調用。destroy() 方法可以讓我們寫一些操作，比如關閉資料庫連接配接。在調用 destroy() 方法之後，servlet 對象被标記為垃圾。

過濾器

除了Servlet本身，Java Web應用中還有兩個重要的元件：過濾器（Filter）和監聽器（Listener）。下面分别回顧。

什麼是過濾器？

Servlet 過濾器是再 Servlet 2.3 規範中加入的功能。過濾器可以動态地攔截請求和響應，以變換或使用包含在請求或響應中的資訊。

某些情況下，我們需要再業務代碼執行前擷取請求中的某些資訊，就可以使用過濾器。

簡而言之：

  • 在用戶端的請求通路伺服器中的資源之前，攔截這些請求。
  • 在伺服器的響應發送回用戶端之前，處理這些響應。

如果我們使用一個過濾器不能解決業務需求，那麼就用多個，多個過濾器可以對請求和響應進行多次處理。多個過濾器組合而成的就是「過濾器鍊」，請求會依次按照過濾器的順序一一進入，直到最後一個過濾器為止。當傳回響應的時候，也是一樣，從最後一個過濾器依次傳遞到第一個過濾器，最後到達用戶端。

過濾器相關的接口

有 3 個接口需要知道，就是 Filter 接口、FilterConfig 接口、FilterChain 接口。

每一個過濾器都要直接或間接地實作 Filter 接口，在 Filter 中定義了 3 個方法，分别是 init()、doFilter()、destroy() 方法。

public interface Filter {
    // 初始化方法，初始化的時候會被調用
    public default void init(FilterConfig filterConfig) throws ServletException {}

    // 對請求進行過濾處理
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;

    // 銷毀方法，釋放資源
    public default void destroy() {}
}

FilterConifg 接口由 Servlet 容器實作，主要用于擷取過濾器中的配置資訊。

public interface FilterConfig {

    // 擷取過濾器名稱
    public String getFilterName();

    // 擷取Servlet上下文
    public ServletContext getServletContext();

    // 根據初始化的參數名擷取的參數值
    public String getInitParameter(String name);

    // 擷取所有初始化參數名的枚舉類型集合
    public Enumeration<String> getInitParameterNames();

}

FilterChain 接口仍然由 Servlet 容器實作，這個接口隻有一個方法。

public interface FilterChain {

    // 用于将過濾後的請求傳遞給下一個過濾器，如果這個過濾器是最後一個，那麼将請求傳遞給目标資源（比如交給了某個Servlet）
    public void doFilter(ServletRequest request, ServletResponse response)
            throws IOException, ServletException;

}

編寫一個過濾器

一個過濾器需要實作 Filter 接口，實作該接口後，需要對它的 3 個方法進行實作，其中對于初始化和銷毀的方法，如果沒有什麼特别的需要處理，可以是空實作（空方法）。

編寫過濾器和編寫 Servlet 也是差不多的，需要一個 Java 類來作為過濾器，并通過 web.xml 進行配置，過濾器也有它對應的标簽，不過我這裡目前使用注解的方式對自己的過濾器進行配置。

直接在過濾器這個類上使用 @WebFilter 注解進行配置，有 filterName 屬性，urlPatterns 屬性（映射路徑，是一個數組），initParams 屬性（用于配置過濾器初始化參數的）等等。

HelloFilter：

@WebFilter(filterName = "第一個過濾器", 
        urlPatterns = {"/count", "/add"}, 
        initParams = {@WebInitParam(name = "count", value = "23"), @WebInitParam(name = "add", value = "32")})
public class HelloFilter implements Filter {
    
    private Integer iCount;
    private Integer iAdd;
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 通過 filterConfig 對象擷取我們給過濾器配置的初始化參數
        String count = filterConfig.getInitParameter("count");
        String add = filterConfig.getInitParameter("add");
        iCount = Integer.valueOf(count);
        iAdd = Integer.valueOf(add);
        System.out.println("第一個過濾器初始化完成！");
        System.out.println("擷取初始化的參數------count：" + iCount + "-add：" + iAdd);
    }

    @Override
    public void destroy() {
        System.out.println("第一個過濾器已經銷毀");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // 處理過濾請求
        iCount++;
        iAdd++;
        // 将 ServletRequest 轉成 HttpServletRequest
        HttpServletRequest req = (HttpServletRequest) servletRequest;
        // 擷取上下文
        ServletContext context = req.getServletContext();
        // 将通路數量的值放入上下文
        context.setAttribute("iCount", iCount);
        context.setAttribute("iAdd", iAdd);
        // 傳遞到下一個過濾器
        filterChain.doFilter(servletRequest, servletResponse);
    }
}

上面的代碼中，配置了過濾的請求路徑有 /count 和 /add ，當用戶端通路這兩個路徑時，就會進入該過濾器，第一次通路就會執行初始化方法，接着會執行 doFilter 方法，将兩個變量自增存儲到 Servlet 上下文中（上下文可以了解成整個 Servlet 容器存取資料的區域（環境），可以被其他 Servlet 共享），最後傳遞到下一個過濾器，如果沒有下一個過濾器，就直接到目标資源。

現在，寫多一個 Servlet，作為請求通路的目标資源，如下：

@WebServlet(urlPatterns = {"/count", "/add"})
public class AServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("處理業務，這裡就是目标資源");
        ServletContext context = req.getServletContext();
        Integer iCount = (Integer) context.getAttribute("iCount");
        Integer iAdd = (Integer) context.getAttribute("iAdd");
        System.out.println("歡迎通路" + iCount + "---" + iAdd);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

重新運作 Tomcat，通路 http://localhost:8080/demo_servlet/count 和 http://localhost:8080/demo_servlet/add

控制台輸出如下：

第一個過濾器初始化完成！
擷取初始化的參數------count：23-add：32
[2023-02-19 03:21:32,340] Artifact demo-servlet:war exploded: Artifact is deployed successfully
[2023-02-19 03:21:32,340] Artifact demo-servlet:war exploded: Deploy took 562 milliseconds
處理業務，這裡就是目标資源
歡迎通路24---33
處理業務，這裡就是目标資源
歡迎通路25---34

應用

字元編碼過濾器

示例：這裡有一個 Servlet，擷取請求中攜帶的參數并傳回其拼接到 HTML 中的内容傳回給用戶端。這個 Servlet 作為處理 /addSomething 的 POST 請求。

@WebServlet(name = "AddServlet", urlPatterns = "/addSomething")
public class AddServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String name = req.getParameter("name");
        String author = req.getParameter("author");
        PrintWriter out = resp.getWriter();
        out.print("<h2>名稱：" + name +"</h2>");
        out.print("<h2>作者：" + author +"</h2>");
        out.flush();
        out.close();
    }
}

此時，如果沒有進行字元編碼的過濾操作，重新設定字元集的話，傳回的結果是有中文亂碼的。是以需要一個字元編碼過濾器，對請求和響應進行操作。

CharacterFilter：這個字元編碼過濾器指定了需要過濾的 Servlet 是哪一個（通過 servletNames 指定），并配置了初始化的一個名為 encoding 的參數，其值為 UTF-8。在過濾的方法中，設定請求和響應的字元編碼為 UTF-8，這樣後續到達目标資源的請求和響應的編碼格式就是支援中文的 UTF-8 編碼了。

@WebFilter(servletNames = "AddServlet", initParams = @WebInitParam(name = "encoding", value = "UTF-8"))
public class CharacterFilter implements Filter {

    private String encoding;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 擷取配置的初始化參數值
        encoding = filterConfig.getInitParameter("encoding");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        if (encoding != null) {
            // 設定 request 編碼格式
            servletRequest.setCharacterEncoding(encoding);
            servletResponse.setContentType("text/html; charset=" + encoding);
        }
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {

    }
}

測試結果：

一文快速回顧 Servlet、Filter、Listener

當然，過濾器還有其他應用場景：

  • 認證和授權：驗證使用者是否具有通路某個資源的權限
  • 日志記錄：記錄用戶端請求和伺服器響應的詳細資訊，用于調試和監控
  • 資料壓縮和解壓縮：壓縮響應資料以減少網絡帶寬的使用
  • 圖像處理：對請求的圖像進行處理，如縮放、裁剪等
  • 過濾器鍊：将多個過濾器組合起來形成一個過濾器鍊，依次處理用戶端請求和伺服器響應

監聽器

什麼是監聽器？

有這麼一個需求：就是當某件事發生的時候，我們可以做出某些動作。如何實作呢？那就是通過監聽器實作。

Servlet 監聽器可以監聽 Web 應用程式的某些事件，并當某件事（比如應用程式的啟動和關閉）發生的時候，我們進行相關的處理。

監聽什麼？

可以監聽 ServletContext 的相關操作，可以監聽 HTTP Session （HTTP 會話）的操作，可以監聽用戶端發送過來的請求（請求到 Servlet）。

監聽器是監聽 Web 容器的有效事件，是以它是由容器管理的。總共有 8 個Listener 接口 和 6 個 Event 類

如何監聽？

它們都有各自的監聽器：

  • 監聽 ServletContext（Servlet 上下文 - application）：ServletContextListener
  • 監聽 HTTP Session：HttpSessionListener
  • 監聽用戶端的請求（request）：ServletRequestListener

監聽器的相關接口

對于 ServletContext 上下文的監聽，有 2 個接口：ServletContextListener 和 ServletAttributeListener 接口。

  1. ServletContextListener 接口： 
public interface ServletContextListener extends EventListener {

    // 通知所有的 Servlet 上下文監聽器對象，Web 應用程式已經被加載，之後才繼續加載 過濾器或者 Servlet，可以調用該方法了
    public default void contextInitialized(ServletContextEvent sce) {
    }

    // 在所有的 Servlet 和 過濾器都被銷毀後，通知所有的 Servlet 上下文監聽器對象，Web 應用程式已經被銷毀，可以調用該方法了
    public default void contextDestroyed(ServletContextEvent sce) {
    }
}
  1. ServletContextAttributeListener 接口： 
public interface ServletContextAttributeListener extends EventListener {
    
    // 當有新的屬性被加入到 Servlet 上下文後，就通知所有的上下文監聽器調用這個方法
    public default void attributeAdded(ServletContextAttributeEvent scae) {
    }

    // 當已有屬性被移除後，通知所有上下文監聽器調用這個方法
    public default void attributeRemoved(ServletContextAttributeEvent scae) {
    }

    // 當已有屬性的被替換後，通知所有上下文監聽器調用這個方法
    public default void attributeReplaced(ServletContextAttributeEvent scae) {
    }
}

對于 HTTP Session 的監聽，有 4 個接口：HttpSessionListener，HttpSessionActivationListener，HttpBindingListener 和 HttpSessionAttributeListener 接口。

  1. HttpSessionListener 接口： 
public interface HttpSessionListener extends EventListener {

    // 通知正在監聽的對象，HttpSession 已經被建立并且初始化了，可以調用該方法了
    public default void sessionCreated(HttpSessionEvent se) {
    }

    // 通知正在監聽的對象，HttpSession 已經被銷毀了，可以調用該方法了
    public default void sessionDestroyed(HttpSessionEvent se) {
    }
}
  1. HttpSessionActivationListener 接口：

這裡涉及到的事件就是 Session 的鈍化以及活化。

鈍化：其實就是使用序列化和反序列化技術把 Session 從記憶體儲存到硬碟。

活化：反過來，把 Session從硬碟加載到記憶體。

舉個例子，如果 A 類沒有實作 Serializable 接口，那麼當 Session 鈍化時就不會鈍化 A 對象，而是把 A 對象從 Session 中移除再鈍化。活化的時候，A 對象是不存在的。

public interface HttpSessionActivationListener extends EventListener {

    // 通知正在監聽的對象，Session 對象将要鈍化，可以調用該方法了
    public default void sessionWillPassivate(HttpSessionEvent se) {
    }

    // 通知正在監聽的對象，Session 對象剛剛活化，可以調用該方法了
    public default void sessionDidActivate(HttpSessionEvent se) {
    }
}
  1. HttpBindingListener 接口：

該接口監聽 HTTP 會話中對象的綁定資訊。

public interface HttpSessionBindingListener extends EventListener {

    // 通知正在監聽的對象，當有對象加入（綁定）到 Session 範圍時，可以調用該方法了
    public default void valueBound(HttpSessionBindingEvent event) {
    }

    // 通知正在監聽的對象，當有對象從 Session 範圍移除（解綁）時，可以調用該方法了
    public default void valueUnbound(HttpSessionBindingEvent event) {
    }
}
  1. HttpSessionAttributeListener 接口： 
public interface HttpSessionAttributeListener extends EventListener {

    // 當有新的屬性被加入到 Session 後，就通知所有的 HttpSession 監聽器調用這個方法
    public default void attributeAdded(HttpSessionBindingEvent se) {
    }

    // 當有新的屬性從 Session 中移除後，就通知所有的 HttpSession 監聽器調用這個方法
    public default void attributeRemoved(HttpSessionBindingEvent se) {
    }

    // 當已有屬性的被替換後，就通知所有的 HttpSession 監聽器調用這個方法
    public default void attributeReplaced(HttpSessionBindingEvent se) {
    }
}

對于 Servlet 請求的監聽（用戶端請求的監聽），有 2 個接口：ServletRequestListener 和 ServletRequestAttributeListener 接口。

  1. ServletRequestListener 接口： 
public interface ServletRequestListener extends EventListener {
    
    // 通知正在監聽的對象，ServletRequest 已經被加載和初始化，可以調用該方法了
    public default void requestInitialized (ServletRequestEvent sre) {
    }

    // 通知正在監聽的對象，ServletRequest 已經被銷毀，可以調用該方法了
    public default void requestDestroyed (ServletRequestEvent sre) {
    }


}
  1. ServletRequestAttributeListener 接口： 
public interface ServletRequestAttributeListener extends EventListener {
    
    // 當有新的屬性被加入到 ServletRequest 後，就通知所有的 ServletRequest 監聽器調用這個方法
    public default void attributeAdded(ServletRequestAttributeEvent srae) {
    }

    // 當有新的屬性從 ServletRequest 中移除後，就通知所有的 ServletRequest 監聽器調用這個方法
    public default void attributeRemoved(ServletRequestAttributeEvent srae) {
    }

    // 當已有屬性的被替換後，就通知所有的 ServletRequest 監聽器調用這個方法
    public default void attributeReplaced(ServletRequestAttributeEvent srae) {
    }
}

編寫一個監聽器

可以看到，這些監聽器無非就是監聽那麼幾個對象的建立、銷毀、其對象屬性的建立、銷毀、替換等等的事件。

HelloListener：該監聽器實作了 ServletContextListener, ServletRequestListener 接口，并實作了接口定義的方法。

@WebListener
public class HelloListener implements ServletContextListener, ServletRequestListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ServletContext context = sce.getServletContext();
        System.out.println("輸出這句話說明 Servlet 上下文已經建立了：" + context);
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        ServletContext context = sce.getServletContext();
        System.out.println("輸出這句話說明 Servlet 上下文已經銷毀了：" + context);
    }

    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        ServletRequest request = sre.getServletRequest();
        System.out.println("輸出這句話說明 ServletRequest 已經建立了：" + request.getProtocol());
    }

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        ServletRequest request = sre.getServletRequest();
        System.out.println("輸出這句話說明 ServletRequest 已經銷毀了：" + request.getProtocol());
    }
}

當 Web 應用程式啟動時，Servlet 上下文就會建立，該監聽器就會監聽到該事件，列印輸出我們寫的内容，同理每一次的 HTTP 請求也是，會被監聽。控制台輸出如下：

輸出這句話說明 Servlet 上下文已經建立了：org.apache.catalina.core.ApplicationContextFacade@6df13dcc
第一個過濾器初始化完成！
擷取初始化的參數------count：23-add：32
[2023-02-19 09:48:11,272] Artifact demo-servlet:war exploded: Artifact is deployed successfully
[2023-02-19 09:48:11,272] Artifact demo-servlet:war exploded: Deploy took 735 milliseconds
輸出這句話說明 ServletRequest 已經建立了：HTTP/1.1
輸出這句話說明 ServletRequest 已經銷毀了：HTTP/1.1
輸出這句話說明 ServletRequest 已經建立了：HTTP/1.1
輸出這句話說明 ServletRequest 已經銷毀了：HTTP/1.1

應用

統計線上使用者數：

public class UserCounterListener implements HttpSessionListener {

    private static int activeUsers = 0;

    public static int getActiveUsers() {
        return activeUsers;
    }

    public void sessionCreated(HttpSessionEvent event) {
        activeUsers++;
    }

    public void sessionDestroyed(HttpSessionEvent event) {
        activeUsers--;
    }
}

監聽器可以用于以下場景：

  • 統計線上使用者數：監聽 HttpSession 的建立和銷毀事件，并記錄目前線上使用者數
  • 初始化應用程式：監聽 ServletContext 的建立事件，并在應用程式啟動時執行初始化操作
  • 緩存預熱：監聽 ServletContext 的建立事件，并在應用程式啟動時預加載緩存資料

總結

1. 編寫 Servlet 的幾種方式：

  • 實作 Servlet 接口（很少用）
    • 需要實作接口裡的方法
    • 可以通過重寫 init()、service()、destroy() 等方法來實作 Servlet 的生命周期管理
  • 繼承 GenericServlet 類（很少用）
    • GenericServlet 實作了 Servlet 接口除了 service() 方法
    • 可以通過重寫 service() 方法來實作 Servlet 的具體邏輯
  • 繼承 HttpServlet 方法（最常用）
    • HttpServlet 繼承了 GenericServlet 類，提供了處理 HTTP 請求的方法
    • 可以通過重寫 doGet()、doPost() 等方法來實作 Servlet 的具體邏輯

2. Servlet 處理 HTTP 請求的過程

我們一般編寫 Servlet 是通過繼承 HttpServlet 類并重寫其中的 doGet()、doPost() 等方法來處理HTTP請求的。

當用戶端向伺服器發送 HTTP 請求時，Servlet 容器會建立一個 HttpServletRequest 對象和一個 HttpServletResponse 對象，并将這兩個對象作為參數傳遞給 Servlet 的 service() 方法。service() 方法會根據請求方法（GET、POST等）調用 doGet()、doPost() 等方法來處理請求。

3. 過濾器和監聽器

過濾器是一個 Java 類，它可以攔截用戶端請求和伺服器響應，對它們進行處理，然後将它們傳遞給目标 Servlet 或 JSP 頁面。

監聽器也是一個 Java 類，它可以監聽 Web 應用中的事件，如 ServletContext、HttpSession、ServletRequest 等對象的建立、銷毀和屬性更改等事件。

Listene Servle Serv
上一篇: Git版本控制之ubuntu搭建Git伺服器
下一篇: Spring-boot使用Quartz實作多線程排程任務

繼續閱讀