Tomcat 工作原理:从连接器到 Servlet 容器,HTTP 请求究竟是如何被处理的?

一、Tomcat 是什么?

在前面的文章中,我们学习了 Servlet,知道 Servlet 是 JavaWeb 中处理 HTTP 请求的核心组件。

但是,Servlet 本身并不能独立运行,它需要一个 Servlet 容器来管理和调用。

Tomcat 就是这样一个容器。

Tomcat 是一个开源的 Web 服务器,同时也是一个 Servlet 容器,能够接收 HTTP 请求、管理 Servlet 生命周期,并将请求分发给对应的 Servlet 处理。

例如,我们启动一个 Spring Boot 项目,经常能看到这样的日志:

Tomcat started on port 8080

这表示 Tomcat 已经启动,并开始监听 8080 端口。

当浏览器访问:

http://localhost:8080/user/list

Tomcat 就会接收请求,并将其交给对应的 Web 应用处理。

这里需要区分两个概念:

  • Web 服务器:负责接收和处理 HTTP 通信。

  • Servlet 容器:负责管理 Servlet 组件及其生命周期。

Tomcat 同时具备这两方面的能力。

二、Tomcat 的整体架构

Tomcat 并不是一个简单的请求转发程序,它内部有一套比较完整的组件体系。

其中最重要的架构是:

Server → Service → Connector + Engine → Host → Context → Wrapper

我们先看整体结构:

Server
  |
  +---- Service
          |
          +---- Connector
          |       |
          |       +---- 接收网络连接
          |       +---- 解析 HTTP 请求
          |       +---- 生成 Request / Response
          |
          +---- Engine
                  |
                  +---- Host
                          |
                          +---- Context
                                  |
                                  +---- Wrapper
                                          |
                                          +---- Servlet

这几个组件分别负责不同的工作。

1. Server:Tomcat 顶层容器

Server 是 Tomcat 的最顶层组件。

它代表整个 Tomcat 实例,负责管理内部的 Service,并提供整体启动和关闭能力。

可以把 Server 理解为 Tomcat 的总管理者。

2. Service:服务组件

Service 负责将 Connector 和 Engine 组合在一起。

它包含:

  • 一个 Engine。

  • 一个或多个 Connector。

Connector 负责接收客户端请求,Engine 负责处理进入 Tomcat 的请求。

3. Connector:连接器

Connector 是 Tomcat 接收客户端请求的重要组件。

它主要负责:

  • 监听网络端口。

  • 接收客户端连接。

  • 读取网络数据。

  • 解析 HTTP 请求。

  • 将请求转换成 Tomcat 内部可以处理的 Request 和 Response 对象。

例如:

浏览器
   |
   | HTTP 请求
   v
Connector
   |
   | 解析请求
   v
Request / Response

我们平时配置的 8080 端口,就与 Connector 有关。

4. Engine:引擎

Engine 是请求处理链路中的顶层容器。

它负责接收 Connector 传递过来的请求,并根据请求中的主机信息选择对应的 Host。

5. Host:虚拟主机

Host 代表一个虚拟主机。

例如,同一个 Tomcat 实例可以配置多个域名,每个域名对应一个 Host。

Tomcat 可以根据请求中的主机名,将请求交给对应的 Host 处理。

6. Context:Web 应用上下文

Context 代表一个 Web 应用。

例如:

http://localhost:8080/shop

其中 /shop 通常可以作为这个 Web 应用的上下文路径。

一个 Tomcat 实例可以部署多个 Web 应用,每个应用对应一个 Context。

7. Wrapper:Servlet 包装容器

Wrapper 是 Tomcat 中管理单个 Servlet 的容器。

它负责管理 Servlet 实例及其生命周期,例如:

  • 创建 Servlet 实例。

  • 初始化 Servlet。

  • 调用 Servlet 处理请求。

  • 在适当的时候销毁 Servlet。

因此,Wrapper 可以理解为 Servlet 在 Tomcat 容器体系中的直接管理者。

三、Tomcat 是如何接收 HTTP 请求的?

理解了整体架构之后,我们来看一个实际问题:

浏览器发送的 HTTP 请求,是如何进入 Tomcat 的?

例如:

http://localhost:8080/user/list

这里涉及网络连接和端口监听。

1. 什么是端口?

端口可以理解为操作系统中区分网络服务的逻辑入口。

例如:

localhost:8080

其中:

  • localhost:表示本机。

  • 8080:表示访问的端口。

当 Tomcat 启动时,会让 Connector 监听配置好的端口。

浏览器访问 8080 端口时,就可以与 Tomcat 建立网络连接。

2. Connector 如何接收请求?

Connector 内部涉及几个重要组件:

  • Endpoint:负责底层网络连接的接收与处理。

  • Processor:负责处理协议数据。

  • ProtocolHandler:负责协调协议处理过程。

以 HTTP 请求为例:

浏览器
   |
   | TCP 连接
   v
Endpoint
   |
   | 读取网络数据
   v
Processor
   |
   | 解析 HTTP 协议
   v
Request / Response

这里需要注意:

Tomcat 不同版本和不同 Connector 实现的内部细节可能有所区别,上面描述的是便于理解的整体处理关系。

3. 为什么需要 Request 和 Response?

浏览器发送过来的数据本质上是网络字节流。

Tomcat 需要将这些数据解析成程序可以使用的对象。

例如:

浏览器发送:

GET /user/list HTTP/1.1
Host: localhost:8080

Tomcat 解析后,可以获取:

请求方法:GET
请求路径:/user/list
请求主机:localhost:8080

然后将这些信息封装到内部请求对象中。

这样,后续的容器组件就不需要直接处理原始网络数据了。

四、Tomcat 如何找到对应的 Web 应用?

假设 Tomcat 中部署了两个 Web 应用:

Tomcat
  |
  +---- shop
  |
  +---- admin

它们分别对应:

http://localhost:8080/shop
http://localhost:8080/admin

当用户访问:

http://localhost:8080/shop/user/list

Tomcat 需要判断这个请求应该交给哪个 Web 应用。

大致过程:

  1. Connector 接收并解析 HTTP 请求。

  2. Engine 根据请求信息选择 Host。

  3. Host 根据上下文路径匹配 Context。

  4. Context 负责后续的 Servlet 映射和请求处理。

这里最重要的是理解:

Context 对应一个 Web 应用,Tomcat 可以通过上下文路径区分不同的 Web 应用。

五、Tomcat 如何找到对应的 Servlet?

确定 Web 应用之后,还需要找到具体处理请求的 Servlet。

例如,我们编写了:

@WebServlet("/user/list")
public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(
            HttpServletRequest request,
            HttpServletResponse response
    ) throws IOException {

        response.getWriter().write("用户列表");
    }
}

用户访问:

http://localhost:8080/shop/user/list

Tomcat 会根据 Servlet 的 URL 映射规则,找到对应的 Wrapper。

Wrapper 管理着 UserServlet。

随后,Tomcat 就可以调用 UserServlet 处理请求。

整体流程:

请求路径:/shop/user/list
          |
          v
      Tomcat
          |
          v
      Host 匹配
          |
          v
      Context 匹配
          |
          v
      Wrapper 匹配
          |
          v
      UserServlet
          |
          v
      处理请求

需要注意:

Servlet 的映射路径 /user/list 是相对于当前 Web 应用的上下文路径进行匹配的。

六、Tomcat 如何管理 Servlet 生命周期?

上一篇我们学习过 Servlet 的生命周期:

init()
  |
  v
service()
  |
  v
destroy()

那么,这些方法究竟是谁调用的?

答案就是 Servlet 容器。

在 Tomcat 中,Wrapper 负责管理对应的 Servlet 实例。

当第一次请求到达某个尚未初始化的 Servlet 时,Tomcat 会根据配置创建 Servlet 实例,并调用初始化方法。

之后,后续请求就可以使用已经初始化的 Servlet 实例。

当 Web 应用卸载或者 Tomcat 关闭时,容器会按照生命周期管理规则调用销毁方法。

所以,开发人员通常不需要自己手动创建和调用 Servlet。

这也是 Servlet 容器存在的意义之一。

七、Tomcat 如何处理并发请求?

假设现在有 100 个用户同时访问:

GET /user/list

Tomcat 不会简单地让所有请求一个接一个地执行。

它需要具备并发处理能力。

1. 什么是线程池?

线程池是一种线程管理机制。

它会预先创建或按需创建一定数量的工作线程,用于执行提交的任务。

Tomcat 可以使用线程池中的工作线程处理请求,避免每个请求都频繁创建和销毁线程。

示意:

          Tomcat
             |
             v
          线程池
             |
     +-------+-------+
     |       |       |
     v       v       v
   线程A   线程B   线程C
     |       |       |
     v       v       v
   请求1   请求2   请求3

2. 一个 Servlet 能被多个线程同时访问吗?

可以。

传统 Servlet 通常采用单实例、多线程的请求处理方式。

例如:

请求1 ----\
           \
请求2 ------> UserServlet 实例
           /
请求3 ----/

多个工作线程可能同时调用同一个 Servlet 实例的请求处理方法。

因此,Servlet 中的成员变量需要特别注意线程安全问题。

3. Tomcat 线程池有什么作用?

主要有三个方面:

  • 减少线程频繁创建和销毁带来的开销。

  • 控制同时处理请求的线程数量。

  • 提高服务器处理并发请求的能力。

不过,线程池并不意味着服务器可以无限制地处理请求。

当请求数量超过处理能力时,可能出现排队、等待甚至连接失败等情况。

八、Tomcat 和 Spring Boot 是什么关系?

这是学习 Java 后端时非常容易混淆的一个问题。

我们平时创建 Spring Boot Web 项目,添加:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

项目启动后,经常会看到 Tomcat 启动日志。

这是因为 Spring Boot 的传统 Servlet Web 应用通常默认使用嵌入式 Tomcat。

那么它们分别负责什么?

技术主要职责
Spring Boot自动配置应用并简化启动
Tomcat提供 Web 服务器和 Servlet 容器能力
Spring MVC负责 Web 请求映射、分发和处理
DispatcherServletSpring MVC 的核心前端控制器
Controller处理具体业务请求

例如:

@RestController
@RequestMapping("/user")
public class UserController {

    @GetMapping("/list")
    public String list() {
        return "用户列表";
    }
}

浏览器访问:

http://localhost:8080/user/list

请求的大致处理过程:

浏览器
   |
   v
Tomcat Connector
   |
   v
Tomcat 容器
   |
   v
DispatcherServlet
   |
   v
Controller
   |
   v
Service
   |
   v
Mapper
   |
   v
数据库

这里需要特别注意:

Controller 并不是 Tomcat 直接管理的 Servlet。

在典型的 Spring MVC 应用中,Tomcat 管理的是 DispatcherServlet,DispatcherServlet 再通过 Spring MVC 的请求映射机制找到对应的 Controller 方法。

这也是传统 JavaWeb 和 Spring Boot Web 开发之间的重要联系。

九、总结

这一篇主要理解了 Tomcat 的内部结构和请求处理过程。

核心知识点:

  1. Tomcat 既是 Web 服务器,也是 Servlet 容器。

  2. Server 是 Tomcat 的顶层组件。

  3. Service 将 Connector 和 Engine 组合起来。

  4. Connector 负责接收连接和处理 HTTP 协议。

  5. Engine、Host、Context、Wrapper 组成请求处理的容器层级。

  6. Wrapper 负责管理对应的 Servlet。

  7. Tomcat 可以通过线程池处理并发请求。

  8. Spring Boot Web 项目通常使用内嵌 Tomcat,Spring MVC 通过 DispatcherServlet 处理请求。

最重要的是理解这条请求链路:

浏览器
  |
  v
Connector
  |
  v
Engine
  |
  v
Host
  |
  v
Context
  |
  v
Wrapper
  |
  v
Servlet
  |
  v
HTTP 响应

这条链路是理解传统 JavaWeb 请求处理机制的重要基础。


Logo

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐