| 编辑推荐: |
本文主要介绍Tomcat的总体架构,连接器
Connector，容器 Container，希望对您的学习有所帮助。
本文来自于云时代架构，由火龙果软件Alice编辑、推荐。 |
|
总体架构
核心功能：
1.处理 socket 连接，负责将网络字节流与 Request
和 Response 对象的转化；
2.加载和管理 Servlet，以及具体处理 Request 请求；
3.Tomcat 支持的 io 模型有 NIO、NIO2、APR，Tomcat
支持的应用层协议有 http1.1 ajp http2.0。
Tomcat 最顶层是 server，一个 server 有多个 service，一个 service
有多个连接器和一个容器，连接器和容器之间通过 ServletRequest 和 ServletResponse
通信。
通过组合模式、模板方法、观察者模式和骨架抽象类，tomcat 定义了基类 LifeCycleBean
实现 LifeCycle 接口，把公共的逻辑，生命周期状态转变和维护、生命事件的触发和监听器的添加删除，子类负责实现自己的
init、stop 和 start 等方法。
tomcat 自定义了监听器；
@WebListener 注解，定义自己的监听器；
StandardServer、StandardService 等是 Server 和 Service
组件的具体实现类，它们都继承了 LifecycleBase。
StandardEngine、StandardHost、StandardContext 和 StandardWrapper
是相应容器组件的具体实现类，因为它们都是容器，所以继承了 ContainerBase 抽象基类，而
ContainerBase 实现了 Container 接口，也继承了 LifecycleBase
类，它们的生命周期管理接口和功能接口是分开的。
连接器 Connector
连接器进一步细化：
监听网络端口；
接受网络请求；
读取网络字节流；
根据应用层协议解析字节流，生成统一的 tomcat request 和 tomcat response
对象；
将 tomcat request 对象转成 servletRequest；
调用 servlet 容器，得到 servletResponse；
将 servletResponse 转成 tomcat response；
将 tomcat response 转成网络字节流；
将响应字节流写回给浏览器；
按照高内聚的功能划分：
网络通信；
应用层协议解析；
tomcat request/response 与 servlet request/response
的转换；
组件通过接口交互，好处是封装变化。Endpoint 负责提供字节流给 Processor，Processor
负责提供 tomcat request 对象给 Adapter，Adapter负责提供 Servlet
Request 给容器。
其中 Endpoint 和 Processor 抽象组装在一起形成了 ProtocolHandler
组件。
ProtocolHandler
Endpoint
接口，抽象实现类是 AbstractEndpoint，具体子类在 NioEndpoint 和 Nio2Endpoint，其中两个重要组件：Acceptor
和 SocketProcessor。
Acceptor 用于监听 Socket 连接请求，SocketProcessor 用于处理收到的
Socket 请求，提交到线程池 Executor 处理。
Processor
接收 Endpoint 的 socket，读取字节流解析成 tomcat request 和 response，通过
adapter 将其提交到容器处理。Processor 的具体实现类 AjpProcessor、Http11Processor
实现了特定协议的解析方法和请求处理方式。
Endpoint 接收到 socket 连接后，生成一个 socketProcessor 交给线程池处理，run
方法会调用 Processor 解析应用层协议，生成 tomcat request 后，调用 adapter
的 service 方法。
Adapter
ProtocolHandler 接口负责解析请求生成 tomcat requst，CoyoteAdapter
的 service 方法，将 Tomcat Request 对象，转成 ServletRequest，再调用
service 方法。
容器 Container
容器的层次结构
父子关系的 Engine、Host、Context、Wrapper 和 Servlet。Context
表示 web 应用程序、wrapper 表示 servlet、context 有多个 wrapper，host
也有多个 context。
Host 代表的是一个虚拟主机，或者说一个站点，可以给 Tomcat 配置多个虚拟主机地址，而一个虚拟主机下可以部署多个
Web 应用程序；Engine 表示引擎，用来管理多个虚拟站点，一个 Service 最多只能有一个
Engine。
容器通过 Pipeline-Valve 责任链，对请求一次处理，invoke 处理方法，每个容器都有一个
Pipeline，触发第一个 Valve，这个容器的 valve 都会被调到，不同容器之间通过 Pipeline
的 getBasic 方法，负责调用下层容器的第一个 Valve。
整个调用连由连接器中的 adapter 触发，调用 engine 中的第一个 Valve。
// Calling the
container
2connector.getService().getContainer().
getPipeline().getFirst().invoke(request,
response); |
wrapper 容器的最后一个 valve 创建一个 filter 链，并调用 doFilter 方法，最终会调用到
servlet 的 service 方法。
final class StandardWrapperValve
extends ValveBase {
@Override
public final void invoke(Request request, Response
response)
throws IOException, ServletException {
// ...
ApplicationFilterChain filterChain =
ApplicationFilterFactory.createFilterChain(request
, wrapper, servlet);
// Call the filter chain for this request
// NOTE: This also calls the servlet's service
() method
Container container = this.container;
try {
if ((servlet != null) && (filterChain
!= null)) {
// Swallow output if needed
if (context.getSwallowOutput()) {
try {
SystemLogHandler.startCapture();
if (request.isAsyncDispatching()) {
request.getAsyncContextInternal().doInternalDispatch
();
} else {
// dofilter
filterChain.doFilter(request.getRequest(),
response.getResponse());
}
} finally {
String log = SystemLogHandler.stopCapture();
if (log != null && log.length() > 0)
{
context.getLogger().info(log);
}
}
} else {
if (request.isAsyncDispatching()) {
request.getAsyncContextInternal().doInternalDispatch();
} else {
// dofilter
filterChain.doFilter
(request.getRequest(), response.getResponse());
}
}
}
} catch() {
// ...
}
}
} |
ServletContext 是 tomcat 中的一个成员变量，spring 中的 ApplicationContext
是 servlet 规范中的 ServletContext 属性。 | 
