一文快速回顧 Servlet、Filter、Listener

前置知識： Web 伺服器：可以指硬體上的，也可以指軟體上的。從硬體的角度來說， Web 伺服器指的就是一臺存儲了網路服務軟體的電腦；從軟體的角度來說， Web 伺服器指的是一種軟體，比如 Tomcat。 Servlet 容器：目前主流的 Servlet 容器軟體包括 Tomcat、Jetty、J... ...

什麼是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

在 web/WEB-INF 下麵新建兩個文件夾，即 classes 和 lib 目錄。
按 Ctrl + Alt + Shift + S 進入 Project Structure 進行配置（配置剛剛新建的兩個目錄）。
配置編譯後的 class 文件輸出路徑。
配置依賴項（Web 應用依賴的 Jar 包）位置。

將 tomcat/lib 目錄下的 servlet-api.jar 複製到剛剛創建的 lib 目錄下（是吧，具體的細節是在 Servlet 容器中實現的）
配置 Tomcat

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

編寫 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

Tomcat中Servlet處理過程

這兩個如何選擇？

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

關於對請求和響應的封裝

每當有一個 HTTP 請求過來，Servlet 容器就會將當前 HTTP 請求的信息封裝為一個 HttpServletRequest 對象，而每一個 HttpServletResponse 對象將會轉成 HTTP 響應返回給客戶端。

HttpServletRequest 介面

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

HTTP 請求消息分為請求行、請求頭和請求體三部分，所以 HttpServletRequest 介面中定義了獲取請求行、請求頭和請求體的相關方法。

獲取請求行信息

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 地址。

獲取請求頭信息

當瀏覽器發送請求時，需要通過請求頭向伺服器傳遞一些附加信息，例如客戶端可以接收的數據類型、壓縮方式、語言等。為了獲取請求頭中的信息， HttpServletRequest 介面定義了一系列用於獲取 HTTP 請求頭欄位的方法，如下表：

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

獲取請求參數信息

在實際開發中，我們經常需要獲取用戶提交的表單數據，例如用戶名和密碼等。為了方便獲取表單中的請求參數，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);
    }
}

HttpServletResponse 介面

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

HTTP 響應消息由響應行、響應頭、響應體三部分組成，所以 HttpServletResponse 介面中定義了向客戶端發送響應狀態碼、響應頭、響應體的方法。

響應行相關的方法

當 Servlet 返迴響應消息時，需要在響應消息中設置狀態碼。因此，HttpServletResponse 介面定義了發送狀態碼的方法，如下表：

返回值類型	方法	描述
void	setStatus（int status）	用於設置 HTTP 響應消息的狀態碼，並生成響應狀態行。
void	sendError（int sc）	用於發送表示錯誤信息的狀態碼。

響應頭相關的方法

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)	用於設置輸出內容使用的字元編碼。

響應體相關的方法

由於在 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 監聽器可以監聽 Web 應用程式的某些事件，並當某件事（比如應用程式的啟動和關閉）發生的時候，我們進行相關的處理。

監聽什麼？

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

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

如何監聽？

它們都有各自的監聽器：

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

監聽器的相關介面

對於 ServletContext 上下文的監聽，有 2 個介面：ServletContextListener 和 ServletAttributeListener 介面。

ServletContextListener 介面：

public interface ServletContextListener extends EventListener {

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

    // 在所有的 Servlet 和 過濾器都被銷毀後，通知所有的 Servlet 上下文監聽器對象，Web 應用程式已經被銷毀，可以調用該方法了
    public default void contextDestroyed(ServletContextEvent sce) {
    }
}

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 介面。

HttpSessionListener 介面：

public interface HttpSessionListener extends EventListener {

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

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

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) {
    }
}

HttpBindingListener 介面：

該介面監聽 HTTP 會話中對象的綁定信息。

public interface HttpSessionBindingListener extends EventListener {

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

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

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 介面。

ServletRequestListener 介面：

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

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


}

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 等對象的創建、銷毀和屬性更改等事件。

最後的最後

由本人水平所限，難免有錯誤以及不足之處， 屏幕前的靚仔靚女們 如有發現，懇請指出！

最後，謝謝你看到這裡，謝謝你認真對待我的努力，希望這篇博客對你有所幫助！

你輕輕地點了個贊，那將在我的心裡世界增添一顆明亮而耀眼的星！