【学习笔记】手写Tomcat 二

6 阅读 0 评论 0 点赞

响应静态资源

HTTP协议请求格式

创建静态资源处理器 StaticResourceHandler

1. 绘制请求解析类 HttpRequest 和响应类 HttpResponse 的封装流程图

2. 优化客户端的连接

响应静态资源

在昨天的基础上，再进一步优化，能够响应HTML文件，图片等静态资源

在响应静态资源之前，我们要先确定客户端请求的是哪个静态资源，是HTML页面还是图片呢？

我们先打印一下客户端的请求信息

HTTP协议请求格式

可以看到，第一行也就是请求行，它有请求方法，请求URL和请求协议

请求URL就是需要请求的资源

1. 解析请求信息

那如何拿到请求的URL呢？然后根据请求URL响应对应的资源

我们看一下 HTTP协议的请求格式，不难发现，都是以回车符和换行符结尾

以回车符和换行符进行分割，然后再根据空格分割就可以拿到请求URL了

创建解析请求类 HttpRequest

package com.shao.net;

import java.util.HashMap;

public class HttpRequest {
    /**
     * 请求信息
     */
    private String msg;

    /**
     * 请求行
     */
    private String requestLine;
    /**
     * 请求行的请求方法
     */
    private String requestMethod;

    /**
     * 请求行的请求URI，请求路径
     */
    private String requestURI;
    /**
     * 请求行的请求模块，例如：/index.html?a=1 请求模块为：/index.html
     */
    private String requestModule;
    /**
     * 请求行的请求协议
     */
    private String requestProtocol;

    /**
     * 存储请求头参数
     */
    private HashMap<String, String> requestHeaderParams = new HashMap<>();

    /**
     * 存储请求体参数
     */
    private HashMap<String, String> requestBodyParams = new HashMap<>();

    /**
     * 构造函数
     */
    public HttpRequest(String msg) {
        this.msg = msg;

        // 根据HTTP协议格式 分割请求信息
        String[] requestArr = msg.split("\r\n");
        // 把数组中的第一个元素赋值给请求行
        requestLine = requestArr[0];


        // 1. 解析请求行
        parseRequestLine();

        // 2. 解析请求头
        parseRequestHeader(requestArr);

        // 3. 解析请求体
        parseRequestBody();
    }

    // 1. 解析请求行
    private void parseRequestLine() {

        // 把请求行按空格分割
        String[] requestParts = requestLine.split(" ");
        // 请求方法
        requestMethod = requestParts[0];
        // 请求资源路径
        requestURI = requestParts[1];
        // 请求协议
        requestProtocol = requestParts[2];

        // 如果请求方法是GET，则根据 ? 号分割，获取请求模块，例如：/index.html?a=1 请求模块为：/index.html
        String[] split = requestURI.split("\\?");
        requestModule = split[0];

        System.out.println("请求方法：" + requestMethod);
        System.out.println("请求uri：" + requestURI);
        System.out.println("请求协议：" + requestProtocol);
        System.out.println("请求模块：" + requestModule);

    }

    // 2. 解析请求头
    private void parseRequestHeader(String[] requestArr) {
        // 检查请求数组，判断是否为空，判断有没有请求头
        if (requestArr == null || requestArr.length <= 1) {
            return;
        }
        // 遍历请求数组，从第二个元素开始，因为第一个元素是请求行
        for (int i = 1; i < requestArr.length; i++) {
            // 判断是否为空，如果为空，表示请求头结束，因为 HTTP 协议中，请求头和请求体之间有2个回车符 换行符
            String headerLine = requestArr[i];
            if (headerLine.length() == 0) {
                break;
            }
            // 把请求头按 :  分割，获取请求头参数
            // 注意：这里需要使用 ": "，而不是 ":"
            String[] headerParts = headerLine.split(": ");
            // 判断请求头的格式是否正确
            if (headerParts.length >= 2) {
                requestHeaderParams.put(headerParts[0], headerParts[1]);
            }
        }
        System.out.println("请求头参数：" + requestHeaderParams);

    }

    // 3. 解析请求体
    private void parseRequestBody() {
        // POST 方法的请求参数是在请求体，GET 方法的请求参数在请求行
        if (this.requestMethod.equalsIgnoreCase("POST")) {
            // 分割请求信息
            String[] split = msg.split("\r\n\r\n");
            // 如果分割后的长度 >= 2,表示有请求体
            if (split.length >= 2) {
                // 分割请求体
                splitRequestBody(split[1]);
            }
        } else if (this.requestMethod.equalsIgnoreCase("GET")) {
            // 把请求行按空格分割，获取请求参数
            String[] requestLineParts = this.requestLine.split(" ");
            String[] split = requestLineParts[1].split("\\?");
            if (split.length >= 2) {
                // 分割请求体
                splitRequestBody(split[1]);
            }
        }
        System.out.println("请求体参数：" + requestBodyParams);
    }

    private void splitRequestBody(String requestBody) {
        // 分割请求参数，例如：a=1&b=2&c=3
        String[] requestBodyParts = requestBody.split("&");
        // 遍历请求体
        for (int i = 0; i < requestBodyParts.length; i++) {
            String part = requestBodyParts[i];
            // 把请求参数按 = 分割，获取键值对，最多分割2部分，如果有多个 = ，只保留第一个 = 之前和之后的部分
            String[] keyValue = part.split("=", 2);
            if (keyValue.length == 2) {
                requestBodyParams.put(keyValue[0], keyValue[1]);
            } else {
                System.out.println("警告：非法格式的请求体：" + part);
            }
        }
    }

    /**
     * 获取
     * @return msg
     */
    public String getMsg() {
        return msg;
    }

    /**
     * 设置
     * @param msg
     */
    public void setMsg(String msg) {
        this.msg = msg;
    }

    /**
     * 获取
     * @return requestLine
     */
    public String getRequestLine() {
        return requestLine;
    }

    /**
     * 设置
     * @param requestLine
     */
    public void setRequestLine(String requestLine) {
        this.requestLine = requestLine;
    }

    /**
     * 获取
     * @return requestMethod
     */
    public String getRequestMethod() {
        return requestMethod;
    }

    /**
     * 设置
     * @param requestMethod
     */
    public void setRequestMethod(String requestMethod) {
        this.requestMethod = requestMethod;
    }

    /**
     * 获取
     * @return requestURI
     */
    public String getRequestURI() {
        return requestURI;
    }

    /**
     * 设置
     * @param requestURI
     */
    public void setRequestURI(String requestURI) {
        this.requestURI = requestURI;
    }

    /**
     * 获取
     * @return requestModule
     */
    public String getRequestModule() {
        return requestModule;
    }

    /**
     * 设置
     * @param requestModule
     */
    public void setRequestModule(String requestModule) {
        this.requestModule = requestModule;
    }

    /**
     * 获取
     * @return requestProtocol
     */
    public String getRequestProtocol() {
        return requestProtocol;
    }

    /**
     * 设置
     * @param requestProtocol
     */
    public void setRequestProtocol(String requestProtocol) {
        this.requestProtocol = requestProtocol;
    }

    /**
     * 获取
     * @return requestHeaderParams
     */
    public HashMap<String, String> getRequestHeaderParams() {
        return requestHeaderParams;
    }

    /**
     * 设置
     * @param requestHeaderParams
     */
    public void setRequestHeaderParams(HashMap<String, String> requestHeaderParams) {
        this.requestHeaderParams = requestHeaderParams;
    }

    /**
     * 获取
     * @return requestBodyParams
     */
    public HashMap<String, String> getRequestBodyParams() {
        return requestBodyParams;
    }

    /**
     * 设置
     * @param requestBodyParams
     */
    public void setRequestBodyParams(HashMap<String, String> requestBodyParams) {
        this.requestBodyParams = requestBodyParams;
    }

    public String toString() {
        return "HttpRequest{msg = " + msg + ", requestLine = " + requestLine + ", requestMethod = " + requestMethod + ", requestURI = " + requestURI + ", requestModule = " + requestModule + ", requestProtocol = " + requestProtocol + ", requestHeaderParams = " + requestHeaderParams + ", requestBodyParams = " + requestBodyParams + "}";
    }
}

调用 HttpRequest 解析请求信息

游览器发送请求

打印解析后的请求信息，可以看到请求的静态资源是 /index.html

拿到了请求uri，我们就可以根据请求uri 响应静态资源了

那这个静态资源放在哪儿呢？

2. 创建静态资源目录 webs

创建一个 HTML 文件，内容先写英文，写中文需要在响应头加上 UTF-8 字符编码

那现在 index.html 有了，怎么响应给客户端呢？

读取 index.html 文件，将读取到的内容发送到游览器，游览器会自动渲染页面

3. 封装响应信息

把响应信息的代码拿出来，单独放到一个类里，这个类就只需要响应数据

这样可以降低代码的耦合度

在创建响应类之前有两个问题

1. 怎么确定请求的是静态资源？动态资源一般需要操作数据库

2. 响应的媒体类型怎么写？

如果响应的是图片，那么就需要修改为 Content-Type：image/jpeg 或 image/png 等

所以，就需要动态的判断响应的静态资源是什么媒体类型。

创建静态资源处理器 StaticResourceHandler

package com.shao.net;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class StaticResourceHandler {

    // 常见静态资源扩展名
    private static final String[] staticExtensions = new String[]{".html", ".css", ".js", ".jpg", ".png", ".gif", ".ico", ".svg", ".pdf", ".txt"};

    /**
     * 判断是否静态资源
     * 如果是静态资源则返回 true ，否则返回 false
     */
    public static boolean isLikelyStaticResource(String fileName) {

        // 检查文件的扩展名是否存在于静态资源扩展名数组中
        for (String ext : staticExtensions) {
            if (fileName.endsWith(ext)) {
                return true;
            }
        }
        return false;
    }


    /**
     * 根据文件路径获取文件内容
     */
    public static byte[] getFileContents(String filePath) {
        // 1. 获取文件对象
        File file = new File(filePath);
        // 2. 判断文件是否存在
        if (!file.exists()) {
            return null;
        }

        // 3. 获取文件内容

        // 定义一个字节数组，数组大小根据文件大小确定
        byte[] fileContents = new byte[0];
        try {
            FileInputStream fis = new FileInputStream(file);

            // fis.available() 是读取的文件的字节数
            fileContents = new byte[fis.available()];

            // 读取文件存放到 fileContents 数组中
            fis.read(fileContents);

            // 关闭文件输入流
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return fileContents;
    }

    /**
     * 获取文件的媒体类型
     */
    public static String getFileMimeType(String filePath) {
        // 1 获取文件对象
        File file = new File(filePath);

        // 2 判断文件是否存在
        if (!file.exists()) {
            return "text/html";
        }
        // 3 获取文件的媒体类型
        String fileType = null;
        try {
            fileType = Files.probeContentType(Paths.get(filePath));

        } catch (IOException e) {
            e.printStackTrace();
        }
        return fileType;
    }

}

创建响应类 HttpResponse

package com.shao.net;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;

public class HttpResponse {

    /**
     * 输出流
     */
    private OutputStream os;

    /**
     * 解析请求信息的对象
     */
    private HttpRequest httpRequest;

    public HttpResponse(OutputStream os, HttpRequest httpRequest) {
        this.os = os;
        this.httpRequest = httpRequest;
    }

    public void response(String filePath) {
        //判断请求的是否为静态文件
        if (StaticResourceHandler.isLikelyStaticResource(httpRequest.getRequestModule())) {
            // 获取静态资源一般是 GET 请求方法
            if (httpRequest.getRequestMethod().equals("GET")) {
                // 响应静态资源
                responseStaticResource(filePath);
            }
        } else {
            // 处理动态请求
            System.out.println("请求动态资源");
        }
    }

    /**
     * 响应静态资源
     */
    private void responseStaticResource(String filePath) {
        // 读取文件
        byte[] fileContents = StaticResourceHandler.getFileContents(filePath);

        // 判断文件是否存在，不存在则返回 404 的页面
        if (fileContents == null) {
            try {
                FileInputStream fis = new FileInputStream("webs/pages/not_Found404.html");

                fileContents = new byte[fis.available()];

                fis.read(fileContents);

                fis.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // 响应协议
        String protocol = httpRequest.getRequestProtocol();
        // 文件媒体类型
        String fileMimeType = StaticResourceHandler.getFileMimeType(filePath);
        try {
            os.write((protocol + " 200 OK\r\n").getBytes());
            os.write(("Content-Type: " + fileMimeType + "\r\n").getBytes());
            os.write(("Content-Length: " + fileContents.length + "\r\n").getBytes());
            os.write("\r\n".getBytes());
            os.write(fileContents);
            os.flush();
            System.out.println("响应成功");
            os.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

然后就可以调用响应类了

测试

静态资源的路径说明

可以直接复制文件的相对路径

作业

1. 绘制请求解析类 HttpRequest 和响应类 HttpResponse 的封装流程图

2. 优化客户端的连接

现在只有主线程处理客户端连接，如果同一时刻有多个客户端发起连接，同一时间只能处理一个客户端的连接，这样效率不高，怎么处理？

解决方案是来一个客户端连接就创建一条线程去处理

本站资源均来自互联网，仅供研究学习，禁止违法使用和商用，产生法律纠纷本站概不负责！如果侵犯了您的权益请与我们联系！

转载请注明出处：免费源码网-免费的源码资源网站 » 【学习笔记】手写Tomcat 二

点赞(0) 打赏

本文分类：文章资讯
本文标签：【学习笔记】手写Tomcat 二
浏览次数：6 次浏览
本文链接：https://freeymw.com/article/27628.html

上一篇 > 「OC」事件点击demo合集
下一篇 > 代理模式详解：静态代理与动态代理的实现

评论列表共有 0 条评论

暂无评论

【学习笔记】手写Tomcat 二

响应静态资源

HTTP协议请求格式

1. 解析请求信息

创建解析请求类 HttpRequest

2. 创建静态资源目录 webs

3. 封装响应信息

创建静态资源处理器 StaticResourceHandler

创建响应类 HttpResponse

然后就可以调用响应类了

测试

静态资源的路径说明

作业

1. 绘制 请求解析类 HttpRequest 和响应类 HttpResponse 的封装流程图

2. 优化客户端的连接

评论列表 共有 0 条评论

发表评论 取消回复

1. 绘制请求解析类 HttpRequest 和响应类 HttpResponse 的封装流程图

评论列表共有 0 条评论

发表评论取消回复