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

在 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 = https://www.cnblogs.com/god23bin/p/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 = "https://www.cnblogs.com/god23bin/p/23"), @WebInitParam(name = "add", value = "https://www.cnblogs.com/god23bin/p/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 = "https://www.cnblogs.com/god23bin/p/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 等物件的創建、銷毀和屬性更改等事件，

最后的最后

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

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

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

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/546299.html

標籤：Java

上一篇：SpringBoot Controller

下一篇：關于JAVA泛型陣列型別擦除引發的問題及解決方案