訪問html頁面

如果我們想訪問html頁面其實就是將本地的html文件以流的方式響應給前端即可，下面我們對HttpResponseServlet這個類做一些改造

package com.tomcatServer.domain;

import com.tomcatServer.utils.ScanUtil;

import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * http servlet響應
 *
 * @author ez4sterben
 * @date 2023/08/15
 */
public class HttpServletResponse {

    private final PrintWriter out;

    private static final String response;

    private static final String htmlResponse;

    public HttpServletResponse(PrintWriter out) {
        this.out = out;
    }

    static {
        response = "HTTP/1.1 200 OK\r\n" +
                "Content-Type: text/plain\r\n" +
                "\r\n";
        htmlResponse = "HTTP/1.1 200 OK\r\n" +
                "Content-Type: text/html\r\n" +
                "\r\n";
    }


    /**
     * 寫
     *
     * @param content 內容
     */
    public void write(String content) {
        out.println(response + content);
    }

    /**
     * 編寫html
     *
     * @param htmlFileName html文件名字
     * @throws IOException ioexception
     */
    public void writeHtml(String htmlFileName) throws IOException {
        Path path = Paths.get(ScanUtil.WEB_APP_PATH + "\\" + htmlFileName);
        byte[] bytes = Files.readAllBytes(path);
        out.println(htmlResponse + new String(bytes, StandardCharsets.UTF_8));
    }
}

writeHtml這個方法將會讀取webApp下面的html文件，注意只讀取下面一級文件中的html文件，然后將這個文件以二進制流的形式轉換成字符串拼接到上面定義的html格式的響應頭。

處理靜態(tài)資源請求

當我們有了解析html文件的方法后，下面要做的就是處理靜態(tài)資源，也就是判斷一下請求路徑中是否有.html這個字符串，有的話就把這次請求當做靜態(tài)資源請求處理，沒有的話再交給GET或者POST請求。這個邏輯將添加在SocketStore中，下面展示更改玩的SocketStore代碼

package com.tomcatServer.socket;

import com.tomcatServer.domain.HttpServletRequest;
import com.tomcatServer.domain.HttpServletResponse;
import com.tomcatServer.utils.ScanUtil;
import com.tomcatServer.utils.ServletUtil;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Map;

/**
 * 套接字存儲
 *
 * @author ez4sterben
 * @date 2023/08/15
 */
public class SocketStore {

    private static ServerSocket socket;

    public static void connect(Integer port) throws IOException {
        socket = new ServerSocket(port);
    }

    public static void close() throws IOException {
        socket.close();
    }

    public static ServerSocket getSocket() {
        return socket;
    }


    /**
     * 處理請求
     *
     * @throws IOException ioexception
     */
    public static void handleRequest(Socket accept) throws IOException {
        // 獲取輸入輸出流
        BufferedReader in = new BufferedReader(new InputStreamReader(accept.getInputStream()));
        PrintWriter out = new PrintWriter(accept.getOutputStream(), true);
        // 定義字符串接收Http協議內容
        String inputLine;
        StringBuilder requestData = new StringBuilder();
        // 讀取數據
        while ((inputLine = in.readLine()) != null && !inputLine.isEmpty()) {
            requestData.append(inputLine).append("\r\n");
        }
        // 解析request param
        String url = requestData.toString().split(" ")[1];
        // 處理靜態(tài)資源
        if(url.contains(".html")){
            String staticSourceName = (url.split(".html")[0] + ".html").substring(1);
            HttpServletResponse response = new HttpServletResponse(out);
            response.writeHtml(staticSourceName);
        }else {
            // 處理GET與POST請求
            if (!requestData.toString().trim().equals("")){
                handleGetAndPostReuqest(in, out, String.valueOf(requestData));
            }
        }
        // 關閉資源
        accept.close();
    }

    /**
     * 處理post請求
     *
     * @param in          在
     * @param requestData 請求數據
     * @throws IOException ioexception
     */
    private static void handleGetAndPostReuqest(BufferedReader in,PrintWriter out, String requestData) throws IOException {
        // 解析request param
        String url = requestData.split(" ")[1];
        String[] urlContent = url.split("\\?");
        String requestPath = urlContent[0];
        String params = urlContent[1];
        String[] paramsKeyValue = params.split("=");

        // 設置請求參數
        HttpServletRequest request = new HttpServletRequest();
        Map<String, String> paramsMap = request.getParams();
        for (int i = 0; i < paramsKeyValue.length; i += 2) {
            paramsMap.put(paramsKeyValue[i],paramsKeyValue[i+1]);
        }
        if (requestData.contains("POST")) {
            // 解析request body
            int contentLength = Integer.parseInt(requestData.split("Content-Length: ")[1].split("\r\n")[0]);
            StringBuilder requestBody = new StringBuilder();
            for (int i = 0; i < contentLength; i++) {
                requestBody.append((char) in.read());
            }

            // 設置request body
            request.setRequestBody(String.valueOf(requestBody));

            // 設置響應內容
            HttpServletResponse response = new HttpServletResponse(out);
            ServletUtil.invokePost(requestPath,request,response);
        }
        if (requestData.contains("GET")){
            // 設置響應內容
            HttpServletResponse response = new HttpServletResponse(out);
            ServletUtil.invokeGet(requestPath,request,response);
        }
    }

}

訪問測試

接下來我們在index.html里面寫點東西并訪問一下試試

http://localhost:8080/index.html

路由支持

其實剛才完成這個功能的時候就會發(fā)現，如何訪問子目錄里面的html呢？
這里其實就要寫一個小方法來支持路由重定向了，下面編寫一個HttpUtil

package com.tomcatServer.utils;

import com.tomcatServer.domain.HttpServletRequest;
import com.tomcatServer.domain.HttpServletResponse;

import java.io.IOException;

public class HttpUtil {

    private final String redirectPath;

    public HttpUtil(String redirectPath) {
        this.redirectPath = redirectPath;
    }
    public void forward(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.writeHtml(redirectPath);
    }
}

對HttpServletRequest做一些改進，提供一個加載靜態(tài)資源的方法。

    public HttpUtil getStaticSource(String path){
        return new HttpUtil(path);
    }

其實這樣我們的功能就完成了，寫一個servlet以及html來測試一下

package tomcatProject.com.ez4sterben.servlet;

import com.tomcatServer.annotation.WebServlet;
import com.tomcatServer.domain.HttpServlet;
import com.tomcatServer.domain.HttpServletRequest;
import com.tomcatServer.domain.HttpServletResponse;

import java.io.IOException;

@WebServlet("/router")
public class RouterServlet extends HttpServlet {

    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        request.getStaticSource("WEB-INF/page/"+request.getParam("path")+".html").forward(request, response);
    }

    @Override
    public void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
        doGet(request, response);
    }
}

多線程改進

為什么要在這里談多線程改進呢，其實是因為我們最近本的接收請求，響應請求，響應頁面以及完成了，接下來要考慮的就是如何支持并發(fā)處理請求，如何配置并發(fā)數，如何配置端口等優(yōu)化問題。

如果想實現并發(fā)處理請求的話，實際上只需要預先定義一個線程池即可，把處理請求的方法交給一個任務類并且實現Runnable接口，當然我們后面會再優(yōu)化這種方案。

package com.tomcatServer.task;

import com.tomcatServer.socket.SocketStore;

import java.io.IOException;
import java.net.Socket;

public class RequestTask implements Runnable{

    private final Socket accept;

    public RequestTask(Socket accept) {
        this.accept = accept;
    }

    @Override
    public void run() {
        try {
            SocketStore.handleRequest(accept);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

        ...
        public static ExecutorService threadPool;
        ...
		// 5.初始化線程池
        threadPool = Executors.newFixedThreadPool(10);

        // 6.處理http請求
        try {
            SocketStore.connect(PORT);
            while (true){
                Socket accept = SocketStore.getSocket().accept();
                if (accept != null){
                    threadPool.submit(new RequestTask(accept));
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            SocketStore.close();
        }

【仿寫tomcat】六、解析xml文件配置端口、線程池核心參數文章來源地址http://www.zghlxwxcb.cn/news/detail-655776.html

到了這里，關于【仿寫tomcat】五、響應靜態(tài)資源（訪問html頁面）、路由支持以及多線程改進的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！