tomcat系统架构及实现

概述

1.Tomcat 要实现 2 个核心功能:

处理 Socket 连接，负责网络字节流与 Request 和 Response 对象的转化。
加载和管理 Servlet，以及具体处理 Request 请求。

因此 Tomcat 设计了两个核心组件连接器(Connector)和容器(Container)来分别做这两件事情。连接器负责对外交流，容器负责内部处理。

2.Tomcat 支持的 I/O 模型有:

NIO:非阻塞 I/O，采用 Java NIO 类库实现。
NIO2:异步 I/O，采用 JDK 7 最新的 NIO2 类库实现。
APR:采用 Apache 可移植运行库实现，是 C/C++ 编写的本地库。

3.Tomcat 支持的应用层协议有:

HTTP/1.1:这是大部分 Web 应用采用的访问协议。
AJP:用于和 Web 服务器集成(如 Apache)。
HTTP/2:HTTP 2.0 大幅度的提升了 Web 性能。

Tomcat 为了实现支持多种 I/O 模型和应用层协议，一个容器可能对接多个连接器，就好比一个房间有多个门。但是单独的连接器或者容器都不能对外提供服务，需要把它们组装起来才能工作，组装后这个整体叫作 Service 组件。
avatar
从图上你可以看到，最顶层是 Server，这里的 Server 指的就是一个 Tomcat 实例。一个 Server 中有一个或者多个 Service，一个 Service 中有多个连接器和一个容器。连接器与容器之间通过标准的 ServletRequest 和 ServletResponse 通信。

连接器

1.主要功能

连接器功能
监听网络端口。
接受网络连接请求。
读取请求网络字节流。
根据具体应用层协议(HTTP/AJP)解析字节流，生成统一的 Tomcat Request 对象。将 Tomcat Request 对象转成标准的 ServletRequest。
调用 Servlet 容器，得到 ServletResponse。
将 ServletResponse 转成 Tomcat Response 对象。
将 Tomcat Response 转成网络字节流。
将响应字节流写回给浏览器。

通过分析连接器的详细功能列表，我们发现连接器需要完成 3 个高内聚的功能:

网络通信。
应用层协议解析。
Tomcat Request/Response 与 ServletRequest/ServletResponse 的转化。

因此 Tomcat 的设计者设计了 3 个组件来实现这 3 个功能，分别是 EndPoint、Processor 和 Adapter。EndPoint 负责提供字节流给 Processor，Processor 负责提供 Tomcat Request 对象给 Adapter，Adapter 负责提供 ServletRequest 对象给容器。其中 Endpoint 和 Processor 放在一起抽象成了 ProtocolHandler 组件，它们的关系如下图所示。
avatar

2.ProtocolHandler 组件
连接器用 ProtocolHandler 来处理网络连接和应用层协议，包含了 2 个重要部件:EndPoint 和 Processor。EndPoint 是通信端点，即通信监听的接口，是具体的 Socket 接收和发送处理器，是对传输层的抽象，因此 EndPoint 是用来实现 TCP/IP 协议的。如果说 EndPoint 是用来实现 TCP/IP 协议的，那么 Processor 用来实现 HTTP 协议， Processor 接收来自 EndPoint 的 Socket，读取字节流解析成 Tomcat Request 和Response对象，并通过 Adapter 将其提交到容器处理，Processor 是对应用层协议的抽象。
EndPoint 是一个接口，对应的抽象实现类是 AbstractEndpoint，而 AbstractEndpoint 的具体子类，比如在 NioEndpoint 和 Nio2Endpoint 中，有两个重要的子组件: Acceptor 和 SocketProcessor。其中 Acceptor 用于监听 Socket 连接请求。SocketProcessor 用于处理接收到的 Socket 请求，它实现 Runnable 接口，在 Run 方法里调用协议处理组件 Processor 进行处理。为了提高处理能力，SocketProcessor 被提交到线程池来执行。而这个线程池叫作执行器 (Executor)。Processor 是一个接口，定义了请求的处理等方法。它的抽象实现类 AbstractProcessor 对一些协议共有的属性进行封装，没有对方法进行实现。具体的实现有 AJPProcessor、 HTTP11Processor 等，这些具体实现类实现了特定协议的解析方法和请求处理方式。
avatar
从图中我们看到，EndPoint 接收到 Socket 连接后，生成一个 SocketProcessor 任务提交到线程池去处理，SocketProcessor 的 Run 方法会调用 Processor 组件去解析应用层协议，Processor 通过解析生成 Request 对象后，会调用 Adapter 的 Service 方法。

3.Adapter 组件
Tomcat 定义了自己的 Request 类来“存放”这些请求信息。ProtocolHandler 接口负责解析请求并生成 Tomcat Request 类。但是这个 Request 对象不是标准的 ServletRequest，也就意味着，不能用 Tomcat Request 作为参数来调用容器。Tomcat 设计者的解决方案是引入 CoyoteAdapter，这是适配器模式的经典运用，连接器调用 CoyoteAdapter 的 Sevice 方法，传入的是 Tomcat Request 对象，CoyoteAdapter 负责将 Tomcat Request 转成 ServletRequest，再调用容器的 Service 方法。

多层容器

1.容器的层次结构
avatar
Context 表示一个 Web 应用程序;Wrapper 表示一个 Servlet，一个 Web 应用程序中可能会有多个 Servlet;Host 代表的是一个虚拟主机，或者说一个站点，可以给 Tomcat 配置多个虚拟主机地址，而一个虚拟主机下可以部署多个 Web 应用程序;Engine 表示引擎，用来管理多个虚拟站点，一个 Service 最多只能有一个 Engine。
Tomcat 就是用组合模式来管理这些容器的。具体实现方法是，所有容器组件都实现了 Container 接口，因此组合模式可以使得用户对单容器对象和组合容器对象的使用具有一致性。这里单容器对象指的是最底层的 Wrapper，组合容器对象指的是上面的 Context、Host 或者 Engine。Container 接口定义如下:

public interface Container extends Lifecycle {
    public void setName(String name);
    public Container getParent();
    public void setParent(Container container);
    public void addChild(Container child);
    public void removeChild(Container child);
 	public Container findChild(String name);
}

2.请求定位 Servlet 的过程

Tomcat 是用Mapper组件来完成这个任务的。Mapper组件的功能就是将用户请求的URL定位到一个Servlet，它的工作原理是:Mapper 件里保存了Web 应用的配置信息，其实就是容器组件与访问路径的映射关系，比如Host容器里配置的域名、Context容器里的Web应用路径，以及Wrapper容器里Servlet 映射的路径，你可以想象这些配置信息就是一个多层次的Map。
首先，根据协议和端口号选定Service和Engine。Tomcat的每个连接器都监听不同的端口，比如Tomcat默认的HTTP连接器监听8080端口、默认的AJP连接器监听8009 端口。上面例子中的 URL 访问的是 8080 端口，因此这个请求会被 HTTP 连接器接收，而一个连接器是属于一个 Service 组件的，这样 Service组件就确定了。我们还知道一个Service组件里除了有多个连接器，还有一个容器组件，具体来说就是一个Engine容器，因此Service确定了也就意味着 Engine也确定了。然后根据域名选定Host。之后根据URL路径找到Context组件。最后根据URL路径找到Wrapper(Servlet)。Context确定后，Mapper再根据 web.xml中配置的Servlet映射路径来找到具体的Wrapper和Servlet。
需要注意的是，并不是说只有Servlet才会去处理请求，实际上这个查找路径上的父子容器都会对请求做一些处理。连接器中的Adapter会调用容器的Service 方法来执行 Servlet，最先拿到请求的是Engine容器，Engine 容器对请求做一些处理后，会把请求传给自己子容器 Host继续处理，依次类推，最后这个请求会传给 Wrapper容器，Wrapper会调用最终的Servlet 来处理。
那么这个调用过程具体是怎么实现的呢?答案是使用Pipeline-Valve管道。Pipeline-Valve是责任链模式，责任链模式是指在一个请求处理的过程中有很多处理者依次对请求进行处理，每个处理者负责做自己相应的处理，处理完之后将再调用下一个处理者继续处理。Valve表示一个处理点，比如权限认证和记录日志。如果你还不太理解的话，可以来看看Valve和Pipeline接口中的关键方法。

public interface Valve {
 public Valve getNext();
 public void setNext(Valve valve);
 public void invoke(Request request, Response response)
}

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

public interface Pipeline extends Contained {
	public void addValve(Valve valve);
	public Valve getBasic();
	public void setBasic(Valve valve);
	public Valve getFirst();
}

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

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

avatar

Valve是Tomcat的私有机制，与Tomcat的基础架构/API是紧耦合的。Servlet API是公有的标准，所有的Web容器包括Jetty都支持Filter机制。另一个重要的区别是 Valve 工作在 Web 容器级别，拦截所有应用的请求;而Servlet Filter工作在应用级别，只能拦截某个Web应用的所有请求。如果想做整个Web容器的拦截器，必须通过 Valve 来实现。