深入剖析Tomcat原理

前言

Tomcat 是 Java 生态最经典的Web 容器+Servlet 容器 ，也是我们日常开发中最常用的中间件。它不仅能运行我们的 SpringBoot、SSM 项目，更封装了网络通信、请求解析、Servlet 生命周期、会话管理等核心能力。

本文将从核心原理 → 整体架构 → 核心组件源码解析 → 手写极简 Tomcat 案例全流程讲解，帮你彻底吃透 Tomcat 本质。

---

一、Tomcat 核心原理总览

1. 核心定位

Tomcat 本质是基于 Java 编写的 HTTP 服务器 + Servlet 容器：

• HTTP 服务器：监听端口（默认8080），接收浏览器/客户端的 HTTP 请求，解析请求报文；
• Servlet 容器 ：加载、管理 Servlet，执行 Servlet 的 init()/service()/destroy() 生命周期方法，生成响应返回给客户端。

2. 核心工作流程（极简版）

1. 启动 Tomcat，Server 组件 启动，绑定Service 组件；
2. Service 组件 关联Connector（连接器） 和Container（容器）；
3. Connector 监听端口，接收 HTTP 请求，封装成Request/Response对象；
4. Connector 将请求交给Container ，通过Engine → Host → Context → Wrapper层层匹配；
5. 找到对应的 Servlet，执行业务逻辑，生成响应；
6. Connector 将响应返回给客户端，完成一次请求处理。

---

二、Tomcat 核心架构（两大核心模块）

Tomcat 架构高度解耦，核心分为连接器（Connector） 和容器（Container） 两大模块，由Server和Service串联：

架构层级图

Server（顶级组件，整个Tomcat服务器）
└── Service（服务组件，关联连接器+容器）
    ├── Connector（连接器：处理网络通信，HTTP/1.1、AJP等）
    └── Container（容器：处理Servlet请求，四级容器）
        ├── Engine（引擎：接收请求，分发到对应Host）
        │   ├── Host（虚拟主机：对应域名，如localhost）
        │   │   ├── Context（Web应用：对应一个项目，如/ROOT、/demo）
        │   │   │   ├── Wrapper（封装器：对应一个Servlet）

核心组件职责

1. Server：Tomcat 启动入口，管理生命周期，负责启动/停止整个服务；
2. Service：组合 Connector 和 Container，一个 Service 可包含多个 Connector，但只有一个 Container；
3. Connector ：网络通信核心，负责接收客户端请求、解析协议、封装请求对象、返回响应；
4. Container ：Servlet 管理核心，四级容器分层管理 Web 应用和 Servlet，实现请求路由。

---

三、核心组件源码深度解析（基于 Tomcat 8.5.84）

环境准备

1. 下载源码：Tomcat 8.5.84 源码
2. 导入 IDEA，配置依赖（ant、jdk1.8+）

---

1. Server 组件源码解析

核心接口 ：org.apache.catalina.Server
默认实现 ：org.apache.catalina.core.StandardServer

核心功能

• 加载server.xml配置；
• 管理所有 Service 组件；
• 提供启动/停止/等待关闭的能力。

核心源码（关键方法）

public final class StandardServer extends LifecycleMBeanBase implements Server {
    // 管理所有Service组件
    private Service services[] = new Service[0];
    
    // 启动Server：遍历启动所有Service
    @Override
    protected void startInternal() throws LifecycleException {
        // 启动所有Service
        for (Service service : services) {
            service.start();
        }
    }
    
    // 停止Server：遍历停止所有Service
    @Override
    protected void stopInternal() throws LifecycleException {
        for (Service service : services) {
            service.stop();
        }
    }
}

总结：Server 是 Tomcat 的「总管家」，负责全局生命周期管理。

---

2. Service 组件源码解析

核心接口 ：org.apache.catalina.Service
默认实现 ：org.apache.catalina.core.StandardService

核心功能

• 关联 Connector 和 Container；
• 统一管理连接器和容器的生命周期。

核心源码

public class StandardService extends LifecycleMBeanBase implements Service {
    // 关联的容器（Engine）
    private Container container = null;
    // 关联的连接器集合
    private Connector connectors[] = new Connector[0];

    // 启动Service：启动容器 → 启动所有连接器
    @Override
    protected void startInternal() throws LifecycleException {
        // 启动Engine容器
        if (container != null) {
            container.start();
        }
        // 启动所有连接器（监听端口）
        for (Connector connector : connectors) {
            connector.start();
        }
    }
}

总结：Service 是「粘合剂」，把网络通信（Connector）和业务处理（Container）绑定在一起。

---

3. Connector 组件源码解析（最核心！）

核心类 ：org.apache.catalina.connector.Connector

核心功能

1. 基于 NIO/BIO 监听端口，接收 HTTP 请求；
2. 解析 HTTP 协议（请求行、请求头、请求体）；
3. 封装 Tomcat 自定义的Request/Response对象；
4. 将请求转发给 Container 处理。

核心源码（关键流程）

public class Connector extends LifecycleMBeanBase {
    // 协议处理器（NIO/BIO，处理网络请求）
    private ProtocolHandler protocolHandler = null;

    // 初始化连接器：绑定协议处理器
    @Override
    protected void initInternal() throws LifecycleException {
        // 绑定NIO协议处理器（默认）
        protocolHandler = new NioEndpoint();
        protocolHandler.init();
    }

    // 启动连接器：开启端口监听
    @Override
    protected void startInternal() throws LifecycleException {
        protocolHandler.start();
    }
}

关键子组件：Endpoint（网络通信底层）

NioEndpoint是 NIO 模式的网络通信核心，基于Java NIO实现：

• Acceptor线程：监听客户端连接；
• Poller线程：监听连接的读写事件；
• Worker线程池：处理请求解析和业务调用。

总结：Connector 是 Tomcat 的「大门」，负责所有客户端的网络交互。

---

4. Container 组件源码解析（四级容器）

核心接口 ：org.apache.catalina.Container
四级容器实现类：

• Engine → StandardEngine
• Host → StandardHost
• Context → StandardContext
• Wrapper → StandardWrapper

核心功能

• Engine：请求分发引擎，匹配虚拟主机；
• Host：管理多个 Web 应用；
• Context：对应一个 Web 应用，管理 Servlet、Filter、Listener；
• Wrapper：封装一个 Servlet，管理 Servlet 生命周期。

核心源码（Wrapper 管理 Servlet 生命周期）

public class StandardWrapper extends ContainerBase implements ServletConfig, Wrapper {
    // 加载Servlet实例
    private Servlet instance = null;

    // 初始化Servlet
    public synchronized Servlet loadServlet() throws ServletException {
        // 反射创建Servlet实例
        instance = (Servlet) Class.forName(servletClass).newInstance();
        // 执行Servlet初始化方法
        instance.init(this);
        return instance;
    }

    // 处理请求：调用service方法
    public void invoke(Request request, Response response) {
        Servlet servlet = loadServlet();
        // 执行Servlet业务方法
        servlet.service(request.getRequest(), response.getResponse());
    }
}

总结：Container 是 Tomcat 的「业务大脑」，负责找到并执行对应的 Servlet。

---

四、手写极简 Tomcat 案例（原理落地）

为了让你彻底理解 Tomcat 原理，我们手写一个迷你版 Tomcat，实现核心能力：

• 监听端口；
• 解析 HTTP 请求；
• 加载自定义 Servlet；
• 响应请求。

1. 项目结构

MiniTomcat/
├── MyTomcat.java       // Tomcat核心类（监听端口、处理请求）
├── MyRequest.java      // 封装请求对象
├── MyResponse.java     // 封装响应对象
├── MyServlet.java     // Servlet接口
├── HelloServlet.java   // 自定义Servlet（业务逻辑）
└── web.properties      // 配置Servlet映射

---

2. 完整源码

1. MyServlet.java（Servlet 接口）

/**
 * 模拟Servlet接口，定义生命周期方法
 */
public interface MyServlet {
    // 初始化
    void init();
    // 处理请求
    void service(MyRequest request, MyResponse response);
    // 销毁
    void destroy();
}

2. MyRequest.java（封装请求）

/**
 * 封装HTTP请求：获取请求路径
 */
public class MyRequest {
    private String requestUrl;

    // 解析请求流，提取请求路径
    public MyRequest(InputStream inputStream) throws IOException {
        byte[] bytes = new byte[1024];
        int len = inputStream.read(bytes);
        if (len > 0) {
            String msg = new String(bytes, 0, len);
            // 解析请求行：GET /hello HTTP/1.1
            this.requestUrl = msg.split(" ")[1];
        }
    }

    public String getRequestUrl() {
        return requestUrl;
    }
}

3. MyResponse.java（封装响应）

/**
 * 封装HTTP响应：返回标准HTTP格式数据
 */
public class MyResponse {
    private OutputStream outputStream;

    public MyResponse(OutputStream outputStream) {
        this.outputStream = outputStream;
    }

    // 输出HTTP响应
    public void write(String content) throws IOException {
        String httpResponse = "HTTP/1.1 200 OK\n" +
                "Content-Type: text/html;charset=UTF-8\n" +
                "\n" + content;
        outputStream.write(httpResponse.getBytes());
        outputStream.close();
    }
}

4. HelloServlet.java（自定义业务 Servlet）

/**
 * 自定义Servlet，实现业务逻辑
 */
public class HelloServlet implements MyServlet {
    @Override
    public void init() {
        System.out.println("HelloServlet 初始化完成...");
    }

    @Override
    public void service(MyRequest request, MyResponse response) {
        try {
            response.write("<h1>Hello MiniTomcat! 自定义Servlet运行成功</h1>");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void destroy() {
        System.out.println("HelloServlet 销毁...");
    }
}

5. web.properties（配置映射）

# 格式：请求路径=Servlet全类名
/hello=com.tomcat.HelloServlet

6. MyTomcat.java（核心启动类）

import java.io.FileInputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Properties;

/**
 * 迷你版Tomcat：监听端口，处理HTTP请求
 */
public class MyTomcat {
    // 加载Servlet配置
    private Properties properties = new Properties();

    // 初始化：加载配置文件
    public void init() {
        try {
            String path = MyTomcat.class.getResource("/web.properties").getPath();
            properties.load(new FileInputStream(path));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 启动Tomcat
    public void start() {
        init();
        try {
            // 监听8080端口
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("MiniTomcat 启动成功，端口：8080");

            // 循环接收客户端请求
            while (!serverSocket.isClosed()) {
                Socket socket = serverSocket.accept();
                // 处理请求
                process(socket);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 处理请求：解析请求 → 匹配Servlet → 执行业务
    private void process(Socket socket) throws Exception {
        MyRequest request = new MyRequest(socket.getInputStream());
        MyResponse response = new MyResponse(socket.getOutputStream());

        // 获取请求路径
        String url = request.getRequestUrl();
        // 根据配置获取Servlet类名
        String className = properties.getProperty(url);

        if (className != null) {
            // 反射创建Servlet实例
            MyServlet servlet = (MyServlet) Class.forName(className).newInstance();
            // 执行Servlet方法
            servlet.init();
            servlet.service(request, response);
            servlet.destroy();
        } else {
            response.write("<h1>404 Not Found</h1>");
        }
        socket.close();
    }

    // 主方法：启动Tomcat
    public static void main(String[] args) {
        new MyTomcat().start();
    }
}

---

3. 运行测试

1. 启动MyTomcat.java，控制台输出：MiniTomcat 启动成功，端口：8080；
2. 浏览器访问：http://localhost:8080/hello；
3. 页面显示：Hello MiniTomcat! 自定义Servlet运行成功；
4. 控制台打印 Servlet 生命周期日志。

效果验证 ：我们手写的迷你 Tomcat，完美实现了Tomcat 核心原理！

---

五、核心总结

1. Tomcat 核心原理一句话

Tomcat 是HTTP 服务器 + Servlet 容器，通过 Connector 处理网络通信，通过 Container 管理 Servlet 生命周期，完成请求接收→解析→处理→响应的全流程。

2. 核心架构两大模块

• Connector：负责网络通信（监听端口、解析 HTTP、封装请求/响应）；
• Container：负责业务处理（四级容器：Engine→Host→Context→Wrapper）。

3. Servlet 生命周期（Tomcat 管理）

1. 加载：反射创建 Servlet 实例；
2. 初始化：执行init()（只执行一次）；
3. 服务：执行service()（每次请求都执行）；
4. 销毁：执行destroy()（服务器关闭时执行）。

4. 手写迷你 Tomcat 核心价值

剥离了 Tomcat 的复杂封装，还原了网络通信、请求解析、Servlet 管理三大本质，是理解 Tomcat 原理的最佳实践。

---

结语

Tomcat 看似复杂，核心逻辑却非常清晰：网络通信交给 Connector，业务处理交给 Container。