当前位置：首页 > news >正文

JAVAWeb08-手动实现 Tomcat 底层机制+ 自己设计 Servlet

news 2025/7/12 17:50:12

1. 前言

先看一个小案例，引出对 Tomcat 底层实现思考

1.1 完成小案例

在这里插入图片描述

● 快速给小伙伴完成这个小案例
0. 我们准备使用 Maven 来创建一个 WEB 项目, 老师先简单给小伙伴介绍一下 Maven 是什么, 更加详细的使用，我们还会细讲, 现在先使用一把

先创建一个 Maven 的 Web 项目 hsp-tomcat

补充：如何配置阿里 maven 镜像
(1) 把 maven的安装目录\conf\settings.xml 拷贝默认的 maven 配置目录
(2) C:\Users\Administrator.m2 目录 settings.xml
(3) 修改 C:\Users\Administrator.m2\settings.xml , 增加如下的部分

<mirrors>
<!-- mirror
| Specifies a repository mirror site to use instead of a given repository. The
repository that
| this mirror serves has an ID that matches the mirrorOf element of this mirror.
IDs are used
| for inheritance and direct lookup purposes, and must be unique across the
set of mirrors. |
<mirror>
<id>mirrorId</id>
<mirrorOf>repositoryId</mirrorOf>
<name>Human Readable Name for this Mirror.</name>
<url>http://my.repository.com/repo/path</url>
</mirror>
--><mirror><id>alimaven</id><name>aliyun maven</name><url>http://maven.aliyun.com/nexus/content/groups/public/</url><mirrorOf>central</mirrorOf></mirror>
</mirrors>

(4) 到此 ok

修改 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><maven.compiler.source>1.8</maven.compiler.source><maven.compiler.target>1.8</maven.compiler.target></properties><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.11</version><scope>test</scope></dependency><!--解读1. dependency 表示依赖, 也就是我们这个项目需要依赖的 jar 包2. groupId 和 artifactId 被统称为坐标, 是为了去定位这个项目/jar3. groupId: 一般是公司 比如 com.baidu , 这里是 avax.servlet4. artifactId 一般是项目名, 这里是 javax.servlet-api5. 这样的化就可以定位一个 jar 包6. version 表示你引入到我们项目的 jar 包的版本是 3.1.07. scope: 表示作用域，也就是你引入的 jar 包的作用范围8. provided 表示在 tomcat 本身是有这个 jar 的，因此在编译,测试使用，但是在打包发布就不用要带上9. 在默认情况下, 引入的 jar 会到 中央仓库去下载 https://mvnrepository.com/10. 会下载到哪里到你指定的目录 C:\Users\Administrator\.m2\repository11. 有时为了下载更快, 往往配置镜像,12. 在 默 认 的 路 径 下 拷 贝 一 份 setting.xml 到C:\Users\Administrator\.m2\settings.xml13. 指定默认的阿里云镜像<mirrors><mirror><id>alimaven</id><name>aliyun maven</name><url>http://maven.aliyun.com/nexus/content/groups/public/</url><mirrorOf>central</mirrorOf></mirror></mirrors>--><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>3.1.0</version><scope>provided</scope></dependency></dependencies>

创建 cal.html

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>计算器</title>
</head>
<body>
<h1>计算器</h1>
<form action="/calServlet" method="get">num1:<input type="text" name="num1"><br/>num2:<input type="text" name="num2"><br/><input type="submit" value="提交">
</form>
</body>
</html>

创建 java 目录，存放 java 源文件
创建 CalServlet.java
修改 web.xml , 配置 Servlet

<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app><display-name>Archetype Created Web Application</display-name><servlet><servlet-name>CalServlet</servlet-name><servlet-class>com.hspedu.servlet.CalServlet</servlet-class></servlet><servlet-mapping><servlet-name>CalServlet</servlet-name><url-pattern>/calServlet</url-pattern></servlet-mapping>
</web-app>

修改 CalServlet.java, 完成计算任务

public class CalServlet extends HttpServlet {protected void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {//接收提交的数据进行计算//复制当前行 ctrl+alt+下光标String strNum1 = request.getParameter("num1");String strNum2 = request.getParameter("num2");//把strNum1 和 strNum2 转成 intint num1 = WebUtils.parseInt(strNum1, 0);int num2 = WebUtils.parseInt(strNum2, 0);int result = num1 + num2;response.setContentType("text/html;charset=utf-8");PrintWriter writer = response.getWriter();writer.print("<h1>" + num1 + " + " + num2 + " = " + result + "<h1>");writer.flush();writer.close();}protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {doPost(request, response);}
}

创建工具类 WebUtils.java

public class WebUtils {/*** 将一个字符串数字，转成 int, 如果转换失败，就返回传入 defaultVal* @param strNum* @param defaultVal* @return*/public static int parseInt(String strNum, int defaultVal) {try {return Integer.parseInt(strNum);} catch (NumberFormatException e) {System.out.println(strNum + " 格式不对，转换失败");}return defaultVal;}}

配置 tomcat
略。。。
启动 tomcat
浏览器访问: http://localhost:8080/cal.html
完成测试

maven 中央仓库 : https://mvnrepository.com/

1.2 思考

问题: Tomcat 底层实现和调用到 Servlet 流程?

我们的目标: 不用 Tomcat, 不用系统提供的 Servlet, 模拟 Tomcat 底层实现并能调用我们自己设计的 Servle, 也能完成相同的功能

1.3 Tomcat 整体架构分析

1.3.1 一图胜千言

● 说明: Tomcat 有三种运行模式（BIO, NIO, APR）, 因为老师核心讲解的是 Tomcat 如何接收客户端请求，解析请求, 调用 Servlet , 并返回结果的机制流程, 采用 BIO 线程模型来模拟.[绘图]
在这里插入图片描述

2. 手动实现 Tomcat 底层机制+ 自己设计 Servlet

2.1 实现任务阶段 1

编写自己 Tomcat, 能给浏览器返回 Hi, Hspedu

基于 socket 开发服务端-流程:
在这里插入图片描述

2.1.1 需求分析/图解

需求分析如图, 浏览器请求 http://localhost:8080/??, 服务端返回 hi , hspedu

2.1.2 分析+代码实现

● 分析示意图
在这里插入图片描述
● 代码实现

创建 TomcatV1.java

/*** 这是第一个版本的tomcat ,可以完成，接收浏览器的请求，并返回信息*/
public class HspTomcatV1 {public static void main(String[] args) throws IOException {//1. 创建ServerSocket, 在 8080端口监听ServerSocket serverSocket = new ServerSocket(8080);System.out.println("=======mytomcat在8080端口监听======");while (!serverSocket.isClosed()) {//等待浏览器/客户端的连接//如果有连接来，就创建一个socket//这个socket就是服务端和浏览器端的连接/通道Socket socket = serverSocket.accept();//先接收浏览器发送的数据//inputStream 是字节流=> BufferedReader(字符流)//java基础 IO , 第19章InputStream inputStream = socket.getInputStream();BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(inputStream, "utf-8"));String mes = null;System.out.println("=======接收到浏览器发送的数据=======");//循环的读取while ((mes = bufferedReader.readLine()) != null) {//判断mes的长度是否为0：判断字符串长度是否为0的作用是为了处理HTTP请求头和请求体之间的空行。if (mes.length() == 0) { break;//退出while}System.out.println(mes);}//我们的tomcat会送-http响应方式OutputStream outputStream = socket.getOutputStream();//构建一个http响应的头//\r\n 表示换行//http响应体，需要前面有两个换行 \r\n\r\nString respHeader = "HTTP/1.1 200 OK\r\n" +"Content-Type: text/html;charset=utf-8\r\n\r\n";String resp = respHeader + "hi, hspedu 韩顺平教育";System.out.println("========我们的tomcat 给浏览器会送的数据======");System.out.println(resp);outputStream.write(resp.getBytes());//将resp字符串以byte[] 方式返回outputStream.flush();outputStream.close();inputStream.close();socket.close();}}
}

细节说明：
1.判断字符串长度是否为0的作用是为了处理HTTP请求头和请求体之间的空行。
在HTTP请求中，请求头和请求体之间必须要有一个空行，表示请求头已经结束，请求体开始。因此，在读取HTTP请求时，需要先读取请求头并解析出请求信息，然后再读取请求体部分。而读取请求头时，每个请求头字段都是以冒号和空格分隔的键值对形式出现的，如果读取到的一行请求头字段的长度为0，就表明请求头已经结束了。此时就可以退出循环，继续处理请求体的内容了。
因此，为了在读取HTTP请求时正确地处理请求头和请求体之间的空行，需要添加判断字符串长度是否为0的逻辑。

2.在HTTP协议中，每行信息都以"\r\n"（回车+换行）作为结束符，表示该行信息结束，并让浏览器接收下一个信息。
所以在构造HTTP响应头部时，需要在每行信息后添加"\r\n"。而在Java中，“\n"表示换行，即使只写”\n"在大多数情况下也能正常工作，但是使用"\r\n"会更加规范和严谨，因为在Windows系统中，只用"\n"可能不会被认为是换行符，而使用"\r\n"则能保证适用于所有操作系统。
因此，这段代码中，在回复客户端的HTTP响应头中使用了"\r\n"作为结束符号，确保HTTP响应头的格式符合HTTP协议的规范。

测试浏览器： http://localhost:8080/

2.1.3 问题分析

没有使用 BIO 线程模型，没有实现多线程，性能差

2.2 实现任务阶段 2

使用 BIO 线程模型，支持多线程

2.2.1 BIO 线程模型介绍

在这里插入图片描述

补充：
1.BIO是阻塞式I/O（Blocking I/O）的缩写，是Java网络编程中常用的一种I/O模型。它指的是在进行网络数据读写时，当用户线程发起了一个I/O操作（如读取数据），该线程会一直等待直到操作完成并返回结果，期间会一直阻塞在那里，无法做其他事情。与之相对的是非阻塞式I/O（NIO）和异步I/O（AIO）两种模型。
BIO模型是传统的线程池模型，即一个请求对应一个线程。在BIO模型中，一个客户端请求到来时，服务器会开启一个新的线程去处理这个请求，直到整个请求处理完毕才会退出线程。这种模型实现简单，易于理解，但同时也会带来一些问题，例如线程池大小的限制、线程上下文切换等问题。当线程池达到最大线程数时，新的请求就会被拒绝或者阻塞，降低系统的吞吐量和性能。
因此，在高并发、大规模的网络编程场景中，BIO不再适用，而需要使用NIO和AIO等更加高效的I/O模型。

2.NIO是Java NIO（New I/O）的缩写，指的是Java提供的一种高效的I/O处理方式。与传统的I/O操作（如BIO）不同，NIO是基于事件驱动的模型，可以在单线程中处理多个并发请求，提升了性能和可扩展性。
通过使用NIO库，Java应用程序可以实现非阻塞式I/O操作，包括文件操作、套接字操作等。它的主要优势在于使用少量线程就能处理大量并发连接，因此适用于高负载、高可靠性的网络应用程序。

2.2.2 需求分析/图解

需求分析如图, 浏览器请求 http://localhost:8080, 服务端返回 hi , hspedu, 后台hsptomcat 使用 BIO 线程模型,支持多线程=> 对前面的开发模式进行改造

2.2.3 分析+代码实现

● 分析示意图
在这里插入图片描述
● 代码实现

HspTomcatV2.java

public class HspTomcatV2 {public static void main(String[] args) throws IOException {//在8080端口监听ServerSocket serverSocket = new ServerSocket(8080);System.out.println("=======hsptomcatV2 在8080监听=======");//只要 serverSocket没有关闭，就一直等待浏览器/客户端的连接while (!serverSocket.isClosed()) {//1. 接收到浏览器的连接后，如果成功，就会得到socket//2. 这个socket 就是 服务器和 浏览器的数据通道Socket socket = serverSocket.accept();//3. 创建一个线程对象，并且把socket给该线程//  这个是java线程基础HspRequestHandler hspRequestHandler =new HspRequestHandler(socket);new Thread(hspRequestHandler).start();}}
}

HspRequestHandler.java

/*** 解读* 1. HspRequestHandler 对象是一个线程对象* 2. 处理一个http请求的*/
public class HspRequestHandler implements Runnable {//定义Socketprivate Socket socket = null;public HspRequestHandler(Socket socket) {this.socket = socket;}@Overridepublic void run() {//这里我们可以对客户端/浏览器进行IO编程/交互try {InputStream inputStream = socket.getInputStream();// 把inputStream -> BufferedReader -> 方便进行按行读取BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(inputStream, "utf-8"));// 不同的线程在和浏览器和客户端交互System.out.println("当前线程= " + Thread.currentThread().getName());System.out.println("=========hsptomcatv2 接收到的数据如下=========");String mes = null;while ((mes = bufferedReader.readLine()) != null) {//     如果长度为0 ""if (mes.length() == 0) {break; //退出}System.out.println(mes);}// 构建一下http响应头// 返回的http的响应体和响应头之间有两个换行 \r\n\r\nString respHeader = "HTTP/1.1 200 OK\r\n" +"Content-Type: text/html;charset=utf-8\r\n\r\n";String resp = respHeader + "<h1>hello world!</h1>";System.out.println("========hsptomcatv2返回的数据是=========");System.out.println(resp);// 返回数据给我们的浏览器/客户端-> 封装成http响应OutputStream outputStream = socket.getOutputStream();resp.getBytes() 是把字符串转成字节数组outputStream.write(resp.getBytes());outputStream.flush();outputStream.close();inputStream.close();socket.close();} catch (IOException e) {e.printStackTrace();} finally {//最后一定确保socket要关闭,//否则如果连接数过多会造成客户端等待if (socket != null) {try {socket.close();} catch (IOException e) {e.printStackTrace();}}}}
}

测试：
浏览器：http://localhost:8080/

2.2.4 问题分析

HspTomcat 只是简单返回结果，没有和 Servlet、web.xml 关联

2.3 实现任务阶段 3

处理 Servlet

2.3.1 Servlet 生命周期-回顾

在这里插入图片描述

2.3.2 需求分析/图解

● 需求分析如图, 浏览器请求 http://localhost:8080/hspCalServlet, 提交数据，完成计算任务，如果 servlet 不存在，返回 404
在这里插入图片描述

2.3.3 分析+代码实现

● 分析示意图
在这里插入图片描述

架构图：

2.3.3.1 优化1阶段

1.搭建结构
2.封装HttpServletRequest

1.模拟servlet
HspServlet.java

/*** 先搭建结构，后面在写内容*/
public interface HspServlet {}

HspHttpServlet.java

public abstract class HspHttpServlet implements HspServlet {}

HspCalServlet.java

public class HspCalServlet extends HspHttpServlet {}

2.模拟HttpServletRequest和HttpServletResponse
HspRequest.java

/*** 解读* 1. HspRequest 作用是封装http请求的数据* get /hspCalServlet?num1=10&num2=30* 2. 比如 method(get) 、 uri(/hspCalServlet) 、 还有参数列表 (num1=10&num2=30)* 3. HspRequest 作用就等价原生的servlet 中的HttpServletRequest* 4. 这里考虑的是GET请求*/
public class HspRequest {private String method;private String uri;//存放参数列表 参数名-参数值 => HashMapprivate HashMap<String, String> parametersMapping =new HashMap<>();private InputStream inputStream = null;//构造器=> 对http请求进行封装 => 可以将老师写的代码封装成方法//inputStream 是和 对应http请求的socket关联public HspRequest(InputStream inputStream) {this.inputStream = inputStream;//完成对http请求数据的封装..encapHttpRequest();}/*** 将http请求的相关数据，进行封装,然后提供相关的方法，进行获取*/private void encapHttpRequest() {System.out.println("HspRequest init()");try {//inputstream -> BufferedReaderBufferedReader bufferedReader =new BufferedReader(new InputStreamReader(inputStream, "utf-8"));//读取第一行/*** GET /hspCalServlet?num1=10&num2=30 HTTP/1.1* Host: localhost:8080* User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Fi*/String requestLine = bufferedReader.readLine();//GET - /hspCalServlet?num1=10&num2=30 - HTTP/1.1String[] requestLineArr = requestLine.split(" ");//得到methodmethod = requestLineArr[0];//解析得到 /hspCalServlet//1. 先看看uri 有没有参数列表int index = requestLineArr[1].indexOf("?");if (index == -1) { //说明没有参数列表uri = requestLineArr[1];} else {//[0,index)uri = requestLineArr[1].substring(0, index);//获取参数列表->parametersMapping//parameters => num1=10&num2=30String parameters = requestLineArr[1].substring(index + 1);//num1=10 , num2=30 .... parametersPair= ["num1=10","num2=30" ]String[] parametersPair = parameters.split("&");//防止用户提交时 /hspCalServlet?if (null != parametersPair && !"".equals(parametersPair)) {//再次分割 parameterPair = num1=10for (String parameterPair : parametersPair) {//parameterVal ["num1", "10"]String[] parameterVal = parameterPair.split("=");if (parameterVal.length == 2) {//放入到 parametersMappingparametersMapping.put(parameterVal[0], parameterVal[1]);}}}}//这里不能关闭流 inputStream 和 socket关联//inputStream.close();} catch (Exception e) {e.printStackTrace();}}//request对象有一个特别重要方法public String getParameter(String name) {if (parametersMapping.containsKey(name)) {return parametersMapping.get(name);} else {return "";}}public String getMethod() {return method;}public void setMethod(String method) {this.method = method;}public String getUri() {return uri;}public void setUri(String uri) {this.uri = uri;}@Overridepublic String toString() {return "HspRequest{" +"method='" + method + '\'' +", uri='" + uri + '\'' +", parametersMapping=" + parametersMapping +'}';}
}

细节补充：
在Java中，Socket和流（Stream）通常是一起使用的，用于进行网络数据传输。如果关闭与Socket相关联的流会导致Socket也关闭的问题，取决于关闭流的方式。
如果使用Socket对象的close()方法关闭与其关联的输入流或输出流，则会同时关闭该Socket，因为这些流是通过Socket来创建的。例如：

Socket socket = new Socket("example.com", 80);
OutputStream os = socket.getOutputStream();
os.close(); // 关闭输出流，同时也会关闭socket

HspResponse

/*** 老师解读* 1. HspResponse对象可以封装OutputStream(是socket关联)* 2. 即可以通过 HspResponse对象 返回Http响应给浏览器/客户端* 3. HspResponse对象 的作用等价于原生的servlet的 HttpServletResponse*/
public class HspResponse {}

3.改进HspRequestHandler

/*** 解读* 1. HspRequestHandler 对象是一个线程对象* 2. 处理一个http请求的*/
public class HspRequestHandler implements Runnable {//定义Socketprivate Socket socket = null;public HspRequestHandler(Socket socket) {this.socket = socket;}@Overridepublic void run() {//这里我们可以对客户端/浏览器进行IO编程/交互try {//这里我们先死后活HspRequest hspRequest = new HspRequest(socket.getInputStream());String num1 = hspRequest.getParameter("num1");String num2 = hspRequest.getParameter("num2");System.out.println("请求的参数num1= " + num1);System.out.println("请求的参数num2= " + num2);System.out.println("hspRequest= " + hspRequest);// 构建一下http响应头// 返回的http的响应体和响应头之间有两个换行 \r\n\r\nString respHeader = "HTTP/1.1 200 OK\r\n" +"Content-Type: text/html;charset=utf-8\r\n\r\n";String resp = respHeader + "<h1>hello world!</h1>";System.out.println("========hsptomcatv2返回的数据是=========");System.out.println(resp);OutputStream outputStream = socket.getOutputStream();resp.getBytes() 是把字符串转成字节数组outputStream.write(resp.getBytes());outputStream.flush();outputStream.close();inputStream.close();socket.close();} catch (IOException e) {e.printStackTrace();} finally {//最后一定确保socket要关闭,//否则如果连接数过多会造成客户端等待if (socket != null) {try {socket.close();} catch (IOException e) {e.printStackTrace();}}}}
}

2.3.3.2 优化2阶段

1.完善HspResponse
2.构建Servlet模型
3.创建Util工具类
4.优化HspRequestHandler处理器

补充:HspResponse.java

/*** 老师解读* 1. HspResponse对象可以封装OutputStream(是socket关联)* 2. 即可以通过 HspResponse对象 返回Http响应给浏览器/客户端* 3. HspResponse对象 的作用等价于原生的servlet的 HttpServletResponse*/
public class HspResponse {private OutputStream outputStream = null;//写一个http的响应头 => 先死后活public static final String respHeader = "HTTP/1.1 200 OK\r\n" +"Content-Type: text/html;charset=utf-8\r\n\r\n";//说明同学们如果有兴趣, 在编写更多的方法//比如 setContentType//在创建 HspResponse 对象时，传入的outputStream是和Socket关联的public HspResponse(OutputStream outputStream) {this.outputStream = outputStream;}//当我们需要给浏览器返回数据时，可以通过HspResponse 的输出流完成//public OutputStream getOutputStream() {return outputStream;}
}

完善模拟的Servlet
1.补充Servlet的生命周期

/*** 先搭建结构，后面在写内容* 老韩只保留了 三个核心方法声明*/
public interface HspServlet {void init() throws Exception;void service(HspRequest request, HspResponse response) throws IOException;void destroy();
}

2.完善HttpServlet

public abstract class HspHttpServlet implements HspServlet {@Overridepublic void service(HspRequest request, HspResponse response) throws IOException {//老师说明 equalsIgnoreCase 比较字符串内容是相同，不区别大小写if("GET".equalsIgnoreCase(request.getMethod())) {//这里会有动态绑定this.doGet(request,response);} else if("POST".equalsIgnoreCase(request.getMethod())) {this.doPost(request,response);}}//这里我们使用的了模板设计模式 => java 基础的 抽象类专门讲过模板设计模式//让HspHttpServlet 子类 HspCalServlet 实现public abstract void doGet(HspRequest request, HspResponse response);public abstract void doPost(HspRequest request, HspResponse response);
}

细节补充：
在这段代码中，this关键字和省略this关键字是没有区别的。因为在Java中，当局部变量和实例变量同名时，编译器会优先使用局部变量，如果需要访问实例变量，可以使用this关键字来代表当前对象。

因此，使用this.doGet()和直接调用doGet()方法实际上是等价的，不会影响程序的执行结果。只要doGet()方法已经定义在了当前类中，都可以直接调用。

不过，在实际开发中，推荐使用this关键字来调用当前对象的方法或访问成员变量，可以提高代码的可读性和可维护性。另外，使用this关键字还有助于避免和局部变量或参数命名冲突的情况。

因此，虽然this.doGet()和doGet()在语义上是一致的，但是在实际开发中，建议使用this.doGet()的方式来调用对象的方法。

3.实现HspCalServlet

public class HspCalServlet extends HspHttpServlet {@Overridepublic void doGet(HspRequest request, HspResponse response) {//java基础的 OOP 的动态绑定机制..//写业务代码，完成计算任务int num1 = WebUtils.parseInt(request.getParameter("num1"), 0);int num2 = WebUtils.parseInt(request.getParameter("num2"), 0);int sum = num1 + num2;//返回计算结果给浏览器//outputStream 和 当前的socket关联OutputStream outputStream = response.getOutputStream();String respMes = HspResponse.respHeader+ "<h1>" + num1 + " + " + num2 + " = " + sum + " HspTomcatV3 - 反射+xml创建</h1>";try {outputStream.write(respMes.getBytes());outputStream.flush();outputStream.close();} catch (IOException e) {e.printStackTrace();}}@Overridepublic void doPost(HspRequest request, HspResponse response) {this.doGet(request, response);}@Overridepublic void init() throws Exception {}@Overridepublic void destroy() {}
}

WebUtils.java

public class WebUtils {//将字符串转成数字方法public static int parseInt(String strNum, int defaultVal) {try {return Integer.parseInt(strNum);} catch (NumberFormatException e) {System.out.println(strNum + " 不能转成数字");}return defaultVal;}
}

改进优化HspRequestHandler处理器

/*** 老师解读* 1. HspRequestHandler 对象是一个线程对象* 2. 处理一个http请求的*/
public class HspRequestHandler implements Runnable {//定义Socketprivate Socket socket = null;public HspRequestHandler(Socket socket) {this.socket = socket;}@Overridepublic void run() {//这里我们可以对客户端/浏览器进行IO编程/交互try {//这里我们先死后活HspRequest hspRequest = new HspRequest(socket.getInputStream());//这里我们可以同HspResponse对象，返回数据给浏览器/客户端HspResponse hspResponse = new HspResponse(socket.getOutputStream());//创建HspCalServlet对象-> 一会我们再用反射来构建对象HspCalServlet hspCalServlet = new HspCalServlet();hspCalServlet.doGet(hspRequest, hspResponse);socket.close();} catch (IOException e) {e.printStackTrace();} finally {//最后一定确保socket要关闭if (socket != null) {try {socket.close();} catch (IOException e) {e.printStackTrace();}}}}
}

2.3.3.3 优化3阶段

1.构造容器
2.配置web.xml
3.创建容器（存放servlet和servlet-mapping）
4.利用dom4j技术获取xml文件，反射创建对象

思路分析
在这里插入图片描述
拷贝web.xml

引入dom4j的依赖

<!--导入dom4j-->
<dependency><groupId>dom4j</groupId><artifactId>dom4j</artifactId><version>1.1</version>
</dependency>

web.xml

<!DOCTYPE web-app PUBLIC"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN""http://java.sun.com/dtd/web-app_2_3.dtd" ><web-app><display-name>Archetype Created Web Application</display-name><!--配置自己设计的Servlet提示： 因为这是我们自己的servlet , 所以不识别, 没有关系, 直接忽略爆红..--><servlet><servlet-name>HspCalServlet</servlet-name><servlet-class>com.hspedu.tomcat.servlet.HspCalServlet</servlet-class></servlet><servlet-mapping><servlet-name>HspCalServlet</servlet-name><url-pattern>/hspCalServlet</url-pattern></servlet-mapping>
</web-app>

HspTomcatV3.java

/*** 第3版的Tomcat, 实现通过xml+反射来初始化容器*/
public class HspTomcatV3 {//1. 存放容器 servletMapping// -ConcurrentHashMap// -HashMap// key            - value// ServletName    对应的实例public static final ConcurrentHashMap<String, HspHttpServlet>servletMapping = new ConcurrentHashMap<>();//2容器 servletUrlMapping// -ConcurrentHashMap// -HashMap// key                    - value// url-pattern       ServletNamepublic static final ConcurrentHashMap<String, String>servletUrlMapping = new ConcurrentHashMap<>();//变强..public static void main(String[] args) {init();}//直接对两个容器进行初始化public static void init() {//读取web.xml => dom4j =>//得到web.xml文件的路径 => 拷贝一份.String path = HspTomcatV3.class.getResource("/").getPath();//System.out.println("path= " + path);//使用dom4j技术完成读取SAXReader saxReader = new SAXReader();//困难->真的掌握try {Document document = saxReader.read(new File(path + "web.xml"));System.out.println("document= " + document);//得到根元素Element rootElement = document.getRootElement();//得到根元素下面的所有元素List<Element> elements = rootElement.elements();//遍历并过滤到 servlet servlet-mappingfor (Element element : elements) {if ("servlet".equalsIgnoreCase(element.getName())) {//这是一个servlet配置//System.out.println("发现 servlet");//使用反射将该servlet实例放入到servletMappingElement servletName = element.element("servlet-name");Element servletClass = element.element("servlet-class");servletMapping.put(servletName.getText(),(HspHttpServlet) Class.forName(servletClass.getText().trim()).newInstance());} else if ("servlet-mapping".equalsIgnoreCase(element.getName())) {//这是一个servlet-mapping//System.out.println("发现 servlet-mapping");Element servletName = element.element("servlet-name");Element urlPatter = element.element("url-pattern");servletUrlMapping.put(urlPatter.getText(), servletName.getText());}}} catch (Exception e) {e.printStackTrace();}//验证，这两个容器是否初始化成功System.out.println("servletMapping= " + servletMapping);System.out.println("servletUrlMapping= " + servletUrlMapping);}
}

2.3.3.4 优化4阶段

1.完善自定义Tomcat
2.修改优化代码
3.完善测试web.xml

改进HspTomcatV3

/*** 第3版的Tomcat, 实现通过xml+反射来初始化容器*/
public class HspTomcatV3 {//1. 存放容器 servletMapping// -ConcurrentHashMap// -HashMap// key            - value// ServletName    对应的实例public static final ConcurrentHashMap<String, HspHttpServlet>servletMapping = new ConcurrentHashMap<>();//2容器 servletUrlMapping// -ConcurrentHashMap// -HashMap// key                    - value// url-pattern       ServletNamepublic static final ConcurrentHashMap<String, String>servletUrlMapping = new ConcurrentHashMap<>();//变强..public static void main(String[] args) {HspTomcatV3 hspTomcatV3 = new HspTomcatV3();hspTomcatV3.init();//启动hsptomcat容器hspTomcatV3.run();}//启动HspTomcatV3容器public void run() {try {ServerSocket serverSocket = new ServerSocket(8080);System.out.println("=====hsptomcatv3在8080监听======");while (!serverSocket.isClosed()) {Socket socket = serverSocket.accept();HspRequestHandler hspRequestHandler =new HspRequestHandler(socket);new Thread(hspRequestHandler).start();}} catch (IOException e) {e.printStackTrace();}}//直接对两个容器进行初始化public void init() {//读取web.xml => dom4j =>//得到web.xml文件的路径 => 拷贝一份.String path = HspTomcatV3.class.getResource("/").getPath();//System.out.println("path= " + path);//使用dom4j技术完成读取SAXReader saxReader = new SAXReader();//困难->真的掌握try {Document document = saxReader.read(new File(path + "web.xml"));System.out.println("document= " + document);//得到根元素Element rootElement = document.getRootElement();//得到根元素下面的所有元素List<Element> elements = rootElement.elements();//遍历并过滤到 servlet servlet-mappingfor (Element element : elements) {if ("servlet".equalsIgnoreCase(element.getName())) {//这是一个servlet配置//System.out.println("发现 servlet");//使用反射将该servlet实例放入到servletMappingElement servletName = element.element("servlet-name");Element servletClass = element.element("servlet-class");servletMapping.put(servletName.getText(),(HspHttpServlet) Class.forName(servletClass.getText().trim()).newInstance());} else if ("servlet-mapping".equalsIgnoreCase(element.getName())) {//这是一个servlet-mapping//System.out.println("发现 servlet-mapping");Element servletName = element.element("servlet-name");Element urlPatter = element.element("url-pattern");servletUrlMapping.put(urlPatter.getText(), servletName.getText());}}} catch (Exception e) {e.printStackTrace();}//验证，这两个容器是否初始化成功System.out.println("servletMapping= " + servletMapping);System.out.println("servletUrlMapping= " + servletUrlMapping);}
}

改进HspRequestHandler

/*** 1. HspRequestHandler 对象是一个线程对象* 2. 处理一个http请求的*/
public class HspRequestHandler implements Runnable {//定义Socketprivate Socket socket = null;public HspRequestHandler(Socket socket) {this.socket = socket;}@Overridepublic void run() {//这里我们可以对客户端/浏览器进行IO编程/交互try {//这里我们先死后活HspRequest hspRequest = new HspRequest(socket.getInputStream());//这里我们可以同HspResponse对象，返回数据给浏览器/客户端HspResponse hspResponse = new HspResponse(socket.getOutputStream());//1. 得到 uri => 就是 servletUrlMapping 的 url-patternString uri = hspRequest.getUri();String servletName = HspTomcatV3.servletUrlMapping.get(uri);if (servletName == null) {servletName = "";}//2. 通过uri->servletName->servlet的实例 , 真正的运行类型是其子类 HspCalServletHspHttpServlet hspHttpServlet =HspTomcatV3.servletMapping.get(servletName);//3. 调用service , 通过OOP的动态绑定机制，调用运行类型的 doGet/doPostif (hspHttpServlet != null) {//得到hspHttpServlet.service(hspRequest, hspResponse);} else {//没有这个servlet , 返回404的提示信息String resp = HspResponse.respHeader + "<h1>404 Not Found</h1>";OutputStream outputStream = hspResponse.getOutputStream();outputStream.write(resp.getBytes());outputStream.flush();outputStream.close();}socket.close();} catch (IOException e) {e.printStackTrace();} finally {//最后一定确保socket要关闭if (socket != null) {try {socket.close();} catch (IOException e) {e.printStackTrace();}}}}
}

改进web.xml

<!DOCTYPE web-app PUBLIC"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN""http://java.sun.com/dtd/web-app_2_3.dtd" ><web-app><display-name>Archetype Created Web Application</display-name><!--配置自己设计的Servlet提示： 因为这是我们自己的servlet , 所以不识别, 没有关系, 直接忽略爆红..--><servlet><servlet-name>HspCalServlet</servlet-name><servlet-class>com.hspedu.tomcat.servlet.HspCalServlet</servlet-class></servlet><servlet-mapping><servlet-name>HspCalServlet</servlet-name><url-pattern>/hspCalServlet</url-pattern></servlet-mapping><!--多配置一个servlet--><servlet><servlet-name>Hsp6CalServlet</servlet-name><servlet-class>com.hspedu.tomcat.servlet.Hsp6CalServlet</servlet-class></servlet><servlet-mapping><servlet-name>Hsp6CalServlet</servlet-name><url-pattern>/hsp6CalServlet</url-pattern></servlet-mapping>
</web-app>

增添Hsp6CalServlet

public class Hsp6CalServlet extends HspHttpServlet {@Overridepublic void doGet(HspRequest request, HspResponse response) {//java基础的 OOP 的动态绑定机制..//写业务代码，完成计算任务int num1 = WebUtils.parseInt(request.getParameter("num1"), 0);int num2 = WebUtils.parseInt(request.getParameter("num2"), 0);int sum = num1 * num2;//返回计算结果给浏览器//outputStream 和 当前的socket关联OutputStream outputStream = response.getOutputStream();String respMes = HspResponse.respHeader+ "<h1>" + num1 + " * " + num2 + " = " + sum + " HspTomcatV3 - 反射+xml创建</h1>";try {outputStream.write(respMes.getBytes());outputStream.flush();outputStream.close();} catch (IOException e) {e.printStackTrace();}}@Overridepublic void doPost(HspRequest request, HspResponse response) {}@Overridepublic void init() throws Exception {}@Overridepublic void destroy() {}
}

2.4 小结

回顾 Tomcat 工作架构图
在这里插入图片描述
BIO线程模型

BIO（Blocking I/O）即同步阻塞 I/O，是 Java 中最早使用的一种 I/O 模型。它的特点是使用传统的套接字（Socket）进行通信，当服务端接收到客户端请求后，为每个客户端连接创建一个新的线程进行处理，因此这种模型也被称为“一请求一应答”模式。

BIO 线程模型的流程如下：

服务端启动后，通过 ServerSocket 等待客户端连接请求。
客户端发起连接请求后，服务端接收到请求并创建一个新的线程（或使用线程池中的一个线程）处理客户端的请求。
服务端将接收到的数据存放到缓冲区中，并处理客户端请求。
服务端将处理结果返回给客户端，并关闭连接。

需要注意的是，BIO 模型中的线程数随着客户端连接数量的增加而增加，如果客户端连接数量过多，服务端可能会出现线程资源不足的情况。

NIO线程模型

NIO（Non-blocking I/O）即非阻塞 I/O，是 Java 中另一种 I/O 模型。相比于 BIO 模型，它使用单个线程或少量线程来处理多个客户端的请求，因此也被称为“多路复用”模式。

NIO 线程模型的流程如下：

服务端启动后，通过 ServerSocketChannel 等待客户端连接请求。
客户端发起连接请求后，服务端接收到请求，并将其注册到 Selector 中，由 Selector 监听客户端的事件。
Selector 在监听到事件后，将其分发给对应的线程进行处理，例如读取客户端发送的数据。
完成对客户端请求的处理后，服务端将处理结果返回给客户端，并关闭连接。

需要注意的是，NIO 模型中使用单个线程或少量线程进行处理，因此可以避免频繁创建线程造成的开销，同时也能够提高系统的性能和吞吐量。但是，在处理客户端请求时需要使用较为复杂的事件轮询机制。

3. 课后作业

在这里插入图片描述

cal.html

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>计算器</title>
</head>
<body>
<h1>计算器</h1>
<form action="/hspCalServlet" method="get">num1:<input type="text" name="num1"><br/>num2:<input type="text" name="num2"><br/><input type="submit" value="提交">
</form>
</body>
</html>