一文快速回顧 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

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

5. 將 tomcat/lib 目錄下的 servlet-api.jar 複製到剛剛建立的 lib 目錄下（是吧，具體的細節是在 Servlet 容器中實現的）
6. 配置 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

這兩個如何選擇？

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

關於對請求和響應的封裝

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

HttpServletRequest 介面

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

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

1. 獲取請求行資訊

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

2. 獲取請求頭資訊

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

3. 獲取請求引數資訊

在實際開發中，我們經常需要獲取使用者提交的表單資料，例如使用者名稱和密碼等。為了方便獲取表單中的請求引數，ServletRequest 定義了一系列獲取請求引數的方法，如下表：

測試 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 介面中定義了向客戶端傳送響應狀態碼、響應頭、響應體的方法。

1. 響應行相關的方法

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

2. 響應頭相關的方法

HttpServletResponse 介面中定義了一系列設定 HTTP 響應頭欄位的方法，如下表：

3. 響應體相關的方法

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

注意：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 介面。

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

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

3. HttpSessionListener 介面：

public interface HttpSessionListener extends EventListener {

    // 通知正在監聽的物件，HttpSession 已經被建立並且初始化了，可以呼叫該方法了
    public default void sessionCreated(HttpSessionEvent se) {
    }

    // 通知正在監聽的物件，HttpSession 已經被銷燬了，可以呼叫該方法了
    public default void sessionDestroyed(HttpSessionEvent se) {
    }
}

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

5. HttpBindingListener 介面：

該介面監聽 HTTP 會話中物件的繫結資訊。

public interface HttpSessionBindingListener extends EventListener {

    // 通知正在監聽的物件，當有物件加入（繫結）到 Session 範圍時，可以呼叫該方法了
    public default void valueBound(HttpSessionBindingEvent event) {
    }

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

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

7. ServletRequestListener 介面：

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

    // 通知正在監聽的物件，ServletRequest 已經被銷燬，可以呼叫該方法了
    public default void requestDestroyed (ServletRequestEvent sre) {
    }


}

8. 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 等物件的建立、銷燬和屬性更改等事件。

最後的最後

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

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

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