tomcat解析

1、整体架构

image.png

2、主要组件

• 连接器（Connector）：处理 Socket 连接，负责网络字节流与 Request 和 Response 对象的转化。

• Servlet容器（Container）：加载和管理 Servlet，以及具体处理 Request 请求。

3、支持的 I/O 模型

• NIO：非阻塞 I/O，采用 Java NIO 类库实现。

• NIO2：异步 I/O，采用 JDK 7 最新的 NIO2 类库实现。

• APR：采用 Apache 可移植运行库实现，是 C/C++ 编写的本地库。

• BIO：阻塞I/O

4、支持的应用层协议

• HTTP/1.1：这是大部分 Web 应用采用的访问协议。

• AJP：用于和 Web 服务器集成（如 Apache）。

• HTTP/2：HTTP 2.0 大幅度的提升了 Web 性能。

5、连接器解析

连接器需要完成的功能：

• 网络通信。

• 应用层协议解析。

• Tomcat Request/Response 与 ServletRequest/ServletResponse 的转化。

tomcat对应的设计：分别是 EndPoint、Processor 和 Adapter。

整体的处理逻辑为：EndPoint 负责提供字节流给 Processor，Processor 负责提供 Tomcat Request 对象给 Adapter，Adapter 负责提供 ServletRequest 对象给容器。如果要支持新的 I/O 方案、新的应用层协议，只需要实现相关的具体子类，上层通用的处理逻辑是不变的。

由于 I/O 模型和应用层协议可以自由组合，比如 NIO + HTTP 或者 NIO2 + AJP。Tomcat 的设计者将网络通信和应用层协议解析放在一起考虑，设计了一个叫 ProtocolHandler 的接口来封装这两种变化点。

小结一下，连接器模块用三个核心组件：Endpoint、Processor 和 Adapter 来分别做三件事情，其中 Endpoint 和 Processor 放在一起抽象成了 ProtocolHandler 组件，它们的关系如下图所示。

image.png

image.png

ProtocolHandler 组件

• EndPoint

EndPoint 是通信端点，即通信监听的接口，是具体的 Socket 接收和发送处理器，是对传输层的抽象，因此 EndPoint 是用来实现 TCP/IP 协议的。

EndPoint 是一个接口，对应的抽象实现类是 AbstractEndpoint，而 AbstractEndpoint 的具体子类，比如在 NioEndpoint 和 Nio2Endpoint 中，有两个重要的子组件：Acceptor 和 SocketProcessor。

其中 Acceptor 用于监听 Socket 连接请求。SocketProcessor 用于处理接收到的 Socket 请求，它实现 Runnable 接口，在 Run 方法里调用协议处理组件 Processor 进行处理。为了提高处理能力，SocketProcessor 被提交到线程池来执行。而这个线程池叫作执行器（Executor)，我在后面的专栏会详细介绍 Tomcat 如何扩展原生的 Java 线程池。

• Processor

如果说 EndPoint 是用来实现 TCP/IP 协议的，那么 Processor 用来实现 HTTP 协议，Processor 接收来自 EndPoint 的 Socket，读取字节流解析成 Tomcat Request 和 Response 对象，并通过 Adapter 将其提交到容器处理，Processor 是对应用层协议的抽象。

Processor 是一个接口，定义了请求的处理等方法。它的抽象实现类 AbstractProcessor 对一些协议共有的属性进行封装，没有对方法进行实现。具体的实现有 AJPProcessor、HTTP11Processor 等，这些具体实现类实现了特定协议的解析方法和请求处理方式。

image.png

从图中我们看到，EndPoint 接收到 Socket 连接后，生成一个 SocketProcessor 任务提交到线程池去处理，SocketProcessor 的 Run 方法会调用 Processor 组件去解析应用层协议，Processor 通过解析生成 Request 对象后，会调用 Adapter 的 Service 方法。

Adapter 组件

我在前面说过，由于协议不同，客户端发过来的请求信息也不尽相同，Tomcat 定义了自己的 Request 类来“存放”这些请求信息。ProtocolHandler 接口负责解析请求并生成 Tomcat Request 类。但是这个 Request 对象不是标准的 ServletRequest，也就意味着，不能用 Tomcat Request 作为参数来调用容器。Tomcat 设计者的解决方案是引入 CoyoteAdapter，这是适配器模式的经典运用，连接器调用 CoyoteAdapter 的 Sevice 方法，传入的是 Tomcat Request 对象，CoyoteAdapter 负责将 Tomcat Request 转成 ServletRequest，再调用容器的 Service 方法。

6、容器解析

image.png

Tomcat 设计了 4 种容器，分别是 Engine、Host、Context 和 Wrapper。这 4 种容器不是平行关系，而是父子关系。下面我画了一张图帮你理解它们的关系。

image.png

Context 表示一个 Web 应用程序；Wrapper 表示一个 Servlet，一个 Web 应用程序中可能会有多个 Servlet；Host 代表的是一个虚拟主机，或者说一个站点，可以给 Tomcat 配置多个虚拟主机地址，而一个虚拟主机下可以部署多个 Web 应用程序；Engine 表示引擎，用来管理多个虚拟站点，一个 Service 最多只能有一个 Engine。

请求最先会到Engine 容器然后一层一层的向下传递，并且在每一层都做相应的处理，那这个处理是怎么做的呢？答案是使用 Pipeline-Valve 管道。

Pipeline-Valve 是责任链模式，责任链模式是指在一个请求处理的过程中有很多处理者依次对请求进行处理，每个处理者负责做自己相应的处理，处理完之后将再调用下一个处理者继续处理。

这里贴出来两个接口的代码：

public interface Valve {  
 public Valve getNext();
 public void setNext(Valve valve);
 public void backgroundProcess(); 
 public void invoke(Request request, Response response) throws                                     IOException, ServletException; 
 public boolean isAsyncSupported();
}

由于 Valve 是一个处理点，因此 invoke 方法就是来处理请求的。注意到 Valve 中有 getNext 和 setNext 方法，因此我们大概可以猜到有一个链表将 Valve 链起来了。请你继续看 Pipeline 接口：

public interface Pipeline {
 public Valve getBasic();
 public void setBasic(Valve valve);
 public void addValve(Valve valve);
 public Valve[] getValves();
 public void removeValve(Valve valve);
 public Valve getFirst();
 public boolean isAsyncSupported();
 public Container getContainer();
 public void setContainer(Container container);
 public void findNonAsyncValves(Set<String> result);
}

没错，Pipeline 中有 addValve 方法。Pipeline 中维护了 Valve 链表，Valve 可以插入到 Pipeline 中，对请求做某些处理。我们还发现 Pipeline 中没有 invoke 方法，因为整个调用链的触发是 Valve 来完成的，Valve 完成自己的处理后，调用 getNext.invoke() 来触发下一个 Valve 调用。

每一个容器都有一个 Pipeline 对象，只要触发这个 Pipeline 的第一个 Valve，这个容器里 Pipeline 中的 Valve 就都会被调用到。但是，不同容器的 Pipeline 是怎么链式触发的呢，比如 Engine 中 Pipeline 需要调用下层容器 Host 中的 Pipeline。

这是因为 Pipeline 中还有个 getBasic 方法。这个 BasicValve 处于 Valve 链表的末端，它是 Pipeline 中必不可少的一个 Valve，负责调用下层容器的 Pipeline 里的第一个 Valve。我还是通过一张图来解释

image.png

整个调用过程由连接器中的 Adapter 触发的，它会调用 Engine 的第一个 Valve：

connector.getService().getContainer().getPipeline().getFirst().invoke(        request, response);

Wrapper 容器的最后一个 Valve 会创建一个 Filter 链，并调用 doFilter() 方法，最终会调到 Servlet 的 service 方法。

你可能会问，前面我们不是讲到了 Filter，似乎也有相似的功能，那 Valve 和 Filter 有什么区别吗？它们的区别是：

• Valve 是 Tomcat 的私有机制，与 Tomcat 的基础架构 /API 是紧耦合的。Servlet API 是公有的标准，所有的 Web 容器包括 Jetty 都支持 Filter 机制。

• 另一个重要的区别是 Valve 工作在 Web 容器级别，拦截所有应用的请求；而 Servlet Filter 工作在应用级别，只能拦截某个 Web 应用的所有请求。如果想做整个 Web 容器的拦截器，必须通过 Valve 来实现。

7、容器的生命周期

在我们实际的工作中，如果你需要设计一个比较大的系统或者框架时，你同样也需要考虑这几个问题：如何统一管理组件的创建、初始化、启动、停止和销毁？如何做到代码逻辑清晰？如何方便地添加或者删除组件？如何做到组件启动和停止不遗漏、不重复？

今天我们就来解决上面的问题，在这之前，先来看看组件之间的关系。如果你仔细分析过这些组件，可以发现它们具有两层关系。

• 第一层关系是组件有大有小，大组件管理小组件，比如 Server 管理 Service，Service 又管理连接器和容器。

• 第二层关系是组件有外有内，外层组件控制内层组件，比如连接器是外层组件，负责对外交流，外层组件调用内层组件完成业务功能。也就是说，请求的处理过程是由外层组件来驱动的。

这两层关系决定了系统在创建组件时应该遵循一定的顺序。

• 第一个原则是先创建子组件，再创建父组件，子组件需要被“注入”到父组件中。

• 第二个原则是先创建内层组件，再创建外层组件，内层组建需要被“注入”到外层组件。

一键式启停：LifeCycle 接口

public interface Lifecycle {
 public static final String BEFORE_INIT_EVENT = "before_init";
 public static final String AFTER_INIT_EVENT = "after_init";
 public static final String START_EVENT = "start";
 public static final String BEFORE_START_EVENT = "before_start";
 public static final String AFTER_START_EVENT = "after_start";
 public static final String STOP_EVENT = "stop";
 public static final String BEFORE_STOP_EVENT = "before_stop";
 public static final String AFTER_STOP_EVENT = "after_stop";
 public static final String AFTER_DESTROY_EVENT = "after_destroy";
 public static final String BEFORE_DESTROY_EVENT = "before_destroy";
 public static final String PERIODIC_EVENT = "periodic";
 public static final String CONFIGURE_START_EVENT = "configure_start";
 public static final String CONFIGURE_STOP_EVENT = "configure_stop";
 public void addLifecycleListener(LifecycleListener listener);
 public LifecycleListener[] findLifecycleListeners();
 public void removeLifecycleListener(LifecycleListener listener);
 public void init() throws LifecycleException;
 public void start() throws LifecycleException;
 public void stop() throws LifecycleException;
 public void destroy() throws LifecycleException;
 public LifecycleState getState();
 public String getStateName();

}  

理所当然，在父组件的 init() 方法里需要创建子组件并调用子组件的 init() 方法。同样，在父组件的 start() 方法里也需要调用子组件的 start() 方法，因此调用者可以无差别的调用各组件的 init() 方法和 start() 方法，这就是组合模式的使用，并且只要调用最顶层组件，也就是 Server 组件的 init() 和 start() 方法，整个 Tomcat 就被启动起来了。