Tomcat 架构图 (Tomcat Architecture Diagram)

目录 (Table of Contents)

1. Tomcat整体架构图
2. Server服务器组件
3. Service服务组件
4. Connector连接器架构
5. Container容器架构
6. 协议处理机制
7. 组件交互流程
8. 核心组件详解

---

1. Tomcat整体架构图 (Tomcat Overall Architecture Diagram)

---

2. Server服务器组件 (Server Component)

2.1 Server架构图 (Server Architecture)

2.2 Server组件说明 (Server Component Description)

Server组件是Tomcat的最顶层组件，代表整个Tomcat服务器实例：

• 端口监听：默认监听8005端口，用于接收关闭命令
• 关闭命令：通过SHUTDOWN命令优雅关闭服务器
• Service管理：管理一个或多个Service组件
• JMX管理：提供JMX管理接口，支持远程监控和管理
• 全局命名服务：提供全局JNDI命名服务

// Server接口定义
public interface Server extends Lifecycle {
    // 获取全局命名资源
    public NamingResourcesImpl getGlobalNamingResources();
    
    // 设置全局命名资源
    public void setGlobalNamingResources(NamingResourcesImpl globalNamingResources);
    
    // 获取JMX域名
    public String getJmxDomain();
    
    // 获取Service数组
    public Service[] findServices();
    
    // 获取指定名称的Service
    public Service findService(String name);
}

---

3. Service服务组件 (Service Component)

3.1 Service架构图 (Service Architecture)

3.2 Service组件说明 (Service Component Description)

Service组件是Connector和Container的组合，提供完整的Web服务：

• Connector连接器：处理客户端连接，支持多种协议
• Container容器：处理请求并生成响应
• Jasper JSP引擎：编译和执行JSP页面
• Naming命名服务：提供JNDI命名服务
• Session会话管理：管理用户会话
• Logging日志服务：记录运行日志
• JMX管理：提供管理接口

---

4. Connector连接器架构 (Connector Architecture)

4.1 Connector详细架构图 (Connector Detailed Architecture)

4.2 Connector组件详细说明 (Connector Component Detailed Description)

ProtocolHandler（协议处理器）

负责处理特定协议的连接和请求：

// ProtocolHandler接口
public interface ProtocolHandler {
    // 获取端点
    public Endpoint getEndpoint();
    
    // 获取处理器
    public Handler getHandler();
    
    // 启动协议处理器
    public void start();
    
    // 停止协议处理器
    public void stop();
}

Endpoint（端点）

负责监听端口和接收连接：

• ServerSocket：服务器端套接字，监听指定端口
• Socket：客户端套接字，处理具体连接
• 端口绑定：绑定到特定端口（如8080、8443等）

Acceptor（接收器）

负责接收客户端连接：

• 连接接收：循环接收新的客户端连接
• 线程管理：通常使用独立线程处理
• 连接队列：将接收到的连接放入处理队列

Handler（处理器）

负责处理接收到的连接：

• 请求读取：从Socket读取请求数据
• 协议解析：根据协议格式解析请求
• 响应生成：生成协议格式的响应

Processor（处理器）

负责具体的请求处理：

• HTTP解析：解析HTTP请求行、头部、体部
• 请求转换：将协议数据转换为Request对象
• 响应转换：将Response对象转换为协议数据

Adapter（适配器）

负责将Processor与Container连接：

// Adapter接口
public interface Adapter {
    // 服务请求
    public void service(Request request, Response response) throws Exception;
}

AsyncTimeout（异步超时）

处理异步请求的超时：

• 超时检测：检测异步请求是否超时
• 超时处理：处理超时请求
• 线程调度：调度异步处理线程

---

5. Container容器架构 (Container Architecture)

5.1 Container层次结构图 (Container Hierarchy)

5.2 Container组件说明 (Container Component Description)

Engine（引擎）

• 作用：表示整个Catalina Servlet引擎
• 特点：可以包含多个Host，处理Service的所有请求
• 实现：StandardEngine类

public interface Engine extends Container {
    // 获取默认主机名
    public String getDefaultHost();
    
    // 设置默认主机名
    public void setDefaultHost(String defaultHost);
    
    // 获取Service
    public Service getService();
    
    // 设置Service
    public void setService(Service service);
}

Host（主机）

• 作用：表示一个虚拟主机
• 特点：可以包含多个Context，对应不同的Web应用
• 实现：StandardHost类

public interface Host extends Container {
    // 获取应用基础目录
    public String getAppBase();
    
    // 设置应用基础目录
    public void setAppBase(String appBase);
    
    // 获取自动部署标志
    public boolean getAutoDeploy();
    
    // 设置自动部署标志
    public void setAutoDeploy(boolean autoDeploy);
}

Context（上下文）

• 作用：表示一个Web应用
• 特点：包含多个Wrapper，对应不同的Servlet
• 实现：StandardContext类

public interface Context extends Container {
    // 获取文档根目录
    public String getDocBase();
    
    // 设置文档根目录
    public void setDocBase(String docBase);
    
    // 获取路径
    public String getPath();
    
    // 设置路径
    public void setPath(String path);
    
    // 重新加载应用
    public void reload();
}

Wrapper（包装器）

• 作用：表示一个Servlet
• 特点：最底层的容器，包装具体的Servlet实例
• 实现：StandardWrapper类

public interface Wrapper extends Container {
    // 获取Servlet类名
    public String getServletClass();
    
    // 设置Servlet类名
    public void setServletClass(String servletClass);
    
    // 获取Servlet
    public Servlet getServlet();
    
    // 获取加载器
    public Loader getLoader();
}

---

6. 协议处理机制 (Protocol Processing Mechanism)

6.1 协议支持架构图 (Protocol Support Architecture)

6.2 协议处理详细说明 (Protocol Processing Detailed Description)

HTTP/1.1协议处理

// HTTP/1.1协议处理器
public class Http11NioProtocol extends AbstractProtocol<NioChannel> {
    
    public Http11NioProtocol() {
        // 设置端点
        setEndpoint(new NioEndpoint());
    }
    
    @Override
    protected Processor createProcessor() {
        // 创建HTTP处理器
        return new Http11Processor();
    }
}

HTTPS/1.1协议处理

// HTTPS/1.1协议处理器
public class Http11Nio2Protocol extends AbstractProtocol<Nio2Channel> {
    
    public Http11Nio2Protocol() {
        // 设置SSL端点
        setEndpoint(new Nio2Endpoint());
    }
    
    @Override
    protected Processor createProcessor() {
        // 创建HTTPS处理器
        return new Http11Processor(true); // SSL支持
    }
}

AJP/1.3协议处理

// AJP/1.3协议处理器
public class AjpNioProtocol extends AbstractAjpProtocol<NioChannel> {
    
    public AjpNioProtocol() {
        // 设置AJP端点
        setEndpoint(new NioEndpoint());
    }
    
    @Override
    protected Processor createProcessor() {
        // 创建AJP处理器
        return new AjpProcessor();
    }
}

---

7. 组件交互流程 (Component Interaction Flow)

7.1 请求处理完整流程图 (Request Processing Complete Flow)

7.2 组件交互详细说明 (Component Interaction Detailed Description)

连接建立阶段

1. 客户端发起连接：浏览器或其他客户端发起TCP连接
2. Connector接收连接：Connector组件接收连接请求
3. Endpoint创建ServerSocket：绑定到指定端口并监听
4. Acceptor启动：启动独立线程接收连接

请求处理阶段

5. Acceptor接收Socket：接收客户端的Socket连接
6. 创建Processor：为每个连接创建Processor实例
7. 协议解析：Processor解析HTTP/HTTPS/AJP协议
8. Adapter适配：将协议请求适配为Servlet请求
9. Container处理：Container处理Servlet请求

响应阶段

10. Container生成响应：业务逻辑处理完成
11. Adapter适配响应：将Servlet响应适配为协议响应
12. Processor发送响应：通过Socket发送响应给客户端

---

8. 核心组件详解 (Core Components Detailed Explanation)

8.1 Server组件生命周期 (Server Component Lifecycle)

8.2 线程模型 (Threading Model)

8.3 配置示例 (Configuration Examples)

Server.xml配置

<Server port="8005" shutdown="SHUTDOWN">
    <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
    
    <GlobalNamingResources>
        <Resource name="UserDatabase" auth="Container"
                  type="org.apache.catalina.UserDatabase"
                  description="User database that can be updated and saved"
                  factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
                  pathname="conf/tomcat-users.xml" />
    </GlobalNamingResources>
    
    <Service name="Catalina">
        <Connector port="8080" protocol="HTTP/1.1"
                   connectionTimeout="20000"
                   redirectPort="8443" />
        
        <Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
                   maxThreads="150" SSLEnabled="true">
            <SSLHostConfig>
                <Certificate certificateKeystoreFile="conf/localhost-rsa.jks"
                             type="RSA" />
            </SSLHostConfig>
        </Connector>
        
        <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
        
        <Engine name="Catalina" defaultHost="localhost">
            <Host name="localhost" appBase="webapps"
                  unpackWARs="true" autoDeploy="true">
                <Context path="/myapp" docBase="myapp" reloadable="true" />
            </Host>
        </Engine>
    </Service>
</Server>

编程式配置

// 创建Server
Server server = new StandardServer();
server.setPort(8005);

// 创建Service
Service service = new StandardService();
service.setName("Catalina");
server.addService(service);

// 创建HTTP Connector
Connector httpConnector = new Connector("HTTP/1.1");
httpConnector.setPort(8080);
service.addConnector(httpConnector);

// 创建Engine
Engine engine = new StandardEngine();
engine.setName("Catalina");
service.setContainer(engine);

// 创建Host
Host host = new StandardHost();
host.setName("localhost");
host.setAppBase("webapps");
engine.addChild(host);

---

总结 (Summary)

Tomcat的架构设计体现了模块化和层次化的思想，通过清晰的组件划分和职责分离，实现了高性能、可扩展的Servlet容器。主要特点包括：

1. 分层架构：Server → Service → Connector/Container的清晰层次
2. 协议支持：支持HTTP、HTTPS、AJP等多种协议
3. 容器设计：Engine → Host → Context → Wrapper的容器层次
4. 线程模型：高效的NIO线程模型处理并发请求
5. 生命周期管理：完善的组件生命周期管理
6. 可扩展性：支持自定义组件和扩展点

理解Tomcat的架构有助于：

• 更好地配置和优化Tomcat服务器
• 快速定位和解决运行时问题
• 开发自定义的Tomcat组件
• 设计高性能的Web应用程序