你有没有遇到过这样的场景：在项目启动会议上，关于技术选型的争论激烈不休？
> Person A: “我觉得我们的 Java Web 应用程序应该使用 Apache Tomcat，它稳定、成熟，是行业标准。”
>
> Person B: “但我更倾向于 Eclipse Jetty，它轻量、启动快，特别适合我们现在的微服务架构。”
你作为决策者或开发者，是否也曾在两者之间犹豫不决？别担心，在这篇文章中，我们将深入探讨这两位 Java 服务器领域的重量级选手。我们将不仅仅是比较它们的参数，还会深入到代码层面、架构设计以及实际的生产环境场景中，帮助你做出最明智的选择。准备好开始这段激动人心的技术探索之旅了吗？让我们从理解它们的核心身份开始。
目录
1. 核心概念解析：它们到底是什么？
在深入细节之前，我们需要先确立一个基准。Apache Tomcat 和 Eclipse Jetty 本质上都是 Servlet 容器，同时也是 Web 服务器。它们的核心职责是接收来自客户端（通常是浏览器）的 HTTP 请求，并将其转发给由 Java 编写的应用程序进行处理，最后将响应返回给用户。简单来说，它们就是 Java Web 应用的“管家”。
1.1 什么是 Apache Tomcat？
Apache Tomcat，通常简称为 Tomcat，是由 Apache 软件基金会维护的开源项目。它不仅仅是一个简单的 Web 服务器，更是一个实现了 Java Servlet、JavaServer Pages (JSP)、Java Expression Language 和 Java WebSocket 技术规范的完整容器。
我们可以把 Tomcat 想象成一艘重型航母。它的核心在于提供了一个健壮的、经过大规模生产环境验证的环境，用于运行 Java 代码。
核心组件工作原理：
Tomcat 的架构主要由几个核心组件构成，了解它们有助于我们后续进行调优：
- Connector (连接器)： 负责处理与客户端的连接。它监听特定的端口（默认 8080），解析 HTTP 请求，并将其封装成 Request 对象。
- Container (容器)： 这是 Tomcat 的“大脑”，负责管理 Servlet 的生命周期。
* Engine： 整个 Catalina Servlet 引擎。
* Host： 虚拟主机，例如 localhost。
* Context： Web 应用本身，一个 Context 对应一个 Web 应用。
- Service： 将 Connector 和 Container 组合在一起，对外提供服务。
Tomcat 的优势领域：
Tomcat 严格遵守 Java EE（现在的 Jakarta EE）规范。如果你在开发一个传统的企业级应用，大量使用了 JSP、Servlet 或者依赖 Java EE 的标准特性，Tomcat 是最安全、最标准的选择。它的文档详尽，社区庞大，当你遇到问题时，几乎总能在 Stack Overflow 或官方文档中找到答案。
1.2 什么是 Eclipse Jetty？
Eclipse Jetty（简称 Jetty）则展现出了另一种风格。它同样是一个开源的 Servlet 容器，但它的设计哲学是“小巧、高效、可嵌入”。Jetty 最初诞生于极度追求性能和高并发的场景，因此它的架构非常现代化。
如果说 Tomcat 是重型航母，Jetty 就像是一艘敏捷的快艇。
架构亮点：
Jetty 的核心是基于 Handler（处理器） 的架构。与 Tomcat 的容器层级结构不同，Jetty 将请求处理看作是一系列的 Handler 组成的链。这种设计使得 Jetty 极其灵活，你可以像搭积木一样拆卸或替换功能模块。
Jetty 的优势领域：
Jetty 最大的特点是其 可嵌入性。这意味着你不需要在服务器上单独安装一个 Tomcat 服务，你可以直接在代码中实例化一个 Jetty 服务器对象，让它随着你的应用程序启动而启动，停止而停止。这使得它成为了大型互联网公司（如 Google App Engine, Hadoop）构建大规模分布式系统的首选。
2. 性能深度剖析：不仅仅是速度
性能是我们最关心的指标，但性能不仅仅是“谁跑得更快”，而是“在什么场景下跑得更稳”。
2.1 Apache Tomcat 的性能特征
Tomcat 的设计初衷是处理大量的长期连接和复杂的企业逻辑。
- 并发模型： Tomcat 传统的 BIO (Blocking I/O) 模式在处理每一个连接时都需要分配一个线程。虽然在高版本中引入了 NIO (Non-blocking I/O) 和 APR (Apache Portable Runtime) 来提升性能，但其核心处理逻辑依然非常依赖线程池。
- 吞吐量： 对于计算密集型或者处理复杂业务逻辑的应用，Tomcat 表现极佳。它能够高效地管理线程生命周期，并在高负载下保持稳定。
- 静态资源处理： Tomcat 处理静态文件（如 HTML, CSS, 图片）的能力虽然不如 Nginx 专业的反向代理服务器，但在纯 Java 容器中，它的表现是中规中矩的，足够应对大多数后台管理系统的需求。
2.2 Eclipse Jetty 的性能特征
Jetty 从诞生之初就是为了解决 C10K 问题（即同时处理一万个连接）而设计的。
- 并发模型： Jetty 天生对 NIO 友好。它使用少量的线程就能处理成千上万个长连接。这使得它在 WebSocket 通信和 Comet (长轮询) 技术方面表现卓越。
- 延迟与响应： 由于 Jetty 的内核极其精简，它在处理请求时的延迟通常比 Tomcat 更低。对于需要毫秒级响应的微服务接口，Jetty 的优势非常明显。
- 内存占用： Jetty 的内存占用通常比 Tomcat 低，特别是在空闲连接较多的情况下。
场景对比：
想象一下，如果你正在构建一个 在线聊天系统 或 实时股票推送平台，大量的连接会长时间挂起等待消息。这时候，Jetty 的 NIO 架构能让你用极少的资源支撑海量用户。而如果你正在构建一个 复杂的 ERP 系统，主要涉及大量的数据库操作和复杂的页面渲染，Tomcat 的线程池模型可能更符合你的直觉，且稳定性更佳。
3. 实战代码：配置与启动
让我们通过代码来看看它们的区别。为了符合现代开发习惯，我们将分别使用 Maven 依赖将它们嵌入到 Java 应用中，这也是 Spring Boot 之所以能同时支持两者的底层原理。
3.1 在 Tomcat 中运行
虽然 Tomcat 常被独立部署，但我们也来看看如何通过代码配置它。Tomcat 的配置通常涉及到 XML 文件（如 server.xml），但通过编程式配置也能让我们看清其结构。
// 引入 Tomcat 核心库
import org.apache.catalina.Context;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.startup.Tomcat;
public class EmbedTomcatDemo {
public static void main(String[] args) throws LifecycleException {
// 1. 实例化 Tomcat 对象
// Tomcat 的启动非常依赖目录结构，需要指定基准目录
Tomcat tomcat = new Tomcat();
tomcat.setPort(8080);
tomcat.getConnector(); // 触发默认连接器的创建
// 2. 创建 Context，这代表一个 Web 应用
// addContext 中的第一个参数是 context path，第二个参数是物理路径
// 这里设为空表示根路径，docBase 设为当前目录
Context ctx = tomcat.addContext("", System.getProperty("user.dir"));
// 3. 编写一个简单的 Servlet
// Tomcat 完全遵循 Servlet 规范，必须先注册 Servlet
Tomcat.addServlet(ctx, "helloServlet", new HelloServlet());
ctx.addServletMappingDecoded("/hello", "helloServlet");
// 4. 启动服务器并等待
tomcat.start();
System.out.println("Tomcat 服务器已启动，访问 http://localhost:8080/hello");
tomcat.getServer().await();
}
// 简单的 Servlet 实现
public static class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
resp.setContentType("text/plain;charset=UTF-8");
resp.getWriter().println("Hello from Apache Tomcat!");
}
}
}
代码分析：
- 你可以看到 Tomcat 的 API 设计比较“重量级”。你需要显式地创建
Context，并将其映射到物理文件路径。这反映了 Tomcat 作为一个完整容器的理念：它希望像管理文件系统一样管理应用。 - 配置建议： 在实际生产中，我们通常不修改代码，而是通过修改
server.xml来调整线程池参数。例如，
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443"
maxThreads="300"
minSpareThreads="10" />
这种基于 XML 的配置虽然繁琐，但对于运维人员来说是透明的，便于在不停机的情况下调整参数。
3.2 在 Jetty 中运行
现在，让我们来看看 Jetty 是如何实现的。你会明显感觉到它的 API 更加面向对象。
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.AbstractHandler;
import org.eclipse.jetty.server.handler.HandlerList;
import org.eclipse.jetty.server.handler.ResourceHandler;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class EmbedJettyDemo {
public static void main(String[] args) throws Exception {
// 1. 实例化 Server 对象
// Jetty 的 Server 非常纯粹，就是一个连接器和一个处理器的集合
Server server = new Server(8081); // 端口直接在构造函数中
// 2. 构建处理器链
// Jetty 的核心概念是 Handler。你可以将多个功能串联起来。
ServletContextHandler context = new ServletContextHandler();
context.setContextPath("/");
// 注册 Servlet，方式与 Tomcat 类似，但使用的是 Holder 模式
context.addServlet(new ServletHolder(new HelloServlet()), "/hello");
// 你可以轻松地添加资源文件处理，比如静态文件
ResourceHandler resourceHandler = new ResourceHandler();
resourceHandler.setResourceBase(System.getProperty("user.dir"));
HandlerList handlers = new HandlerList();
handlers.addHandler(resourceHandler);
handlers.addHandler(context);
// 3. 将处理器链设置给 Server
server.setHandler(handlers);
// 4. 启动
server.start();
System.out.println("Jetty 服务器已启动，访问 http://localhost:8081/hello");
server.join();
}
// 同样的 Servlet 实现
public static class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
resp.setContentType("text/plain;charset=UTF-8");
resp.getWriter().println("Hello from Eclipse Jetty! 快速且灵活。");
}
}
}
代码分析：
- Handler 的灵活性： 注意看
HandlerList。在 Jetty 中，我们不仅仅是在运行一个 Web 容器，我们在构建一个处理网络请求的管道。你可以先让请求经过资源处理器，再经过 Servlet 处理器。这种灵活性是 Jetty 嵌入式特性的核心。 - 无 XML 依赖： 虽然 Jetty 也支持 XML 配置，但在代码中直接构建 Handler 树是 Jetty 社区非常推崇的做法。这使得配置与应用代码紧密贴合，减少了“配置地狱”的风险。
4. 配置与易用性：XML vs Java Config
4.1 Tomcat 的配置逻辑
Tomcat 的强项在于其规范性。在传统的 Tomcat 部署中，你需要：
- 将 INLINECODEc7aba2a0 文件放入 INLINECODE997a9214 目录。
- 修改
server.xml来配置数据源、Realm（安全域）和集群设置。 - 配置
context.xml来进行应用级的 JNDI 资源配置。
你可能会遇到的问题：
新手常被 Tomcat 的类加载机制困扰。Tomcat 的类加载层次结构非常复杂（Bootstrap, System, Common, WebAppClassloader 等）。如果你在 INLINECODE75fd74a0 目录和应用的 INLINECODEb2a04de4 目录放入了不同版本的 jar 包，可能会导致 INLINECODE707d7ed0 或 INLINECODEa95a6bc0。解决这些问题需要深刻理解 Tomcat 的双亲委派模型的变种。
4.2 Jetty 的配置逻辑
Jetty 推崇“最小化配置”。它的启动非常快，在开发过程中，你甚至不需要重启服务器就能看到代码变更（这在 Jetty 中叫做 hot reload，通常结合 jetty-maven-plugin 使用）。
Jetty 的配置文件 jetty.xml 实际上是一个 XML 格式的 Java 代码映射。它通过 XML 来构建前面提到的 Server 和 Handler 对象树。
最佳实践：
对于微服务架构，我强烈推荐 Jetty。你可以把 Jetty 的配置写死在代码里（例如在 Spring Boot 的 @Configuration 类中），这样每个微服务都携带了它自己的运行时环境，完全自治，不依赖外部的服务器安装。
5. 故障排查与常见错误
在实际工作中，你不可避免地会遇到一些坑。让我们看看这两者在某些常见问题上的表现。
5.1 内存泄漏
- Tomcat: 由于 Tomcat 的生命周期管理非常严格，如果你在应用代码中使用了静态变量持有 Context 的引用，或者使用了 ThreadLocal 而没有在部署停止时清理，Tomcat 在热部署时会报出严重的内存泄漏警告（
The web application appears to have started a thread named [xxx] but has failed to stop it）。
* 解决方案： 我们需要确保在 ServletContextListener 的 contextDestroyed 方法中手动清理线程和引用。
- Jetty: Jetty 的内存模型通常更加轻量，但同样面临连续部署时的内存问题。由于 Jetty 常被嵌入使用，如果你忘记调用
server.stop()，JVM 可能无法正常退出，因为非守护线程还在运行。
5.2 连接器阻塞
- Tomcat: 如果你的后端处理很慢，Tomcat 的默认线程池可能会被耗尽。当线程数达到
maxThreads设定的上限（默认通常是 200），新的请求只能在队列中等待。如果队列满了，请求就会被拒绝（HTTP 503）。 - Jetty: 由于 Jetty 使用 NIO，它在处理慢速 I/O（比如上传文件到慢速存储）时，不会阻塞处理线程。这意味在同样的硬件配置下，Jetty 可能能比默认配置的 Tomcat 承受更多的挂起连接。
6. 总结：我们该如何选择？
经过这番深入的探讨，我们可以得出以下结论。这两者之间并没有绝对的“赢家”，只有“最适合”。
选择 Apache Tomcat 的理由：
- 你的团队对传统的 Java EE 规范非常熟悉，并且习惯于通过 XML 进行服务器配置。
- 你正在维护一个遗留的、庞大的单体应用，这个应用依赖于特定的 Servlet 版本特性。
- 你需要高度稳定的服务，且不想在服务器架构层做太多的定制化开发。“能用、好用、不出错”是首要目标。
选择 Eclipse Jetty 的理由：
- 你正在构建微服务、云原生应用，或者需要将服务器嵌入到设备或应用程序中。
- 你的应用需要处理大量的长连接（WebSocket、即时通讯、游戏服务器）。Jetty 的异步 I/O 性能在这里无可匹敌。
- 你非常看重启动速度和内存占用，特别是在容器化环境中，Jetty 的轻量级能节省大量资源。
接下来的建议：
既然我们已经了解了它们的区别，我建议你不妨做一个实际的小实验。尝试将同一个简单的 Spring Boot 应用分别切换到 Tomcat 和 Jetty 启动器上（在 pom.xml 中排除默认的 starter，添加另一个），然后观察启动日志、内存占用以及请求处理的差异。动手实践是掌握这些概念的最好方式。
希望这篇文章能帮助你理清思路，在你的下一个项目中，自信地做出最符合需求的技术决策！