1.Tomcat如何調用Servlet

?1.1Servlet原理

Servlet是屬于上層建筑，它處在應用層，它的下層有傳輸層，網絡層，數據鏈路層，硬件，屬于“經濟基礎”，畢竟下層經濟基礎決定上層建筑。前面說過，Servlet是一組操作HTTP的API，Tomcat可作為HTTP服務器來處理請求，這個處理請求的關鍵就是調用Servlet來操作HTTP給客戶端做出響應。

我們所寫的Servlet代碼沒有main方法，那他是如何運行的呢？其實是Tomcat在調用Servlet，Tomcat其實就是一個應用程序，是運行在用戶態上的一個普通的Java進程。

當瀏覽器發送請求給服務器的時候，Tomcat作為HTTP Server會調用Serlvet API，然后執行我們所寫的Servlet程序來處理請求。

處理請求的過程中牽涉的不僅僅只有HTTP，還有其他層的協議，但是我們并沒有感知到其他層協議的細節，只關注了應用層HTTP協議的細節，這就是協議分層好處，程序員在實現處理請求時，不必去關心應用層下面的細節。

?1.2Tomcat的執行邏輯

為了方便描述Tomcat的執行邏輯，我們使用偽代碼的形式來分析：

初始化與收尾工作，又細分為以下幾部分:

1)從指定的目錄中找到Servlet類，并加載。

2根據加載的結果，給這些類型創建實例。

3)創建好實例后，調用Servlet對象中的 init 方法。

4)創建TCP socket對象，監聽8080端口，等待客戶端來連接。

5)如果請求處理完畢，也就是處理請求的循環退出了，那Tomcat也結束了，調用 destroy 方法結束進程，但是這個環節不一定可靠，正常退出的情況下，需要在管理端口（8005）去調用 destroy ，將Tomcat關閉，但很多時候都是直接殺死進程來達到關閉的目的，此時根本來不及調用 dsetroy 方法。

class Tomcat {
 
    // 用來存儲所有的 Servlet 對象
    private List<Servlet> instanceList = new ArrayList<>();
    public void start() {
 
        // 根據約定，讀取 WEB-INF/web.xml 配置文件;
        // 并解析被 @WebServlet 注解修飾的類

        // 假定這個數組里就包含了我們解析到的所有被 @WebServlet 注解修飾的類. 
        Class<Servlet>[] allServletClasses = ...;

        // 這里要做的的是實例化出所有的 Servlet 對象出來;
        for (Class<Servlet> cls : allServletClasses) {
 
            // 這里是利用 java 中的反射特性做的
            // 實際上還得涉及一個類的加載問題，因為我們的類字節碼文件，是按照約定的
            // 方式（全部在 WEB-INF/classes 文件夾下）存放的，所以 tomcat 內部是
            // 實現了一個自定義的類加載器(ClassLoader)用來負責這部分工作。

            Servlet ins = cls.newInstance();
            instanceList.add(ins);
        }

        // 調用每個 Servlet 對象的 init() 方法，這個方法在對象的生命中只會被調用這一次;
        for (Servlet ins : instanceList) {
 
            ins.init();
        }

        // 利用我們之前學過的知識，啟動一個 HTTP 服務器
        // 并用線程池的方式分別處理每一個 Request
        ServerSocket serverSocket = new ServerSocket(8080);
        // 實際上 tomcat 不是用的固定線程池，這里只是為了說明情況
        ExecuteService pool = Executors.newFixedThreadPool(100);

        while (true) {
 
            Socket socket = ServerSocket.accept();
            // 每個請求都是用一個線程獨立支持，這里體現了我們 Servlet 是運行在多線程環境下的
            pool.execute(new Runnable() {
 
                doHttpRequest(socket);//處理請求
            });
        }
        // 調用每個 Servlet 對象的 destroy() 方法，這個方法在對象的生命中只會被調用這一次;
        for (Servlet ins : instanceList) {
 
            ins.destroy();
        }
    }

    public static void main(String[] args) {
 
        new Tomcat().start();
    }
}

Tomcat處理請求工作：

1）讀取socket中的數據，并按照HTTP協議的格式來進行解析，獲取請求。

2）判斷請求是需要靜態內容還是動態內容，如果是靜態內容，可以在根路徑上找到目的文件，返回請求

3）如果是動態文件，則需要通過URL上的一級路徑與二級路徑來確定通過哪一個Servlet類來進行處理，沒有的話就會返回404

4）找到對應Servlet對象，調用對象里面的 service 方法，根據請求的方法來調用對應的 do... 方法

class Tomcat {
 
    void doHttpRequest(Socket socket) {
 
        // 參照我們之前學習的 HTTP 服務器類似的原理，進行 HTTP 協議的請求解析，和響應構建
        HttpServletRequest req = HttpServletRequest.parse(socket);
        HttpServletRequest resp = HttpServletRequest.build(socket);
        
        // 判斷 URL 對應的文件是否可以直接在我們的根路徑上找到對應的文件，如果找到，就是靜態
        // 直接使用我們學習過的 IO 進行內容輸出
        if (file.exists()) {
 
            // 返回靜態內容
            return;
       }
        
        // 走到這里的邏輯都是動態內容了
        
        // 根據我們在配置中說的，按照 URL -> servlet-name -> Servlet 對象的鏈條
        // 最終找到要處理本次請求的 Servlet 對象
        Servlet ins = findInstance(req.getURL());
        
        // 調用 Servlet 對象的 service 方法
        // 這里就會最終調用到我們自己寫的 HttpServlet 的子類里的方法了
        try {
 
       		ins.service(req, resp); 
       } catch (Exception e) {
 
            // 返回 500 頁面，表示服務器內部錯誤
       }
   }
}

service方法執行邏輯：

class Servlet {
 
    public void service(HttpServletRequest req, HttpServletResponse resp) {
 
        String method = req.getMethod();
        if (method.equals("GET")) {
 
            doGet(req, resp);
       } else if (method.equals("POST")) {
 
            doPost(req, resp);
       } else if (method.equals("PUT")) {
 
            doPut(req, resp);
       } else if (method.equals("DELETE")) {
 
            doDelete(req, resp);
       } 
       ......
   }
}

在整個流程中，有三個關鍵的方法：

init

?2.Servlet中關鍵的幾個API

?2.1常用方法列舉

HttpServlet關鍵方法：

這些方法的調用時機，就構成了“Servlet”的生命周期。

HttpServletRequest關鍵方法：

HttpServletResponse關鍵方法：

?2.2Post請求的構造

在同一webapp里面，關聯路徑不能夠相同，不然Tomcat跑不起來，對于GET請求，可以使用URL的查詢字符串進行構造，但是POST請求不行，需要使用form或者ajax。

構造Post請求（使用ajax構造）：

在webapp目錄下創建一個HTML文件，用來構造POST請求，首先我們先的引入 jquery 依賴（博主使用的是本地導入，你可以如果網絡地址： https://cdn.bootcdn.net/ajax/libs/jquery/3.6.0/jquery.min.js 導入依賴），然后調用ajax構造請求。

<script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
    <script>
        $.ajax({
   
            type: "post",
            url: "method",
            success: function (body){
   
                console.log(body);
            }
        })
    </script>

注意上面的URL屬性不能加 / ，加上表示的就是絕對路徑了，當然你也可以使用 ./ 來表示相對路徑，但是在Servlet注解關聯路徑必須得加上 / 。

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/method")
public class MethodServlet extends HttpServlet {
 
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
        resp.getWriter().write("POST請求");
    }
}

我們訪問 http://127.0.0.1:8080/hello_servlet/test.html 來看控制臺輸出的返回結果。

我們發現與我們的預期不一致，我們處理請求的時候返回了 POST請求 ，而這里顯示了 POST?? ，原因是發生了亂碼，idea默認編碼格式為 utf-8 ，Windows默認的編碼格式是 gbk ，那瀏覽器解析body的時候也是以 gbk 格式去進行解析，要想統一格式，就得先告訴瀏覽器響應數據的編碼格式是什么，我們需要在Servlet程序里面設置字符格式，設置方法為調用HttpServletResponse對象的 setContentType 方法，傳入參數 text/html; charset=utf8 。

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/method")
public class MethodServlet extends HttpServlet {
 
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
        resp.setContentType("text/html; charset=utf8");
        resp.getWriter().write("POST請求");
    }
}

重新打包部署，刷新頁面：

?2.3獲取請求信息

對于請求的信息，我們運用HttpServletRequest類的方法來進行請求信息的獲?。?/span>

比如我們訪問的url為 http://127.0.0.1:8080/hello_servlet/showreq?key=10&a=100&b=200 ，很明顯這是使用查詢字符串構造的一個GET請求，通過HttpServletRequest類一系列對應的方法，我們可以獲取到這個請求的方法類型，協議版本，URL，查詢字符串，頭部的一些信息等。其中查詢字符串與頭部信息的獲取先要使用getParameterNames方法或者getHeaderNames方法獲取所有的查詢字符串或頭部信息的所有 key 值，這個一個枚舉對象，然后在根據getParameter或者getHeader方法通過 key 值遍歷枚舉對象獲取 value 。

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;

@WebServlet("/showreq")
public class ShowRequestServlet extends HttpServlet {
 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
    //訪問鏈接：http://127.0.0.1:8080/hello_servlet/showreq?key=10&a=100&b=200
        StringBuilder stringBuilder = new StringBuilder();
        resp.setContentType("text/html; charset=utf-8");
        //1協議名稱與版本
        stringBuilder.append("協議版本:");
        stringBuilder.append(req.getProtocol());
        stringBuilder.append("<br>");
        //2方法類型
        stringBuilder.append("方法:");
        stringBuilder.append(req.getMethod());
        stringBuilder.append("<br>");
        //3獲取查URL路徑
        stringBuilder.append("URL路徑:");
        stringBuilder.append(req.getRequestURI());
        stringBuilder.append("<br>");
        //4URL（不包括查詢字符串后面的部分）
        stringBuilder.append("URL（不包括查詢字符串后面的部分）:");
        stringBuilder.append(req.getRequestURL());
        stringBuilder.append("<br>");

        //5一級路徑
        stringBuilder.append("一級路徑:");
        stringBuilder.append(req.getContextPath());
        stringBuilder.append("<br>");
        //6查詢字符串
        stringBuilder.append("查詢字符串:");
        stringBuilder.append(req.getQueryString());
        stringBuilder.append("<br>");
        //7正文編碼格式
        stringBuilder.append("正文編碼格式:");
        stringBuilder.append(req.getCharacterEncoding());
        stringBuilder.append("<br>");
        //8mine
        stringBuilder.append("mine:");
        stringBuilder.append(req.getContentType());
        stringBuilder.append("<br>");
        //9正文長度
        stringBuilder.append("正文長度:");
        stringBuilder.append(req.getContentLength());
        stringBuilder.append("<br>");
        //10獲得每一個查詢字符串的鍵值：
        stringBuilder.append("<h3>獲得每一個查詢字符串的鍵值：</h3>");
        Enumeration query = req.getParameterNames();
        while(query.hasMoreElements()) {
 
            String key = (String)query.nextElement();
            stringBuilder.append(key);
            stringBuilder.append(":");
            stringBuilder.append(req.getParameter(key));
            stringBuilder.append("<br>");
        }
        //11獲得頭部的鍵值
        stringBuilder.append("<h3>獲得頭部的鍵值：</h3>");
        Enumeration header = req.getHeaderNames();
        while(header.hasMoreElements()) {
 
            String key = (String)header.nextElement();
            stringBuilder.append(key);
            stringBuilder.append(":");
            stringBuilder.append(req.getHeader(key));
            stringBuilder.append("<br>");
        }
        resp.getWriter().write(stringBuilder.toString());
    }
}

結果：

?2.4Post請求信息的獲取

我們知道post請求的請求信息在http格式中的 body 部分當中，而 body 中的請求內容的格式是有很多種的，比如最常見的有：

1. x-www-form-urlencode格式，通過form表單或者postman構造。
2. json格式
3. form-data格式

x-www-form-urlencode格式：

k e y = v a l u e & k e y = v a l u e & . . . key=value\&key=value\&... k e y = v a l u e & k e y = v a l u e & . . .

form表單創建 x-www-form-urlencode格式 請求：

<!DOCTYPE html>
<html lang="ch">
<head>
    <meta charset="UTF-8">
    <title>post</title>
</head>
<body>
    <form action="./postParameter" method="post" accept-charset="utf-8">
        <span>userId</span>
        <input type="text" name="userId">
        <span>classId</span>
        <input type="text" name="classId">
        <input type="submit" value="提交">
    </form>
</body>
</html>

Servlet程序接收和處理請求：

對于 x-www-form-urlencode格式 請求可以直接使用 HttpServletRequest 中的 getParameter 方法依據 key 來獲取 value ，然后再將獲取到的數據返回，form表單構造的請求會自動跳轉頁面。

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/postParameter")
public class GetPostParameterServlet extends HttpServlet {
 
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
        //獲取post請求body請求中的參數
        //設置請求與響應編碼格式
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html; charset=utf8");
        //比如useId =   classId=
        String userId = req.getParameter("userId");
        String classId = req.getParameter("classId");
        //寫會數據
        resp.getWriter().write("userId=" + userId + ", " + "classId=" + classId);
    }
}

運行結果：

json格式:

{ \{ {

k e y : v a l u e , key:value, k e y : v a l u e ,

k e y : v a l u e , key:value, k e y : v a l u e ,

k e y : v a l u e , key:value, k e y : v a l u e ,

. . . ... . . .

} \} }

對于json格式，手動解析不容易，因為json里面的字段是可以嵌套的，但我們可以借助第三方庫來解析處理json，比如Jackson，Jackson依賴導入過程如下：

處理json請求步驟：

第一步，在前端js代碼中構造出格式為 json 格式的請求。

其中 ajax 構造 post 請求，使用 contentType 來說明請求的類型， data 屬性來設置 body 的內容。

<!DOCTYPE html>
<html lang="cn">
<head>
    <meta charset="UTF-8">
    <title>json</title>
</head>
<body>
    <!-- 前端HTML部分 -->
    <input type="text" id="userId"> 
    <input type="text" id="classId">
    <input type="button" id="submit" value="提交"> 
	<!-- 如果已經準備好本地的jQuery就導入本地的，否則可以找網上的jQuery cdn網絡路徑 -->
    <script src="./jquery3.6.0.js"></script>

    <script>
        let userIdInput = document.querySelector("#userId");
        let classIdInput = document.querySelector("#classId");
        let button = document.querySelector("#submit");

        button.onclick = function() {
   
            $.ajax({
   
                type : "post",
                url: "getJsonPost",
                contentType: "appliaction/json",
                data:JSON.stringify({
   
                    userId: userIdInput.value,
                    classId:classIdInput.value
                }),
                success: function(body){
   
                    console.log(body);
                }
            })
        }
    </script>
</body>
</html>

第二步，在java后端代碼中使用Jackson處理。

• 1）創建Jackson核心對象ObjectMapper對象。
• 2）讀取請求中的body信息，該過程通過ObjectMapper對象的 readValue 方法實現。
• 3）創建用來接受 json 數據的類。
• 4） readValue 方法的參數有兩個，第一個參數用來表示請求的來源，可以是路徑字符串，與可以是 InputSream 對象，也可以是 File 對象，第二個參數表示接收json數據的類對象。
• 5）處理并響應請求。

import com.fasterxml.jackson.databind.ObjectMapper;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

class User {
 
    public String userId;
    public String classId;
}
@WebServlet("/getJsonPost")
public class GetJsonPostServlet extends HttpServlet {
 
    //1.創建一個Jackson的核心對象
    private ObjectMapper objectMapper = new ObjectMapper();
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
        //格式
        resp.setContentType("text/html; charset=utf8");
        //處理
        //2.讀取body請求的內容，使用ObjectMapper對象的readValue方法來解析
        //就是將字符串轉換成java的對象，readValue方法的第一個參數可以是路徑字符串可以是輸入流對象，引入可以是File對象
        //第二個參數，表示需要將請求的json格式數據轉換成哪一個java對象
        User user = objectMapper.readValue(req.getInputStream(), User.class);
        System.out.println(user.userId);
        System.out.println(user.classId);
        resp.getWriter().write("userId=" + user.userId + "  ,classId=" + user.classId);
    }
}

運行結果：

readValue 方法基本原理：

1. 讀取json格式的數據，并解析成鍵值對。
2. 便利這些鍵值對，獲得 key ，并與所需傳入的對象中的屬性（反射）相比，如果 key 與屬性的名字相同，則把 key 對應的 value 賦值給這個屬性，否則就跳過，所有的鍵值對便利完后，這個對象差不多就被構造的差不多了。

?2.5響應的構造

案例1：設置響應狀態碼

設置方法很簡單，只需要調用 httpServletResponse 對象中的 setStatus 方法就可以了

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/status")
public class StatusServlet extends HttpServlet {
 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
        //格式
        resp.setContentType("text/html; charset=utf8");
        //設置狀態碼
        int status = 200;
        resp.setStatus(status);

        resp.getWriter().write("hello,這是" + status + "狀態碼的響應內容!");
    }
}

啟動程序，網頁顯示如下：

我把狀態碼修改為 404 ，網頁顯示如下：

那為什么不是之前我們所遇到的那種404頁面呢？這是因為我們設置的頁面響應內容就是 hello,這是404狀態碼的響應內容! ，可以理解為自定義的 404 狀態響應頁面，就像其他的網站，如果訪問不到頁面，顯示的提醒頁面也是不一樣的，比如b站的頁面是這個樣子的：

案例2：自動頁面刷新

自動頁面刷新只要在響應中設置一個header: Refresh就能實現頁面的定時刷新了，對于響應 header 的設置，我們可以通過 HttpServletResponse 對象中的 setHeader 方法來設置Refresh屬性和刷新頻率。

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/autorefresh")
public class AutoRefreshServlet extends HttpServlet {
 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
        //格式
        resp.setContentType("text/html; charset = utf8");
        //設置Refresh，第二個參數表示刷新頻率，單位是秒
        resp.setHeader("Refresh", "1");
        //響應
        resp.getWriter().write("時間戳：" + System.currentTimeMillis());
    }
}

效果：

案例3：重定向案例

第一步，設置狀態碼為 302 。

第二步，設置header:Location，調用 setHeader 方法時，第一個參數填 Location ，表示設置 header 字段為 Location ，第二個參數為重定向的目的地址，你要重定向到哪一個網址就傳入哪一個地址的字符串。

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/redirect")
public class RedirectServlet extends HttpServlet {
 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
        //格式
        resp.setContentType("text/html; charset = utf8");
        //設置狀態碼
        resp.setStatus(302);
        //設置重定向字段與地址,如跳轉到力扣官網
        resp.setHeader("Location", "https://leetcode.cn/");
    }
}

效果：

當然，servlet提供了更為簡便的重定向方法，就是使用 HttpServletResponse 類中的 sendRedirect 方法。

@WebServlet("/redirect")
public class RedirectServlet extends HttpServlet {
 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
        //格式
        resp.setContentType("text/html; charset = utf8");
        //設置狀態碼
//        resp.setStatus(302);
//        //設置重定向字段與地址,如跳轉到力扣官網
//        resp.setHeader("Location", "https://leetcode.cn/");
        resp.sendRedirect("https://leetcode.cn/");
    }
}

效果與上面第一種方法是一樣的。

原文：https://blog.csdn.net/m0_59139260/article/details/125578758