目录
响应静态资源
HTTP协议请求格式
1. 解析请求信息
创建解析请求类 HttpRequest
2. 创建静态资源目录 webs
3. 封装响应信息
创建静态资源处理器 StaticResourceHandler
创建响应类 HttpResponse
作业
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. 优化客户端的连接
现在只有主线程处理客户端连接，如果同一时刻有多个客户端发起连接，同一时间只能处理一个客户端的连接，这样效率不高，怎么处理？
解决方案是来一个客户端连接就创建一条线程去处理
