【学习条记】手写 Tomcat 二

目次
一、HTTP协议哀求格式
二、相应静态资源
1. 剖析哀求信息
创建剖析哀求类 HttpRequest
2. 创建静态资源目次 webs
3. 封装相应信息
创建静态资源处置惩罚器 StaticResourceHandler
创建相应类 HttpResponse
调用相应类相应数据
测试
静态资源的路径分析
三、作业
1. 绘制 哀求剖析类 HttpRequest 和相应类 HttpResponse 的封装流程图
2. 优化客户端的毗连

---

一、HTTP协议哀求格式

二、相应静态资源

在昨天的根本上，再进一步优化，可以大概相应HTML文件，图片等静态资源
在相应静态资源之前，我们要先确定客户端哀求的是哪个静态资源，是HTML页面照旧图片呢？
我们先打印一下客户端的哀求信息

可以看到，第一行也就是 哀求行 ，它有哀求方法，哀求URL和哀求协议
哀求URL就是须要哀求的资源

1. 剖析哀求信息

那怎样拿到 哀求的URL呢？然后根据哀求URL相应对应的资源
我们看一下 HTTP协议的哀求格式，不难发现，都是以回车符和换行符末了
以 回车符和换行符举行分割，然后再根据 空格 分割就可以拿到哀求URL了

创建剖析哀求类 HttpRequest

1. package com.shao.net;
3. import java.util.HashMap;
5. public class HttpRequest {
6.     /**
7.      * 请求信息
8.      */
9.     private String msg;
11.     /**
12.      * 请求行
13.      */
14.     private String requestLine;
15.     /**
16.      * 请求行的请求方法
17.      */
18.     private String requestMethod;
20.     /**
21.      * 请求行的请求URI，请求路径
22.      */
23.     private String requestURI;
24.     /**
25.      * 请求行的请求模块，例如：/index.html?a=1 请求模块为：/index.html
26.      */
27.     private String requestModule;
28.     /**
29.      * 请求行的请求协议
30.      */
31.     private String requestProtocol;
33.     /**
34.      * 存储请求头参数
35.      */
36.     private HashMap<String, String> requestHeaderParams = new HashMap<>();
38.     /**
39.      * 存储请求体参数
40.      */
41.     private HashMap<String, String> requestBodyParams = new HashMap<>();
43.     /**
44.      * 构造函数
45.      */
46.     public HttpRequest(String msg) {
47.         this.msg = msg;
49.         // 根据HTTP协议格式 分割请求信息
50.         String[] requestArr = msg.split("\r\n");
51.         // 把数组中的第一个元素赋值给请求行
52.         requestLine = requestArr[0];
55.         // 1. 解析请求行
56.         parseRequestLine();
58.         // 2. 解析请求头
59.         parseRequestHeader(requestArr);
61.         // 3. 解析请求体
62.         parseRequestBody();
63.     }
65.     // 1. 解析请求行
66.     private void parseRequestLine() {
68.         // 把请求行按空格分割
69.         String[] requestParts = requestLine.split(" ");
70.         // 请求方法
71.         requestMethod = requestParts[0];
72.         // 请求资源路径
73.         requestURI = requestParts[1];
74.         // 请求协议
75.         requestProtocol = requestParts[2];
77.         // 如果请求方法是GET，则根据 ? 号分割，获取请求模块，例如：/index.html?a=1 请求模块为：/index.html
78.         String[] split = requestURI.split("\\?");
79.         requestModule = split[0];
81.         System.out.println("请求方法：" + requestMethod);
82.         System.out.println("请求uri：" + requestURI);
83.         System.out.println("请求协议：" + requestProtocol);
84.         System.out.println("请求模块：" + requestModule);
86.     }
88.     // 2. 解析请求头
89.     private void parseRequestHeader(String[] requestArr) {
90.         // 检查请求数组，判断是否为空，判断有没有请求头
91.         if (requestArr == null || requestArr.length <= 1) {
92.             return;
93.         }
94.         // 遍历请求数组，从第二个元素开始，因为第一个元素是请求行
95.         for (int i = 1; i < requestArr.length; i++) {
96.             // 判断是否为空，如果为空，表示请求头结束，因为 HTTP 协议中，请求头和请求体之间有2个回车符 换行符
97.             String headerLine = requestArr[i];
98.             if (headerLine.length() == 0) {
99.                 break;
100.             }
101.             // 把请求头按 :  分割，获取请求头参数
102.             // 注意：这里需要使用 ": "，而不是 ":"
103.             String[] headerParts = headerLine.split(": ");
104.             // 判断请求头的格式是否正确
105.             if (headerParts.length >= 2) {
106.                 requestHeaderParams.put(headerParts[0], headerParts[1]);
107.             }
108.         }
109.         System.out.println("请求头参数：" + requestHeaderParams);
111.     }
113.     // 3. 解析请求体
114.     private void parseRequestBody() {
115.         // POST 方法的请求参数是在请求体，GET 方法的请求参数在请求行
116.         if (this.requestMethod.equalsIgnoreCase("POST")) {
117.             // 分割请求信息
118.             String[] split = msg.split("\r\n\r\n");
119.             // 如果分割后的长度 >= 2,表示有请求体
120.             if (split.length >= 2) {
121.                 // 分割请求体
122.                 splitRequestBody(split[1]);
123.             }
124.         } else if (this.requestMethod.equalsIgnoreCase("GET")) {
125.             // 把请求行按空格分割，获取请求参数
126.             String[] requestLineParts = this.requestLine.split(" ");
127.             String[] split = requestLineParts[1].split("\\?");
128.             if (split.length >= 2) {
129.                 // 分割请求体
130.                 splitRequestBody(split[1]);
131.             }
132.         }
133.         System.out.println("请求体参数：" + requestBodyParams);
134.     }
136.     private void splitRequestBody(String requestBody) {
137.         // 分割请求参数，例如：a=1&b=2&c=3
138.         String[] requestBodyParts = requestBody.split("&");
139.         // 遍历请求体
140.         for (int i = 0; i < requestBodyParts.length; i++) {
141.             String part = requestBodyParts[i];
142.             // 把请求参数按 = 分割，获取键值对，最多分割2部分，如果有多个 = ，只保留第一个 = 之前和之后的部分
143.             String[] keyValue = part.split("=", 2);
144.             if (keyValue.length == 2) {
145.                 requestBodyParams.put(keyValue[0], keyValue[1]);
146.             } else {
147.                 System.out.println("警告：非法格式的请求体：" + part);
148.             }
149.         }
150.     }
152.     /**
153.      * 获取
154.      * @return msg
155.      */
156.     public String getMsg() {
157.         return msg;
158.     }
160.     /**
161.      * 设置
162.      * @param msg
163.      */
164.     public void setMsg(String msg) {
165.         this.msg = msg;
166.     }
168.     /**
169.      * 获取
170.      * @return requestLine
171.      */
172.     public String getRequestLine() {
173.         return requestLine;
174.     }
176.     /**
177.      * 设置
178.      * @param requestLine
179.      */
180.     public void setRequestLine(String requestLine) {
181.         this.requestLine = requestLine;
182.     }
184.     /**
185.      * 获取
186.      * @return requestMethod
187.      */
188.     public String getRequestMethod() {
189.         return requestMethod;
190.     }
192.     /**
193.      * 设置
194.      * @param requestMethod
195.      */
196.     public void setRequestMethod(String requestMethod) {
197.         this.requestMethod = requestMethod;
198.     }
200.     /**
201.      * 获取
202.      * @return requestURI
203.      */
204.     public String getRequestURI() {
205.         return requestURI;
206.     }
208.     /**
209.      * 设置
210.      * @param requestURI
211.      */
212.     public void setRequestURI(String requestURI) {
213.         this.requestURI = requestURI;
214.     }
216.     /**
217.      * 获取
218.      * @return requestModule
219.      */
220.     public String getRequestModule() {
221.         return requestModule;
222.     }
224.     /**
225.      * 设置
226.      * @param requestModule
227.      */
228.     public void setRequestModule(String requestModule) {
229.         this.requestModule = requestModule;
230.     }
232.     /**
233.      * 获取
234.      * @return requestProtocol
235.      */
236.     public String getRequestProtocol() {
237.         return requestProtocol;
238.     }
240.     /**
241.      * 设置
242.      * @param requestProtocol
243.      */
244.     public void setRequestProtocol(String requestProtocol) {
245.         this.requestProtocol = requestProtocol;
246.     }
248.     /**
249.      * 获取
250.      * @return requestHeaderParams
251.      */
252.     public HashMap<String, String> getRequestHeaderParams() {
253.         return requestHeaderParams;
254.     }
256.     /**
257.      * 设置
258.      * @param requestHeaderParams
259.      */
260.     public void setRequestHeaderParams(HashMap<String, String> requestHeaderParams) {
261.         this.requestHeaderParams = requestHeaderParams;
262.     }
264.     /**
265.      * 获取
266.      * @return requestBodyParams
267.      */
268.     public HashMap<String, String> getRequestBodyParams() {
269.         return requestBodyParams;
270.     }
272.     /**
273.      * 设置
274.      * @param requestBodyParams
275.      */
276.     public void setRequestBodyParams(HashMap<String, String> requestBodyParams) {
277.         this.requestBodyParams = requestBodyParams;
278.     }
280.     public String toString() {
281.         return "HttpRequest{msg = " + msg + ", requestLine = " + requestLine + ", requestMethod = " + requestMethod + ", requestURI = " + requestURI + ", requestModule = " + requestModule + ", requestProtocol = " + requestProtocol + ", requestHeaderParams = " + requestHeaderParams + ", requestBodyParams = " + requestBodyParams + "}";
282.     }
283. }

复制代码

调用 HttpRequest 剖析哀求信息

游览器发送哀求

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

拿到了哀求uri，我们就可以根据 哀求uri 相应静态资源了
那这个静态资源放在哪儿呢？
2. 创建静态资源目次 webs

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

那如今 index.html 有了，怎么相应给客户端呢？
读取 index.html 文件，将读取到的内容发送到游览器，游览器会主动渲染页面
3. 封装相应信息

把相应信息的代码拿出来，单独放到一个类里，这个类就只须要相应数据
如答应以低沉代码的耦合度

在创建相应类之前有两个标题
1. 怎么确定哀求的是静态资源？动态资源一样平常须要操纵数据库
2. 相应的媒体范例怎么写？
如果相应的是图片，那么就须要修改为 Content-Type：image/jpeg 或 image/png 等
以是，就须要动态的判断相应的静态资源是什么媒体范例。
创建静态资源处置惩罚器 StaticResourceHandler

1. package com.shao.net;
3. import java.io.File;
4. import java.io.FileInputStream;
5. import java.io.IOException;
6. import java.nio.file.Files;
7. import java.nio.file.Paths;
9. public class StaticResourceHandler {
11.     // 常见静态资源扩展名
12.     private static final String[] staticExtensions = new String[]{".html", ".css", ".js", ".jpg", ".png", ".gif", ".ico", ".svg", ".pdf", ".txt"};
14.     /**
15.      * 判断是否静态资源
16.      * 如果是静态资源则返回 true ，否则返回 false
17.      */
18.     public static boolean isLikelyStaticResource(String fileName) {
20.         // 检查文件的扩展名是否存在于静态资源扩展名数组中
21.         for (String ext : staticExtensions) {
22.             if (fileName.endsWith(ext)) {
23.                 return true;
24.             }
25.         }
26.         return false;
27.     }
30.     /**
31.      * 根据文件路径获取文件内容
32.      */
33.     public static byte[] getFileContents(String filePath) {
34.         // 1. 获取文件对象
35.         File file = new File(filePath);
36.         // 2. 判断文件是否存在
37.         if (!file.exists()) {
38.             return null;
39.         }
41.         // 3. 获取文件内容
43.         // 定义一个字节数组，数组大小根据文件大小确定
44.         byte[] fileContents = new byte[0];
45.         try {
46.             FileInputStream fis = new FileInputStream(file);
48.             // fis.available() 是读取的文件的字节数
49.             fileContents = new byte[fis.available()];
51.             // 读取文件存放到 fileContents 数组中
52.             fis.read(fileContents);
54.             // 关闭文件输入流
55.             fis.close();
56.         } catch (Exception e) {
57.             e.printStackTrace();
58.         }
59.         return fileContents;
60.     }
62.     /**
63.      * 获取文件的媒体类型
64.      */
65.     public static String getFileMimeType(String filePath) {
66.         // 1 获取文件对象
67.         File file = new File(filePath);
69.         // 2 判断文件是否存在
70.         if (!file.exists()) {
71.             return "text/html";
72.         }
73.         // 3 获取文件的媒体类型
74.         String fileType = null;
75.         try {
76.             fileType = Files.probeContentType(Paths.get(filePath));
78.         } catch (IOException e) {
79.             e.printStackTrace();
80.         }
81.         return fileType;
82.     }
84. }

复制代码

创建相应类 HttpResponse

1. package com.shao.net;
3. import java.io.FileInputStream;
4. import java.io.IOException;
5. import java.io.OutputStream;
7. public class HttpResponse {
9.     /**
10.      * 输出流
11.      */
12.     private OutputStream os;
14.     /**
15.      * 解析请求信息的对象
16.      */
17.     private HttpRequest httpRequest;
19.     public HttpResponse(OutputStream os, HttpRequest httpRequest) {
20.         this.os = os;
21.         this.httpRequest = httpRequest;
22.     }
24.     public void response(String filePath) {
25.         //判断请求的是否为静态文件
26.         if (StaticResourceHandler.isLikelyStaticResource(httpRequest.getRequestModule())) {
27.             // 获取静态资源一般是 GET 请求方法
28.             if (httpRequest.getRequestMethod().equals("GET")) {
29.                 // 响应静态资源
30.                 responseStaticResource(filePath);
31.             }
32.         } else {
33.             // 处理动态请求
34.             System.out.println("请求动态资源");
35.         }
36.     }
38.     /**
39.      * 响应静态资源
40.      */
41.     private void responseStaticResource(String filePath) {
42.         // 读取文件
43.         byte[] fileContents = StaticResourceHandler.getFileContents(filePath);
45.         // 判断文件是否存在，不存在则返回 404 的页面
46.         if (fileContents == null) {
47.             try {
48.                 FileInputStream fis = new FileInputStream("webs/pages/not_Found404.html");
50.                 fileContents = new byte[fis.available()];
52.                 fis.read(fileContents);
54.                 fis.close();
55.             } catch (Exception e) {
56.                 e.printStackTrace();
57.             }
58.         }
60.         // 响应协议
61.         String protocol = httpRequest.getRequestProtocol();
62.         // 文件媒体类型
63.         String fileMimeType = StaticResourceHandler.getFileMimeType(filePath);
64.         try {
65.             os.write((protocol + " 200 OK\r\n").getBytes());
66.             os.write(("Content-Type: " + fileMimeType + "\r\n").getBytes());
67.             os.write(("Content-Length: " + fileContents.length + "\r\n").getBytes());
68.             os.write("\r\n".getBytes());
69.             os.write(fileContents);
70.             os.flush();
71.             System.out.println("响应成功");
72.             os.close();
74.         } catch (IOException e) {
75.             e.printStackTrace();
76.         }
77.     }
78. }

复制代码

调用相应类相应数据

测试

静态资源的路径分析

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

三、作业

1. 绘制 哀求剖析类 HttpRequest 和相应类 HttpResponse 的封装流程图

2. 优化客户端的毗连

如今只有主线程处置惩罚客户端毗连，如果同一时间有多个客户端发起毗连，同一时间只能处置惩罚一个客户端的毗连，如许服从不高，怎么处置惩罚？
办理方案是来一个客户端毗连就创建一条线程行止置惩罚



免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金