Skip to content

Servlet-手写Tomcat ​

[TOC]

概述 ​

Web 容器(如 Tomcat) 本质上是一个运行在服务端的 Java 应用程序,负责监听客户端浏览器的 HTTP 请求、解析请求报文、分发静态资源或调度动态 Servlet 业务组件,并将处理结果封装为 HTTP 响应报文回写给浏览器。在手写 Tomcat 的开发过程中,我们将围绕浏览器访问 http://localhost:8080/servlet/calServlet 这一核心业务场景,从零构建一个支持静态页面读取与动态 Servlet 反射调度的轻量级 Web 容器。

容器整体架构 ​

当用户在浏览器地址栏输入 URL 发起请求时,手写 Tomcat 容器内部的完整流转链路跨越了底层网络通信、多线程并发调度、静态资源 IO 读取以及动态 Servlet 反射执行四个核心层级:

  1. 网络接入层:容器启动时通过 ServerSocket 绑定 8080 端口持续监听客户端连接,接收浏览器发送的原始 HTTP 请求字节流,并在业务处理完毕后通过 Socket 输出流回写 HTTP 响应报文。

  2. 并发分发层:每当容器接收到一个客户端 Socket 连接,主线程不直接处理耗时业务,而是创建独立的 HspRequestHandler 线程对象接管该连接,实现多客户端请求的并发处理。

  3. 路由分流层:HspRequestHandler 线程提取请求报文中的目标 URL,判断目标资源类型;若请求的是 HTML、CSS、JS 或图片等静态资源,直接通过 IO 流读取本地文件并组装 HTTP 响应返回。

  4. 容器调度层:若请求 URL 指向动态业务(如 /servlet/calServlet),容器则结合启动阶段由 Dom4j 解析 web.xml 构建的映射容器,通过反射机制实例化并调用目标 Servlet 完成业务计算。

image-20261117123946657

三阶段演进路线 ​

为了降低复杂系统的构建难度,整个手写 Tomcat 的开发流程按照职责边界划分为三个递进式迭代阶段:

阶段一:Socket 网络通信

打通浏览器与 Java 服务端之间的底层网络连接。基于 Socket 网络编程与 BIO 流技术实现 8080 端口监听,读取浏览器发送的 HTTP 请求行与请求头数据,并按照 HTTP 协议规范手工拼接响应状态行、响应头与响应体回写给客户端。

阶段二:多线程请求分发

引入多线程并发机制与路由分流逻辑。将单次请求的处理流程剥离至实现 Runnable 接口的 HspRequestHandler 线程中执行,支持静态 HTML 资源文件的本地 IO 寻址与回写;同时在容器启动阶段引入 Dom4j 解析 web.xml,将 <servlet> 与 <servlet-mapping> 节点配置预加载至内存映射容器。

阶段三:Servlet 容器调度

构建自定义 Servlet 规范与动态反射调度闭环。封装 HspRequest(解析请求方式、URI 及查询参数)与 HspResponse(封装底层输出流与响应头),定义 HspServlet 接口与 HspHttpServlet 模板抽象类实现 GET/POST 请求派发,最终在 HspRequestHandler 中通过 URL 匹配、反射实例化与生命周期调用驱动业务 CalServlet 执行。

image-20261117111637541

核心组件职责 ​

手写 Tomcat 容器由启动入口、并发处理器、请求响应封装类、自定义 Servlet 规范体系以及业务实现类共同组成:

  • HspTomcat:容器主启动类,负责在启动时调用 Dom4j 解析 web.xml 初始化映射容器,并开启 ServerSocket 循环监听 8080 端口。

  • HspRequestHandler:请求处理线程类,接管客户端 Socket 连接,统筹请求解析、静态资源过滤、动态 Servlet 路由匹配与反射执行全流程。

  • HspRequest:HTTP 请求封装类,负责从 Socket 输入流中解析请求方法(method)、请求路径(uri)以及表单或 URL 携带的业务参数。

  • HspResponse:HTTP 响应封装类,持有 Socket 底层 OutputStream,向业务 Servlet 暴露统一的响应写入通道并预置标准 HTTP 响应头。

  • HspServlet 与 HspHttpServlet:自定义 Servlet规范接口与抽象模板基类,定义init、service、destroy生命周期契约,并利用模板方法模式将service调用分发至子类重写的doGet或doPost 方法。

  • CalServlet:具体的业务 Servlet 实现类,继承 HspHttpServlet,接收客户端提交的运算参数并将计算结果通过 HspResponse 输出至浏览器。

工程环境配置 ​

手写 Tomcat 工程采用标准 Maven 结构组织代码,除 JDK 原生提供的 java.net、java.io、java.lang.reflect 与 java.util.concurrent 核心包外,仅需在 pom.xml 中引入 dom4j 依赖用于解析 web.xml 配置文件。

xml
<dependencies>
    <!-- 引入 Dom4j 依赖,用于容器启动阶段解析 web.xml 中的 Servlet 映射配置 -->
    <dependency>
        <groupId>dom4j</groupId>
        <artifactId>dom4j</artifactId>
        <version>1.6.1</version>
    </dependency>
</dependencies>

工程静态资源(如 cal.html)与容器配置文件 web.xml 统一存放在 src/main/resources 目录下,编译后由容器直接从类路径(target/classes)根目录加载读取。

阶段一:Socket 网络通信 ​

在手写 Tomcat 的第一阶段迭代中,核心业务目标是打通客户端浏览器与服务端 HspTomcat 容器之间的底层网络通信闭环。此阶段暂不引入多线程分发与 Servlet 动态反射,而是由主线程直接通过 ServerSocket 监听 8080 端口,完整走通“接收浏览器连接 → 按行读取 HTTP 请求报文 → 组装标准 HTTP 响应报文 → 字节流回写并释放连接”的单次请求处理链路。

image-20261117122244861

ServerSocket 请求监听 ​

当启动 HspTomcat 容器并在浏览器地址栏发起 http://localhost:8080/ 请求时,服务端接收并拆解请求报文的业务流转按以下顺序执行:

  1. 绑定端口启动循环监听:容器主程序初始化 ServerSocket 实例并绑定 8080 端口,随后进入 while (!serverSocket.isClosed()) 持续监听循环,保证容器在未关闭状态下能够源源不断地接收外部请求。

  2. 阻塞等待客户端接入:主线程调用 serverSocket.accept() 进入阻塞等待状态;当浏览器发起 TCP 连接请求时,该方法被唤醒并返回代表当前客户端通信通道的 Socket 对象。

  3. 包装字符流按行拆解报文:容器从 Socket 通道中获取底层字节输入流,将其包装为指定 utf-8 字符集的 BufferedReader 缓冲字符流,以便按行提取浏览器发送的 HTTP 请求行(如 GET / HTTP/1.1)与各行请求头属性。

  4. 识别空行终止请求头读取:在 while 循环调用 readLine() 读取报文的过程中,由于浏览器默认开启长连接(Connection: keep-alive),输入流不会主动关闭;因此业务上必须判断当前读取行是否为空行(mesg.length() == 0),一旦检测到标志着 HTTP 请求头结束的空行,立即执行 break 跳出读取循环,防止线程因等待流结束标志(null)而陷入永久阻塞。

java
// 1. 创建 ServerSocket 并绑定 8080 端口,启动容器监听
ServerSocket serverSocket = new ServerSocket(8080);

// 2. 循环监听客户端连接,只要容器未关闭就持续接收请求
while (!serverSocket.isClosed()) {
  // 3. 阻塞等待浏览器连接,连接建立后返回对应的 Socket 通道
  Socket socket = serverSocket.accept();

  // 4. 将 Socket 字节输入流包装为 UTF-8 字符缓冲流,按行读取 HTTP 请求头
  BufferedReader bufferedReader = new BufferedReader(
      new InputStreamReader(socket.getInputStream(), "utf-8"));
  String mesg = null;

  // 5. 循环读取请求行与请求头,遇到空行代表请求头结束即刻退出循环
  while ((mesg = bufferedReader.readLine()) != null) {
    if (mesg.length() == 0) {
      break;
    }
    System.out.println(mesg);
  }
}

HTTP 响应报文回写 ​

服务端读取完浏览器请求头后,不能直接将业务字符串裸写回客户端,否则浏览器无法识别协议格式;必须严格按照 HTTP 响应报文结构完成数据封装与通道回写:

  1. 拼接标准 HTTP 响应头与空行:构造状态行 HTTP/1.1 200 OK\r\n 声明响应成功,紧接着拼接响应头 Content-Type: text/html;charset=utf-8\r\n 指示浏览器按 UTF-8 编码的 HTML 格式解析内容,并在响应头末尾追加一个独立的 \r\n(形成 \r\n\r\n 空行结构),明确划分响应头与响应体的边界。

  2. 挂载响应体并写入输出流:将实际要展示的业务内容(如 "hi, HspTomcat!")拼接到响应头空行之后,通过 socket.getOutputStream() 获取底层字节输出流,将完整响应报文转换为字节数组写入通道并调用 flush() 强制刷出缓冲区。

  3. 关闭流与单次连接通道:数据刷出完毕后,依次关闭 outputStream、bufferedReader 以及当前客户端 socket 连接,通知浏览器本次 HTTP 响应传输结束,同时主线程回到外层循环起点继续等待下一次请求接入。

java
package com.hspedu.tomcat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

// 1. 阶段一主程序:实现底层 Socket 请求监听与 HTTP 响应回写闭环
public class HspTomcat {

  public static void main(String[] args) throws IOException {
    // 2. 绑定 8080 端口开启服务监听
    ServerSocket serverSocket = new ServerSocket(8080);

    while (!serverSocket.isClosed()) {
      Socket socket = serverSocket.accept();
      BufferedReader bufferedReader = new BufferedReader(
          new InputStreamReader(socket.getInputStream(), "utf-8"));
      String mesg = null;
      while ((mesg = bufferedReader.readLine()) != null) {
        if (mesg.length() == 0) {
          break;
        }
      }

      // 3. 获取 Socket 底层字节输出流,准备回写 HTTP 响应
      OutputStream outputStream = socket.getOutputStream();

      // 4. 构造 HTTP 响应头与响应体,响应头与响应体之间必须保留空行(\r\n\r\n)
      String respHeader = "HTTP/1.1 200 OK\r\n" +
          "Content-Type: text/html;charset=utf-8\r\n\r\n";
      String resp = respHeader + "hi, HspTomcat!";

      // 5. 将响应报文转换为字节数组写入通道并刷出缓冲区
      outputStream.write(resp.getBytes());
      outputStream.flush();

      // 6. 单次请求处理完毕,依次关闭流与当前客户端 Socket 连接
      outputStream.close();
      bufferedReader.close();
      socket.close();
    }
  }
}

阶段二:多线程请求分发 ​

在第一阶段打通底层 Socket 单线程通信闭环的基础上,第二阶段的核心业务目标是解决多客户端并发接入、静态资源路由分流以及容器配置预热加载三大核心流转问题。容器主线程不再亲自处理耗时的 IO 读写,而是将客户端连接交由独立的 HspRequestHandler 工作线程并发处理;工作线程通过解析请求 URL 识别静态资源(如 cal.html)并直接读取本地文件返回,同时容器在启动阶段通过 Dom4j 解析 web.xml 构建映射表,为第三阶段的动态 Servlet 调度做好路由准备。

image-20261117122308164

HspRequestHandler 线程分发 ​

为了防止单个客户端的慢速 IO 阻塞整个 Tomcat 容器的端口监听,请求接收与业务处理的流转职责在主线程与工作线程之间进行了明确切分:

  1. 主线程专注端口监听与连接接收:HspTomcat 主线程在 while (!serverSocket.isClosed()) 循环中仅执行 serverSocket.accept() 阻塞等待,一旦捕获到浏览器发起的 TCP 连接并拿到 Socket 实例,不执行任何流读取操作,立即进入线程派发环节。

  2. 创建并启动工作线程接管通道:主线程将当前客户端的 Socket 实例作为构造参数传入实现了 Runnable 接口的 HspRequestHandler 对象中,随后调用 new Thread(hspRequestHandler).start() 启动独立工作线程,主线程随即返回循环顶部继续监听下一个客户端请求。

  3. 工作线程闭环管理请求生命周期:HspRequestHandler 线程在 run() 方法内独立完成当前 Socket 输入流的读取、业务逻辑分流以及响应输出流的回写,并在 finally 代码块中强制关闭 Socket 连接,确保单个请求发生异常时不会波及主线程与其他并发请求。

java
// 1. 定义请求处理线程类,实现 Runnable 接口接管客户端 Socket 连接
public class HspRequestHandler implements Runnable {

  private Socket socket = null;

  public HspRequestHandler(Socket socket) {
    this.socket = socket;
  }

  // 2. 在独立工作线程中执行请求读取、业务分流与响应回写逻辑
  @Override
  public void run() {
    try {
      BufferedReader bufferedReader = new BufferedReader(
          new InputStreamReader(socket.getInputStream(), "utf-8"));

      // 3. 读取请求报文并向客户端回写响应数据
      OutputStream outputStream = socket.getOutputStream();
      String resp = "HTTP/1.1 200 OK\r\n" +
          "Content-Type: text/html;charset=utf-8\r\n\r\n" +
          "hi, HspRequestHandler!";
      outputStream.write(resp.getBytes());
      outputStream.flush();
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      // 4. 确保单次请求处理完毕后安全关闭底层 Socket 通道
      if (socket != null) {
        try {
          socket.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
}

静态资源 IO 响应 ​

当用户在浏览器中请求静态表单页面(如 http://localhost:8080/cal.html)时,HspRequestHandler 线程内部执行 URL 识别与本地文件寻址回写流程:

  1. 提取请求首行中的目标路径:工作线程从输入流读取第一行 HTTP 请求行(例如 GET /cal.html HTTP/1.1),按空格切分字符串提取出目标 URI(/cal.html)。

  2. 拦截静态资源并定位类路径文件:判断目标 URI 是否为静态资源文件(如以 .html、.css、.js 结尾);若命中静态资源分支,通过类加载器获取编译后的类路径根目录(target/classes/),拼接出去除前导斜杠后的完整本地文件路径。

  3. 读取存在文件并封装 200 响应:校验目标 File 对象是否存在;若存在则创建字符缓冲流按行读取本地静态文件内容,在文件正文前拼接 HTTP/1.1 200 OK 响应头与空行,通过 Socket 输出流完整写回浏览器展示。

  4. 缺失静态文件回写 404 状态码:若类路径下不存在对应的静态资源文件,则组装 HTTP/1.1 404 Not Found 状态行与错误提示页面回写浏览器,直接终止本次请求处理流程。

java
// 1. 提取 HTTP 请求首行,拆解出目标 URI 路径(如 /cal.html)
String requestLine = bufferedReader.readLine();
String uri = requestLine.split(" ")[1];

// 2. 判断请求路径是否为静态 HTML 资源
if (uri.endsWith(".html")) {
  String path = HspRequestHandler.class.getResource("/").getPath();
  File file = new File(path + uri.substring(1));

  // 3. 若本地静态文件存在,按行读取文件内容并拼接 200 响应头回写
  if (file.exists()) {
    BufferedReader fileReader = new BufferedReader(new FileReader(file));
    StringBuilder content = new StringBuilder();
    String line = null;
    while ((line = fileReader.readLine()) != null) {
      content.append(line);
    }
    fileReader.close();

    String resp = "HTTP/1.1 200 OK\r\n" +
        "Content-Type: text/html;charset=utf-8\r\n\r\n" +
        content.toString();
    outputStream.write(resp.getBytes());
  } else {
    // 4. 若静态文件不存在,回写 404 Not Found 响应提示
    String resp = "HTTP/1.1 404 Not Found\r\n" +
        "Content-Type: text/html;charset=utf-8\r\n\r\n" +
        "<h1>404 Not Found</h1>";
    outputStream.write(resp.getBytes());
  }
}

Dom4j 解析 web.xml ​

若客户端请求的不是静态资源,而是动态业务路径(如 /servlet/calServlet),容器需要通过路由表找到对应的业务 Servlet 类。为此,HspTomcat 在正式开启端口监听前,必须先完成 web.xml 配置的预加载与映射初始化:

  1. 声明双层并发映射容器:在 HspTomcat 主类中定义两个静态 ConcurrentHashMap 容器:
    • servletUrlMapping:负责维护请求路径 url-pattern 到 servlet-name 的映射关系;
    • servletMapping:负责维护 servlet-name 到对应 HspHttpServlet 实例的映射关系。
  2. 启动阶段定位并解析 XML 文档树:容器启动时优先调用 init() 方法,定位类路径根目录下的 web.xml 文件,通过 Dom4j 的 SAXReader 读取配置文件并生成内存 Document 对象与根标签 <web-app>。
  3. 遍历标签完成反射实例化与路由注册:遍历 <web-app> 下的所有一级子标签:
    • 当遇到 <servlet> 标签时,提取 <servlet-name> 与 <servlet-class> 文本,直接利用 Class.forName(...).newInstance() 反射创建业务 Servlet 实例并存入 servletMapping;
    • 当遇到 <servlet-mapping> 标签时,提取 <url-pattern> 与 <servlet-name> 文本并绑定存入 servletUrlMapping,完成路由表的构建。
java
// 1. 定义并发安全的映射容器,分别存储 Servlet 实例与 URL 映射关系
public static final ConcurrentHashMap<String, HspHttpServlet> servletMapping =
    new ConcurrentHashMap<>();
public static final ConcurrentHashMap<String, String> servletUrlMapping =
    new ConcurrentHashMap<>();

// 2. 容器启动初始化方法:利用 Dom4j 解析类路径下的 web.xml 配置文件
public void init() throws Exception {
  String path = HspTomcat.class.getResource("/").getPath();
  SAXReader saxReader = new SAXReader();
  Document document = saxReader.read(new File(path + "web.xml"));
  Element rootElement = document.getRootElement();

  // 3. 遍历根标签下的所有子节点,提取 servlet 与 servlet-mapping 配置
  List<Element> elements = rootElement.elements();
  for (Element element : elements) {
    if ("servlet".equalsIgnoreCase(element.getName())) {
      Element servletName = element.element("servlet-name");
      Element servletClass = element.element("servlet-class");

      // 4. 通过反射实例化业务 Servlet 并存入 servletMapping 容器
      servletMapping.put(servletName.getText().trim(),
          (HspHttpServlet) Class.forName(servletClass.getText().trim()).newInstance());
    } else if ("servlet-mapping".equalsIgnoreCase(element.getName())) {
      Element servletName = element.element("servlet-name");
      Element urlPattern = element.element("url-pattern");

      // 5. 将请求路径 url-pattern 与 servlet-name 绑定存入 servletUrlMapping 容器
      servletUrlMapping.put(urlPattern.getText().trim(), servletName.getText().trim());
    }
  }
}

阶段三:Servlet 容器调度 ​

在完成底层 Socket 通信、多线程分发与 web.xml 配置预加载后,第三阶段的核心业务目标是打通动态 Servlet 容器调度的完整执行闭环。当用户在浏览器中提交表单或访问 http://localhost:8080/servlet/calServlet?num1=10&num2=20 时,容器将原始字节流封装为 HspRequest 与 HspResponse 对象,结合双层映射容器查找目标 Servlet 实例,并通过自定义 HspServlet 规范的模板方法模式将请求派发至业务类 CalServlet 执行计算与结果回写。

image-20261117122327773

HspRequest 请求封装 ​

在第二阶段中,HspRequestHandler 直接操作字符缓冲流截取请求首行;进入第三阶段后,为了向业务 Servlet 提供标准化的请求数据读取能力,解析 HTTP 请求报文的职责被完整收敛至 HspRequest 类中执行:

  1. 接管底层输入流触发初始化:HspRequestHandler 接收到客户端连接后,将 socket.getInputStream() 传入 HspRequest 构造器,构造器内部立即调用 init() 私有方法启动报文拆解流程。

  2. 提取请求方式与完整请求路径:将底层字节输入流包装为 UTF-8 编码的 BufferedReader,读取 HTTP 请求第一行(如 GET /servlet/calServlet?num1=10&num2=20 HTTP/1.1),按空格切分字符串数组,提取索引 0 处的请求方法 method(如 GET)与索引 1 处的完整路径部分。

  3. 分离路由 URI 与查询参数映射表:检测完整路径中是否包含参数分隔符 ?;若不包含 ?,则直接将整段路径赋值给 uri;若包含 ?,则截取 ? 之前的部分作为用于容器路由匹配的纯净 uri(如 /servlet/calServlet),截取 ? 之后的参数串先按 & 切分为多组键值对,再按 = 逐对切分参数名与参数值,存入内部 parametersMapping 哈希表中,供后续业务代码调用 getParameter(name) 按需提取。

java
// 1. 封装 HTTP 请求数据,解析 method、uri 以及请求参数列表
public class HspRequest {

  private String method;
  private String uri;
  private HashMap<String, String> parametersMapping = new HashMap<>();
  private InputStream inputStream = null;

  // 2. 构造器接收 Socket 底层字节输入流并触发解析流程
  public HspRequest(InputStream inputStream) {
    this.inputStream = inputStream;
    init();
  }

  // 3. 读取请求首行,依次拆解请求方法、路由 URI 与查询参数键值对
  private void init() {
    try {
      BufferedReader bufferedReader = new BufferedReader(
          new InputStreamReader(inputStream, "utf-8"));
      String requestLine = bufferedReader.readLine();
      String[] requestLineArr = requestLine.split(" ");
      method = requestLineArr[0];

      // 4. 根据是否存在 ? 号分离请求路径 uri 与参数键值对
      int index = requestLineArr[1].indexOf("?");
      if (index == -1) {
        uri = requestLineArr[1];
      } else {
        uri = requestLineArr[1].substring(0, index);
        String parameters = requestLineArr[1].substring(index + 1);
        String[] parametersPair = parameters.split("&");
        for (String parameterPair : parametersPair) {
          String[] parameterVal = parameterPair.split("=");
          if (parameterVal.length == 2) {
            parametersMapping.put(parameterVal[0], parameterVal[1]);
          }
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  // 5. 根据参数名从映射表中获取对应的请求参数值
  public String getParameter(String name) {
    if (parametersMapping.containsKey(name)) {
      return parametersMapping.get(name);
    }
    return "";
  }

  public String getMethod() {
    return method;
  }

  public String getUri() {
    return uri;
  }
}

HspResponse 响应封装 ​

与请求封装相对应,容器需要将底层 Socket 的输出通道封装为 HspResponse 对象传递给业务 Servlet,使业务层能够直接向客户端浏览器回写动态处理结果:

  1. 绑定客户端字节输出流:HspRequestHandler 将 socket.getOutputStream() 传入 HspResponse 构造器中保存,确保当前响应对象与客户端连接通道一一对应。

  2. 预置标准 HTTP 响应头常量:在 HspResponse 类中定义静态常量 respHeader,预先封装好 HTTP/1.1 200 OK 状态行、Content-Type: text/html;charset=utf-8 响应头以及用于分隔响应体的 \r\n\r\n 空行结构,避免每个业务 Servlet 重复编写底层协议头。

  3. 向业务层提供输出流访问入口:对外暴露 getOutputStream() 方法,业务 Servlet 完成逻辑计算后,直接获取该输出流并将 HspResponse.respHeader 与动态 HTML 内容一并写出即可完成响应回传。

java
// 1. 封装 HTTP 响应对象,持有底层 Socket 输出流并预置响应头常量
public class HspResponse {

  private OutputStream outputStream = null;

  // 2. 预置 HTTP 200 状态行、UTF-8 响应头以及分割响应体的空行
  public static final String respHeader = "HTTP/1.1 200 OK\r\n" +
      "Content-Type: text/html;charset=utf-8\r\n\r\n";

  // 3. 构造器接收并绑定当前客户端 Socket 的 OutputStream
  public HspResponse(OutputStream outputStream) {
    this.outputStream = outputStream;
  }

  // 4. 向业务 Servlet 暴露输出流以回写动态计算结果
  public OutputStream getOutputStream() {
    return outputStream;
  }
}

HspHttpServlet 模板派发 ​

为了解耦容器调度与具体业务实现,阶段三自定义了一套由 HspServlet 接口、HspHttpServlet 抽象模板类与 CalServlet 业务子类组成的三层调用体系:

  1. 顶层接口定义容器调用契约:HspServlet 接口声明 init()、service(HspRequest, HspResponse) 与 destroy() 三个标准方法,容器调度层只需面向接口调用 service 方法即可驱动请求处理。

  2. 抽象父类按请求方法模板分流:HspHttpServlet 实现 HspServlet 接口并接管 service() 方法;在 service() 内部读取 request.getMethod() 的值,若为 "GET" 请求则调用 this.doGet(request, response),若为 "POST" 请求则调用 this.doPost(request, response),通过 Java 动态绑定机制将执行流转交给具体的业务子类。

  3. 业务子类读取参数并回写计算结果:业务类 CalServlet 继承 HspHttpServlet 并重写 doGet 与 doPost 方法;在 doGet 中通过 request.getParameter() 提取客户端传入的运算参数完成求和计算,随后通过 response.getOutputStream() 将响应头与计算结果 HTML 写回浏览器。

自定义 Servlet 顶层接口

java
// 1. 自定义 Servlet 顶层接口,规范容器调用契约
public interface HspServlet {

  // 2. 保留三个核心方法声明:初始化、请求处理与销毁
  void init() throws Exception;

  void service(HspRequest request, HspResponse response) throws IOException;

  void destroy();
}

抽象模板类实现 HspServlet 接口

java
// 1. 抽象模板类实现 HspServlet 接口,按请求方式分流调用子类的 doGet 或 doPost
public abstract class HspHttpServlet implements HspServlet {

  @Override
  public void service(HspRequest request, HspResponse response) throws IOException {
    // 2. 读取请求方法类型,动态绑定执行子类重写的业务方法
    if ("GET".equalsIgnoreCase(request.getMethod())) {
      this.doGet(request, response);
    } else if ("POST".equalsIgnoreCase(request.getMethod())) {
      this.doPost(request, response);
    }
  }

  // 3. 定义抽象方法,交由具体业务 Servlet 子类实现
  public abstract void doGet(HspRequest request, HspResponse response);

  public abstract void doPost(HspRequest request, HspResponse response);
}

业务子类 CalServlet 的具体处理逻辑如下:

java
// 1. 业务 Servlet 实现类,继承 HspHttpServlet 完成两数相加计算业务
public class CalServlet extends HspHttpServlet {

  @Override
  public void doGet(HspRequest request, HspResponse response) {
    // 2. 从 HspRequest 中提取客户端提交的运算参数并转换为整型计算结果
    int numOne = Integer.parseInt(request.getParameter("num1"));
    int numTwo = Integer.parseInt(request.getParameter("num2"));
    int sum = numOne + numTwo;

    // 3. 通过 HspResponse 获取输出流,拼接响应头与计算结果回写给浏览器
    OutputStream outputStream = response.getOutputStream();
    String resp = HspResponse.respHeader + "<h1>" + numOne + " + " + numTwo + " = " + sum + "</h1>";
    try {
      outputStream.write(resp.getBytes());
      outputStream.flush();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  @Override
  public void doPost(HspRequest request, HspResponse response) {
    this.doGet(request, response);
  }
}

Servlet 反射容器调度 ​

当 HspRequest、HspResponse 与 HspHttpServlet 体系准备就绪后,工作线程 HspRequestHandler 即可将第二阶段预加载的映射容器与第三阶段的业务调用串联成完整的容器调度链路:

  1. 初始化请求与响应包装对象:HspRequestHandler 在 run() 方法中首先基于当前 Socket 的输入输出流创建 HspRequest 与 HspResponse 实例,并从 hspRequest.getUri() 获取不含查询参数的请求路径。

  2. 区分静态资源与动态业务分支:先判断 uri 是否为 .html 等静态资源;若命中静态分支则直接读取类路径下的静态文件回写;若未命中静态分支,则判定为动态 Servlet 请求,进入容器路由匹配阶段。

  3. 双层映射容器查表与空指针防护:以 uri(如 /servlet/calServlet)为键从 HspTomcat.servletUrlMapping 中查询对应的 servletName;由于 ConcurrentHashMap 的 get() 方法不允许传入 null 键,若未查到映射导致 servletName 为 null 时需将其重置为空字符串 "",随后再以 servletName 为键从 HspTomcat.servletMapping 实例池中取出容器启动时通过反射创建的 HspHttpServlet 实例。

  4. 触发多态调用或 404 兜底响应:若成功从实例池中拿到 hspHttpServlet 对象,直接调用 hspHttpServlet.service(hspRequest, hspResponse) 完成动态业务派发;若实例为 null(说明请求的动态路径未在 web.xml 中注册),则通过 hspResponse 向浏览器回写 404 Not Found 提示,最终在 finally 块中关闭 Socket 通道结束本次请求。

java
// 1. 阶段三完整请求处理器:串联请求封装、静态资源分流与动态 Servlet 反射容器调度
public class HspRequestHandler implements Runnable {

  private Socket socket = null;

  public HspRequestHandler(Socket socket) {
    this.socket = socket;
  }

  @Override
  public void run() {
    try {
      // 2. 将 Socket 输入输出流封装为 HspRequest 与 HspResponse 对象
      HspRequest hspRequest = new HspRequest(socket.getInputStream());
      HspResponse hspResponse = new HspResponse(socket.getOutputStream());
      String uri = hspRequest.getUri();

      // 3. 若非静态资源请求,进入动态 Servlet 容器映射匹配与调度分支
      if (!uri.endsWith(".html")) {
        String servletName = HspTomcat.servletUrlMapping.get(uri);
        if (servletName == null) {
          servletName = "";
        }

        // 4. 从实例池中获取反射创建的业务 Servlet,触发 service 模板派发
        HspHttpServlet hspHttpServlet = HspTomcat.servletMapping.get(servletName);
        if (hspHttpServlet != null) {
          hspHttpServlet.service(hspRequest, hspResponse);
        } else {
          // 5. 若未匹配到注册的 Servlet 实例,回写 404 Not Found 响应
          String resp = HspResponse.respHeader + "<h1>404 Not Found</h1>";
          hspResponse.getOutputStream().write(resp.getBytes());
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      if (socket != null) {
        try {
          socket.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
}