第二章：Tomcat 架构原理

第二章：Tomcat 架构原理

第二章：Tomcat 架构原理

2.1 引言

2.2 Tomcat 架构概览

Tomcat 的架构设计遵循模块化和组件化的原则，其核心架构可以概括为 容器 和 连接器 两大组件，以及它们之间协同工作的 请求处理流程。

2.2.1 核心组件

• Server (服务器): Tomcat 实例的顶层组件，一个 Server 实例代表着一个 Tomcat 服务器进程。它可以包含多个 Service 组件。server.xml 文件中 <Server> 标签定义了 Server 组件。

• Service (服务): Service 组件是 Server 的子组件，一个 Server 可以包含多个 Service。每个 Service 包含一个 Engine 和多个 Connector。Service 的主要职责是将 Connector 接收的请求传递给 Engine 进行处理。server.xml 文件中 <Service> 标签定义了 Service 组件。

• Connector (连接器): Connector 组件负责接收客户端的请求，并将请求传递给 Engine 进行处理，同时将 Engine 处理后的响应返回给客户端。Tomcat 支持多种 Connector，例如 HTTP Connector（处理 HTTP 请求）、AJP Connector（用于与前端 Web 服务器如 Apache 或 Nginx 集成）等。server.xml 文件中 <Connector> 标签定义了 Connector 组件。

• Engine (引擎): Engine 组件是 Service 的核心组件，负责处理 Connector 接收到的请求。一个 Service 只能有一个 Engine。Engine 接收到请求后，会根据请求的 Host 信息选择合适的 Host 组件进行处理。server.xml 文件中 <Engine> 标签定义了 Engine 组件。

• Host (虚拟主机): Host 组件代表一个虚拟主机，一个 Engine 可以包含多个 Host。每个 Host 对应一个域名或 IP 地址，负责管理部署在该虚拟主机上的 Web 应用（Context）。server.xml 文件中 <Host> 标签定义了 Host 组件。

• Context (上下文): Context 组件代表一个 Web 应用，是 Tomcat 中最小的部署单元。一个 Host 可以包含多个 Context。Context 负责加载和管理 Web 应用，包括 Servlet、Filter、Listener 等 Web 组件。server.xml 文件中 <Context> 标签或单独的 Context 配置文件（如 context.xml 或每个 Web 应用的 META-INF/context.xml）定义了 Context 组件。

2.2.2 组件关系图

可以使用 Mermaid 的 graph TD 图来清晰地展示 Tomcat 的组件层次关系：

图 2-1 Tomcat 组件层次关系图

从图中可以看出，Tomcat 的组件呈现树状结构，Server 是根节点，Service 是 Server 的子节点，Engine 是 Service 的子节点，Host 是 Engine 的子节点，Context 是 Host 的子节点。Connector 与 Service 同级，负责接收请求并传递给 Service 中的 Engine。

2.3 Tomcat 请求处理流程详解

理解 Tomcat 的请求处理流程是深入理解其架构原理的关键。当客户端发送一个请求到 Tomcat 服务器时，请求会经历以下步骤：

1. Connector 接收请求: 客户端的请求首先被 Connector 组件接收。Connector 监听指定的端口，等待客户端连接。一旦接收到连接请求，Connector 会创建一个 Socket 连接，并创建一个 Request 和 Response 对象来封装请求和响应信息。

   代码实践 (Connector 配置 - server.xml):

   <Connector port="8080" protocol="HTTP/1.1"
              connectionTimeout="20000"
              redirectPort="8443" />
   ​

   这段配置定义了一个 HTTP Connector，监听 8080 端口，使用 HTTP/1.1 协议，连接超时时间为 20 秒，重定向端口为 8443（用于 HTTPS）。

2. Connector 将请求传递给 Service: Connector 接收到请求后，将其交给所属的 Service 组件进行处理。一个 Connector 只能属于一个 Service。

3. Service 将请求传递给 Engine: Service 接收到请求后，将其交给 Engine 组件进行处理。一个 Service 只能有一个 Engine。

4. Engine 根据 Host 信息选择 Host: Engine 接收到请求后，会根据请求头中的 Host 信息 (域名或 IP 地址) 匹配合适的 Host 组件。如果找不到匹配的 Host，则会使用默认 Host。

   代码实践 (Engine 和 Host 配置 - server.xml):

   <Service name="Catalina">
       <Engine name="Catalina" defaultHost="localhost">
           <Host name="localhost"  appBase="webapps"
                 unpackWARs="true" autoDeploy="true">
           </Host>
           <Host name="example.com"  appBase="example-webapps"
                 unpackWARs="true" autoDeploy="true">
           </Host>
       </Engine>
       <Connector port="8080" protocol="HTTP/1.1"
                  connectionTimeout="20000"
                  redirectPort="8443" />
   </Service>
   ​

   这段配置定义了一个名为 "Catalina" 的 Service，包含一个名为 "Catalina" 的 Engine。Engine 默认 Host 为 "localhost"。定义了两个 Host： "localhost" 和 "example.com"，分别对应不同的 appBase (Web 应用部署目录)。

5. Host 根据 Context Path 选择 Context: Host 接收到请求后，会根据请求的 Context Path (Web 应用的上下文路径，例如 /myapp) 匹配合适的 Context 组件。如果找不到匹配的 Context，Tomcat 会返回 404 错误。

   代码实践 (Context 配置 - server.xml 或 context.xml):

   在 server.xml 中配置 Context (不推荐，通常用于测试或简单场景):

   <Host name="localhost"  appBase="webapps"
         unpackWARs="true" autoDeploy="true">
       <Context path="/myapp" docBase="myapp" reloadable="true" />
   </Host>
   ​

   在 context.xml 中配置 Context (推荐，更灵活):

   在 conf/Catalina/localhost/myapp.xml (文件名与 Context Path 对应) 中:

   <Context docBase="myapp" reloadable="true" />
   ​

   以上配置定义了一个 Context，Context Path 为 /myapp，Web 应用的文档根目录为 myapp (相对于 appBase)，reloadable="true" 表示允许热部署。

6. Context 处理请求: Context 组件负责处理具体的请求。它会创建一个 ServletRequest 和 ServletResponse 对象，并将请求传递给相应的 Servlet 进行处理。

   代码实践 (Servlet 代码 - MyServlet.java):

   import javax.servlet.ServletException;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import java.io.IOException;
   import java.io.PrintWriter;
   public class MyServlet extends HttpServlet {
       @Override
       protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
           response.setContentType("text/html");
           PrintWriter out = response.getWriter();
           out.println("<html><body>");
           out.println("<h1>Hello from MyServlet!</h1>");
           out.println("</body></html>");
       }
   }
   ​

   代码实践 (Servlet 映射 - web.xml):

   在 Web 应用的 WEB-INF/web.xml 文件中配置 Servlet 映射:

   <servlet>
       <servlet-name>MyServlet</servlet-name>
       <servlet-class>MyServlet</servlet-class>
   </servlet>
   <servlet-mapping>
       <servlet-name>MyServlet</servlet-name>
       <url-pattern>/hello</url-pattern>
   </servlet-mapping>
   ​

   这段代码定义了一个名为 MyServlet 的 Servlet，并将其映射到 URL 路径 /hello。当请求的 URL 匹配 /myapp/hello 时，Tomcat 会调用 MyServlet 的 doGet 方法处理请求。

7. Servlet 处理请求并生成响应: Servlet 接收到请求后，执行业务逻辑，并生成响应内容。Servlet 通过 ServletResponse 对象将响应内容写入，例如设置响应头、写入 HTML 内容等。

8. Context 将响应返回给 Host，Host 返回给 Engine，Engine 返回给 Service，Service 返回给 Connector: Servlet 处理完请求后，Context 将生成的响应返回给 Host，Host 返回给 Engine，Engine 返回给 Service，Service 返回给 Connector。

9. Connector 将响应返回给客户端: Connector 接收到响应后，将其通过 Socket 连接返回给客户端浏览器。至此，一个完整的请求处理流程结束。

2.3.1 请求处理流程图

可以使用 Mermaid 的 graph TD 图来可视化请求处理流程：

图 2-2 Tomcat 请求处理流程图

2.4 Tomcat 核心组件详解

2.4.1 Server 组件

Server 组件是 Tomcat 的顶层容器，它代表着一个完整的 Tomcat 实例。Server 组件的主要职责是创建和管理 Service 组件，并负责 Tomcat 的生命周期管理，例如启动、停止等。

Server 组件的主要功能:

• 生命周期管理: Server 组件负责 Tomcat 实例的启动和停止。

• Service 管理: Server 组件包含一个或多个 Service 组件，并负责管理这些 Service 组件的生命周期。

• 全局资源管理: Server 组件可以配置全局的 JNDI 资源，供所有 Web 应用共享。

Server 组件的配置 (server.xml):

• <Server port="8005" shutdown="SHUTDOWN">: 定义 Server 组件，port 属性指定关闭 Tomcat 的端口，shutdown 属性指定关闭命令。

• <GlobalNamingResources>: 定义全局 JNDI 资源。

• <Listener>: 配置 Server 级别的监听器，例如生命周期监听器、JMX 监听器等。

2.4.2 Service 组件

Service 组件是 Server 的子组件，它将一个 Engine 和多个 Connector 组合在一起，对外提供服务。Service 组件的主要职责是将 Connector 接收的请求传递给 Engine 进行处理，并负责管理 Connector 和 Engine 的生命周期。

Service 组件的主要功能:

• 请求路由: Service 组件将 Connector 接收的请求路由到 Engine 进行处理。

• 生命周期管理: Service 组件负责管理 Engine 和 Connector 的生命周期。

• 共享资源管理: Service 组件可以配置 Service 级别的 JNDI 资源，供该 Service 下的所有 Web 应用共享。

Service 组件的配置 (server.xml):

• <Service name="Catalina">: 定义 Service 组件，name 属性指定 Service 的名称。

• <Engine>: 配置 Engine 组件。

• <Connector>: 配置 Connector 组件。

• <Executor>: 配置 Service 级别的线程池，供 Connector 和 Engine 共享。

• <Listener>: 配置 Service 级别的监听器。

• <Realm>: 配置 Service 级别的安全认证 Realm。

2.4.3 Connector 组件

Connector 组件负责接收客户端的请求，并将请求传递给 Engine 进行处理，同时将 Engine 处理后的响应返回给客户端。Tomcat 支持多种 Connector，例如 HTTP Connector 和 AJP Connector。

Connector 组件的主要功能:

• 接收请求: Connector 监听指定的端口，接收客户端的连接请求和 HTTP 请求。

• 协议解析: Connector 解析客户端发送的请求，将请求数据封装成 Request 对象。

• 请求传递: Connector 将 Request 对象传递给 Service 中的 Engine 进行处理。

• 响应返回: Connector 将 Engine 处理后的 Response 对象转换为 HTTP 响应，返回给客户端。

常见的 Connector 类型:

• HTTP Connector (Coyote HTTP/1.1 Connector): 用于处理 HTTP 和 HTTPS 请求，是最常用的 Connector 类型。

  • protocol="HTTP/1.1" 或 protocol="org.apache.coyote.http11.Http11NioProtocol" (NIO) 或 protocol="org.apache.coyote.http11.Http11AprProtocol" (APR) 或 protocol="org.apache.coyote.http11.Http11Nio2Protocol" (NIO2)。

  • port="8080": 监听端口。

  • redirectPort="8443": HTTPS 重定向端口。

  • connectionTimeout="20000": 连接超时时间。

  • maxThreads="200": 最大线程数。

• AJP Connector (Coyote AJP/1.3 Connector): 用于与前端 Web 服务器 (例如 Apache 或 Nginx) 集成，通常用于反向代理场景。

  • protocol="AJP/1.3" 或 protocol="org.apache.coyote.ajp.AjpNioProtocol" (NIO) 或 protocol="org.apache.coyote.ajp.AjpAprProtocol" (APR) 或 protocol="org.apache.coyote.ajp.AjpNio2Protocol" (NIO2)。

  • port="8009": 监听端口 (默认 AJP 端口)。

  • redirectPort="8443": HTTPS 重定向端口。

  • secretRequired="true" 和 secret="your_ajp_secret": AJP 认证配置 (增强安全性)。

2.4.4 Engine 组件

Engine 组件是 Service 的核心组件，负责处理 Connector 接收到的请求。一个 Service 只能有一个 Engine。Engine 接收到请求后，会根据请求的 Host 信息选择合适的 Host 组件进行处理。

Engine 组件的主要功能:

• Host 管理: Engine 组件包含多个 Host 组件，并负责管理这些 Host 组件。

• 请求路由: Engine 组件根据请求头中的 Host 信息将请求路由到合适的 Host 组件进行处理。

• Valve 管道: Engine 组件可以配置 Valve 管道，用于在请求处理过程中执行一些通用的处理逻辑，例如日志记录、安全检查等。

Engine 组件的配置 (server.xml):

• <Engine name="Catalina" defaultHost="localhost">: 定义 Engine 组件，name 属性指定 Engine 的名称，defaultHost 属性指定默认 Host。

• <Host>: 配置 Host 组件。

• <Valve>: 配置 Engine 级别的 Valve。

• <Realm>: 配置 Engine 级别的安全认证 Realm。

• <Cluster>: 配置 Engine 级别的集群。

2.4.5 Host 组件

Host 组件代表一个虚拟主机，一个 Engine 可以包含多个 Host。每个 Host 对应一个域名或 IP 地址，负责管理部署在该虚拟主机上的 Web 应用 (Context)。

Host 组件的主要功能:

• Context 管理: Host 组件包含多个 Context 组件，并负责管理这些 Context 组件。

• 虚拟主机: Host 组件实现虚拟主机功能，允许在同一个 Tomcat 实例上运行多个 Web 应用，并通过不同的域名或 IP 地址进行访问。

• Web 应用部署: Host 组件负责 Web 应用的部署和卸载。

• Valve 管道: Host 组件可以配置 Valve 管道，用于在请求处理过程中执行一些特定于虚拟主机的处理逻辑。

Host 组件的配置 (server.xml):

• <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true">: 定义 Host 组件，name 属性指定 Host 的域名或 IP 地址，appBase 属性指定 Web 应用部署目录，unpackWARs="true" 表示自动解压 WAR 包，autoDeploy="true" 表示自动部署 Web 应用。

• <Context>: 配置 Context 组件。

• <Valve>: 配置 Host 级别的 Valve。

• <Realm>: 配置 Host 级别的安全认证 Realm。

2.4.6 Context 组件

Context 组件代表一个 Web 应用，是 Tomcat 中最小的部署单元。一个 Host 可以包含多个 Context。Context 负责加载和管理 Web 应用，包括 Servlet、Filter、Listener 等 Web 组件。

Context 组件的主要功能:

• Web 应用加载: Context 组件负责加载 Web 应用，包括读取 web.xml 配置文件，创建 ServletContext 对象，实例化 Servlet、Filter、Listener 等 Web 组件。

• Servlet 容器: Context 组件是 Servlet 容器，负责管理 Servlet 的生命周期，调用 Servlet 的 service 方法处理请求。

• 资源管理: Context 组件可以配置 Context 级别的 JNDI 资源，供该 Web 应用使用。

• 会话管理: Context 组件负责管理用户的会话 (Session)。

• Valve 管道: Context 组件可以配置 Valve 管道，用于在请求处理过程中执行一些特定于 Web 应用的处理逻辑。

Context 组件的配置 (server.xml, context.xml, 或 Web 应用的 META-INF/context.xml):

• <Context path="/myapp" docBase="myapp" reloadable="true">: 定义 Context 组件，path 属性指定 Context Path (Web 应用的上下文路径)，docBase 属性指定 Web 应用的文档根目录，reloadable="true" 表示允许热部署。

• <WatchedResource>: 配置需要监听的文件资源，用于热部署。

• <Parameter>: 配置 Context 初始化参数。

• <Environment>: 配置 Context 级别的环境变量。

• <Resource>: 配置 Context 级别的 JNDI 资源。

• <Valve>: 配置 Context 级别的 Valve。

• <Realm>: 配置 Context 级别的安全认证 Realm。

• <Loader>: 配置 Context 级别的类加载器。

• <Manager>: 配置 Context 级别的会话管理器。

2.5 总结

理解 Tomcat 的架构原理对于 Web 开发者来说至关重要。它可以帮助我们：

• 更好地配置 Tomcat: 根据应用需求合理配置 Tomcat 的各个组件，例如选择合适的 Connector 类型、调整线程池大小、配置虚拟主机等。

• 优化 Web 应用性能: 了解请求处理流程可以帮助我们找到性能瓶颈，并进行针对性的优化，例如优化 Servlet 代码、减少请求处理时间、合理使用缓存等。

• 快速定位和解决问题: 当 Web 应用出现问题时，例如请求处理错误、性能下降等，理解 Tomcat 架构可以帮助我们快速定位问题根源，并采取相应的解决措施。

• 设计更高效的 Web 应用: Tomcat 的架构思想，例如组件化、模块化、管道化等，可以借鉴到我们自己的 Web 应用设计中，提高应用的灵活性、可扩展性和可维护性。

掌握 Tomcat 架构原理是成为一名优秀的 Java Web 开发者的重要一步。希望本章内容能够帮助读者深入理解 Tomcat，并在实际开发中灵活运用。