在Java后端开发的浩瀚海洋里Tomcat就像一座永不熄灭的灯塔，支撑着无数互联网应用的运行。我们每天dou在用它，部署War包，配置Server.xml，但你有没有在夜深人静时想过：这头庞然大物的心脏，到底是怎么跳动的？

说实话，面对Tomcat那动辄数万行的源码，hen多人dou会望而却步。但Ru果我们剥去它层层叠叠的外衣——集群、Session管理、安全认证、Jasper编译器——剩下的那个赤裸裸的内核，其实简单得令人惊讶。今天咱们就撸起袖子，不依赖任何第三方框架，仅用JDK自带的类库，徒手造一个迷你的Web服务器。通过这个过程，你将彻底kan透HTTP协议的本质，以及Servlet容器那“欺骗”世界的魔法。

别被那些复杂的架构图吓到了。无论你是用Nginx、Apache还是Tomcat，一个基础的HTTP服务器，无论规模大小，其核心流程douKe以抽象为以下几个步骤。这就像是在餐厅点餐，流程其实非常固定：

监听端口服务器启动，打开一个端口，死死盯着有没有客户端发来连接请求。

接受连接一旦有请求过来建立TCP连接。为了不阻塞后面的客人，通常得找个专门的线程或者线程池来伺候这位客人。

解析请求浏览器发来的是一堆字符串，我们需要读懂它：你要访问哪个URL？用什么方法？有没有带Cookie？

处理业务根据URL找到对应的处理逻辑。Ru果是静态文件，直接从硬盘读；Ru果是动态请求，就调用Java代码。

构建响应把处理结果按照HTTP协议的格式包装好，回传给浏览器。

为了实现这个闭环，我们设计了五个核心类，它们就像五个精干的战士，共同撑起了这个TinyTomcat的骨架。下面我们来kankan它们是如何协同工作的。

在真正的Tomcat中，有一套极其复杂的Servlet规范，但在我们的极简版里一切从简。为了支持灵活的动态处理，我们 定义一个“契约”。这就是SimpleServlet接口。

这个接口非常简单，甚至有点“简陋”。它只有一个service方法，接受请求和响应对象。这其实是设计模式中策略模式的完美体现。服务器引擎本身并不关心具体的业务逻辑——它只管调用service。至于你是要输出“Hello World”，还是要查询数据库，那是你实现类的事情。

import java.io.IOException;
/**
 * 极简Servlet接口
 * 这是我们所有业务逻辑必须遵守的“法律”
 */
@FunctionalInterface
public interface SimpleServlet {
    void service throws IOException;
}

这个类是整个程序的起点，也是调度中心，堪称“大脑”。你Ke以把它想象成一个繁忙的路口指挥官。其核心逻辑主要集中在start方法和handleClient方法中。

在这里我们使用了ServerSocket来监听端口。为了提高性Neng，避免一个请求卡死整个服务器，我们引入了线程池。每当有一个新的连接进来就扔给线程池去处理，主线程立刻解放出来继续等待下一个连接。这就是TomcatNeng够处理高并发的基础雏形。

此外这里还维护了一个servletMapping，这是一个Map结构，负责将URL路径映射到具体的Servlet实例上。这就是路由的本质。

import java.io.*;
import java.net.*;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.*;
import java.time.*;
import java.time.format.*;
/**
 * Mini版 Tomcat - 核心服务器
 * 功Neng：监听端口、解析HTTP、路由请求
 */
public class SimpleTomcat {
    private int port = 9090; // 默认端口设为9090，避免冲突
    private String webRoot = ".";
    private ServerSocket serverSocket;
    private ExecutorService threadPool;
    private boolean running = false;
    // Servlet映射表：路径 -> Servlet实例
    private Map servletMapping = new ConcurrentHashMap<>;
    // 静态文件后缀映射，告诉浏览器该用什么方式打开文件
    private static final Map CONTENT_TYPES = Map.of(
        ".html", "text/html; charset=utf-8",
        ".txt", "text/plain; charset=utf-8",
        ".js", "application/javascript",
        ".css", "text/css",
        ".json", "application/json",
        ".png", "image/png",
        ".jpg", "image/jpeg",
        ".jpeg", "image/jpeg",
        ".gif", "image/gif"
    );
    public SimpleTomcat {
        this.port = port;
        this.webRoot = webRoot;
        this.threadPool = Executors.newFixedThreadPool; // 线程池大小设为100
    }
    public void start throws IOException {
        serverSocket = new ServerSocket;
        running = true;
        System.out.printf;
        System.out.printf.getAbsolutePath);
        // 注册默认处理器
        registerDefaultServlets;
        // 无限循环，等待连接
        while  {
            Socket client = serverSocket.accept;
            threadPool.submit -> handleClient);
        }
    }
    // ...省略部分辅助代码，如stop和addServlet...
    private void handleClient {
        try (client; 
             BufferedReader in = new BufferedReader));
             OutputStream out = client.getOutputStream) {
            // 1. 读取请求行
            String requestLine = in.readLine;
            if  return;
            String parts = requestLine.split;
            if  return;
            String method = parts;
            String path = parts;
            // 2. 创建请求/响应对象
            SimpleRequest request = new SimpleRequest;
            SimpleResponse response = new SimpleResponse;
            // 3. 路由处理
            if ) {
                serveWelcomePage;
            } else if ) {
                // 动态Servlet处理
                servletMapping.get.service;
            } else if ) {
                serveFavicon;
            } else {
                // 静态文件服务
                serveStaticFile;
            }
        } catch  {
            e.printStackTrace;
        }
    }
    // ...省略serveStaticFile等内部方法...
}

HTTP请求本质上是按特定格式组织的文本流。当浏览器发来请求时它只是发了一堆字节。SimpleRequest类的任务就是把这些冷冰冰的字节翻译成我们Neng理解的Java对象。

在这个类里我们Zuo了三件主要的事：

解析请求行提取出Method和URL路径。

解析查询参数Ru果你访问的是/hello?name=Tom，我们需要把name和Tom提取出来存入一个Map中。

解析请求头虽然在这个极简版里我们用得不多，但读取Header是必须的，因为我们需要通过判断空行来知道Header部分何时结束。

import java.io.*;
import java.util.*;
/**
 * 请求对象
 * 负责将Socket流中的HTTP文本解析为结构化数据
 */
public class SimpleRequest {
    private final String method;
    private final String path;
    private final Map headers = new HashMap<>;
    private final Map params = new HashMap<>;
    public SimpleRequest throws IOException {
        this.method = method;
        this.path = path;
        // 解析查询参数 
        int qIndex = path.indexOf;
        if  {
            parseQueryString);
        }
        // 解析请求头，直到遇到空行
        String line;
        while ) != null && !line.isEmpty) {
            int colon = line.indexOf;
            if  {
                headers.put(
                    line.substring.trim.toLowerCase,
                    line.substring.trim
                );
            }
        }
    }
    private void parseQueryString {
        for ) {
            String kv = pair.split;
            if  {
                params.put;
            }
        }
    }
    public String getMethod { return method; }
    public String getPath { 
        int qIndex = path.indexOf;
        return qIndex> 0 ? path.substring : path; 
    }
    public String getParameter { return params.get; }
    public String getHeader { return headers.get); }
}

有来无往非礼也。解析完请求，我们得给浏览器一个交代。SimpleResponse类的职责就是构建一个格式正确的HTTP响应。

这里有一个非常巧妙的设计：延迟发送头。我们设置了headersSent标志位。这是因为在业务代码中，我们可Neng会先设置状态码、Content-Type等头部信息，然后再输出响应体。Ru果一调用setContentType就发送数据，那后续就没法改状态了。

所以真正的发送动作被推迟到了getWriter或getOutputStream第一次被调用的时候。这时候，程序会自动调用sendHeaders方法，把状态行和头部先写出去，紧接着写Body。注意那个\r \r ，它是分隔头部和身体的关键标记，少一个dou不行。

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;
/**
 * 响应对象
 * 负责封装HTTP响应状态、头信息和 body
 */
public class SimpleResponse {
    private final OutputStream output;
    private PrintWriter writer;
    private int status = 200;
    private String statusText = "OK";
    private final Map headers = new HashMap<>;
    private boolean headersSent = false;
    public SimpleResponse {
        this.output = output;
        headers.put;
        headers.put
            .format));
    }
    public void setStatus {
        this.status = status;
        this.statusText = text;
    }
    public void setContentType {
        headers.put;
    }
    public PrintWriter getWriter throws IOException {
        sendHeaders; // 确保头部先发送
        if  {
            writer = new PrintWriter, true);
        }
        return writer;
    }
    private void sendHeaders throws IOException {
        if  return;
        headersSent = true;
        StringBuilder sb = new StringBuilder;
        // 拼接状态行
        sb.append.append.append.append.append;
        // 拼接Header
        for ) {
            sb.append).append.append).append;
        }
        // 关键的空行，分隔Body
        sb.append;
        output.write.getBytes);
    }
}

有了容器，有了请求响应对象，终于Ke以写点业务代码了。HelloServlet就是我们契约的一个具体实现。这个类就像一个简单的控制器，它处理业务，并渲染视图。

你kan，在这里我们完全不需要关心Socket怎么连，流怎么读，我们只关心怎么拿到参数，怎么输出HTML。这就是Servlet规范带给开发者的便利。

import java.io.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
/**
 * 示例Servlet
 * 一个简单的问候页面展示如何获取参数和输出HTML
 */
public class HelloServlet implements SimpleServlet {
    @Override
    public void service throws IOException {
        String name = req.getParameter;
        if .isEmpty) {
            name = "朋友";
        }
        res.setContentType;
        PrintWriter writer = res.getWriter;
        writer.println;
        writer.println;
        writer.println;
        writer.println; color: white; }");
        writer.println; }");
        writer.println;
        writer.println;
        writer.println.format(
            DateTimeFormatter.ofPattern) + "