Tomcat服务器Day02-Tomcat架构

桃扇骨 2022-12-04 10:59 191阅读 0赞

qq@toc

# HTTP工作原理 #

*  **HTTP**协议是浏览器与服务器之间的数据传输协议
 *  **HTTP**协议作为应用层协议,是基于底层**TCP/IP**协议来进行数据传输的. 传输的数据包括**HTML**文件,图片,查询结果等
 *  **HTTP**协议不涉及数据包**Packet**的传输,主要规定了浏览器与服务器之间的通信格式

<table> 
 <thead> 
  <tr> 
   <th>步骤</th> 
   <th>用户</th> 
   <th>浏览器</th> 
   <th>服务器</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>用户发起用户请求</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td></td> 
   <td>浏览器发起TCP连接请求</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td></td> 
   <td></td> 
   <td>服务器接受请求并建立连接</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td></td> 
   <td>浏览器生成HTTP格式的请求数据包</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td></td> 
   <td>浏览器发送请求数据包</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td></td> 
   <td></td> 
   <td>服务器解析HTTP格式的请求数据包</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td></td> 
   <td></td> 
   <td>服务器执行请求</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td></td> 
   <td></td> 
   <td>服务器生成HTTP格式的响应数据包</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td></td> 
   <td></td> 
   <td>服务器发送响应数据包</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td></td> 
   <td>浏览器解析HTTP格式的响应数据包</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td></td> 
   <td>浏览器呈现HTML响应给用户</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

*  用户通过浏览器进行操,比如输入网站并回车或者点击链接,浏览器获取到这个事件
 *  浏览器向服务端发出**TCP**连接请求
 *  服务器接受浏览器的连接请求,并经过**TCP**三次握手建立连接
 *  浏览器将请求数据打包成一个**HTTP**格式的数据包
 *  浏览器将请求数据包推入网络,数据包经过网络传输,最终到达服务器
 *  服务器获取到请求数据包后,以**HTTP**格式解析请求数据包,获取到浏览器的请求
 *  服务器执行浏览器的请求处理,比如提供静态文件或者调用服务器相关程序获取动态结果
 *  服务器将响应的结果,包括**HTML**和图片,按照**HTTP**格式进行打包
 *  服务器将响应数据包推入网络,数据包经过网络传输,最终到达浏览器
 *  浏览器获取到响应数据包后,以**HTTP**格式解析响应数据包,获取响应到的数据
 *  浏览器将响应数据展示在页面上呈现给用户
 *  **HTTP服务器Tomcat和Jetty的主要作用:**
    
     *  **接受连接**
     *  **解析请求数据**
     *  **处理请求**
     *  **发送响应**

# Tomcat架构 #

## HTTP服务器请求处理 ##

*  **HTTP**服务器不是直接调用业务类,而是将请求交给容器来处理,容器通过**Servlet**接口调用业务类
 *  **Servlet**接口和**Servlet**容器的出现,达到了**HTTP**服务器与业务类解耦的目的
 *  **Servlet**接口和**Servlet**容器的规范叫作**Servlet**规范
 *  **Tomcat**按照**Servlet**规范实现了**Servlet**容器,同时具有**HTTP**服务器的功能
 *  如果要实现新业务,只需要实现一个**Servlet**接口,并注册到**Tomcat**服务器即**Servlet**容器中,由**Tomcat**完成其余的服务器操作

## Servlet容器工作流程 ##

*  当用户请求某个资源时 **,HTTP**会使用一个**ServletRequest**对象将用户的请求信息封装起来
 *  然后**Servlet**容器获取到请求,会根据**URL**和**Servlet**的映射关系,找到相应的**Servlet**
 *  如果**Servlet**还没有被加载,就使用反射机制创建这个**Servlet,** 并且调用**Servlet**的**init()** 方法来完成初始化
 *  接着调用**Servlet**的**service**方法来处理请求
 *  最后使用**ServletResponse**对象将请求响应信息封装起来 **,HTTP**服务器会将响应封装信息发送给浏览器

## Tomcat整体架构 ##

*  **Tomcat**服务器需要实现两个核心功能:
    
     *  处理**Socket**连接,负责网络字节流与**Request**和**Response**对象的转化
     *  加载和管理**servlet,** 以及处理**Request**请求
 *  **Tomcat**设计两个核心组件连接器**Connector**和容器**Container**来分别完成这两件事:
    
     *  连接器**Connector**负责对外交流
     *  容器**Container**负责内部处理

# 连接器Coyote #

*  **Coyote**是**Tomcat**的连接器框架,是**Tomcat**提供的供客户端访问的外部接口:
    
     *  客户端通过**Coyote**与服务器建立连接,发送请求并接受响应
 *  **Coyote**封装了网络底层通信,包括**Socket**请求和响应处理.为**Catalina**容器提供了统一的接口,使**Catalina**容器与具体的请求协议以及**IO**操作方式完全解耦:
    
     *  **Coyote**将**Socket**输入转换封装为**Request**对象,交由**Catalina**容器进行处理
     *  处理完成后 **,Catalina**通过**Coyote**提供的**Response**对象将结果写入输出流
 *  **Coyote**作为独立的模块,只负责具体协议和**IO**相关操作,与**Servlet**的规范实现没有直接关系:
    
     *  **Request**对象和**Response**对象并没有实现**Servlet**规范对应的接口
     *  而是在**Catalina**中将**Request**和**Response**对象进一步封装为**ServletRequest**和**ServletResponse**  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center]

## IO模型与网络协议 ##

*  在**Coyote**中 **,Tomcat**支持多种**I/O**模型和应用层协议:
    
     *  **Tomcat**支持的**IO**模型: 默认是**NIO**
        
         *  **NIO:** 非阻塞**I/O,** 采用**Java**的**NIO**类库实现
         *  **NIO2:** 异步**I/O,** 采用**JDK 7**的**NIO2**类库实现
         *  **APR:** 采用**Apache**可移植运行库实现,是**C/C++** 编写的本地库. 如果使用**APR**作为**I/O**模型,需要单独安装**APR**库
     *  **Tomcat**支持的应用层协议:
        
         *  **HTTP1.1:** 大部分**Web**应用采用的访问协议
         *  **AJP:** 用于和**Apache**等**Web**服务器集成,以实现对静态资源的优化及集群部署,目前支持**AJP1.3**
         *  **HTTP2:** **HTTP2**大幅度提升了**Web**性能
 *  **Tomcat**为了实现支持多种**I/O**模型和应用层协议,一个容器可能对接多个连接器:
    
     *  单独的连接器或者容器都是无法对外提供服务的,需要组装起来才能工作,组装后的这个整体叫做**Service**组件
     *  **Service**只是将连接器和容器组装在一起
     *  出于灵活性考虑,通常在**Tomcat**中配置多个**Service,** 可以实现通过不同的端口号访问同一台机器上部署的不同应用

## 连接器组件 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 1]

*  **Endpoint:**
    
     *  **Coyote**通信端点,即通信监听接口
     *  是具体的**Socket**请求的接收和发送处理器,是对传输层抽象,用来实现**TCP/IP**协议
     *  **Tomcat**中并没有**Endpoint**接口,而是定义了一个抽象类**AbstractEndpoint,** 该抽象类定义了两个内部类:
        
         *  **Acceptor**
            
             *  用于监听**Socket**连接请求
         *  **SocketProcessor**
            
             *  用于处理接收到的**Socket**请求
             *  实现**Runnable**接口,在**Run**方法中调用了协议处理组件**Processor**进行处理
             *  为了提高处理能力 **,socketProcessor**会被提交到线程池来执行,该线程池是**Tomcat**扩展原生的 **Java**线程池,被称作执行器**Executor**
 *  **Processor:**
    
     *  **Coyote**协议处理接口,是对应用层协议的抽象
     *  **Processor**用来实现**HTTP**协议
     *  **Processor**接收来自**Endpoint**的**Socket**数据,读取字节流解析成**HttpRequest**对象
     *  然后将**HttpRequest**通过**Adapter**转化成**ServletRequest**提交给容器处理
 *  **ProtocolHandler:**
    
     *  **Coyote**协议接口,通过**Endpoint**和**Processor**实现针对具体协议的处理能力
     *  **Tomcat**中提供了**6**个实现类:
        
         *  **AjpAprProtocol**
         *  **AjpNioProtocol**
         *  **AjpNio2Protocol**
         *  **Http11AprProtocol**
         *  **Http11NioProtocol**
         *  **Http11Nio2Protocol**
     *  在配置**tomcat/conf/server.xml**时,要指定具体的**ProtocolHandler,** 也可以指定协议名称.比如**Http1.1,** 如果安装了**APR,** 将会使用**Http11AprProtocol,** 否则使用**Http11NioProtocol**
 *  **Adapter:**
    
     *  由于协议的不同,客户端传输的请求信息也会不同 **,Tomcat**自定义一个**Request**类来存放这些请求信息
     *  **ProcotolHandler**接口负责解析请求并生成**Request**类,但是这个**Request**不是标准的**ServletRequest,** 所有不能使用**Tomcat**中自定义的**Request**作为参数来调用容器进行数据处理
     *  通过运用适配器模式,引入**CoyoteAdapter**来解决这样的问题:连接器调用**CoyoteAdapter**的**Service**方法,传入**Tomcat Request**对象,然后**CoyoteAdapter**负责将**Tomcat Request**转化成**ServletRequest,** 最后再调用容器的**Service**方法

# 容器Catalina #

*  **Tomcat**就是一个由一系列可配置的组件组成的**web**容器
 *  **Catalina**是**Tomcat**的**servlet**容器
 *  **Catalina**是**Servlet**容器实现,通过松耦合的方式集成**Coyote,** 以完成按照请求协议进行数据读取
 *  **Tomcat模块分层示意图:**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 2]
 *  **Tomcat**本质上是一个**Servlet**容器,所以**Catalina**是**Tomcat**的核心,其余模块都是为**Catalina**提供服务支撑的:
    
     *  连接器**Coyote**提供连接通信
     *  **JSP**引擎**Jasper**提供**JSP**引擎
     *  表达式语言**JavaEL**提供**EL**表达式支持
     *  命名服务**Naming**提供**JNDI**服务
     *  服务器日志**Juli**提供日志服务

## Catalina结构 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 3]

*  **Catalina**负责管理**Server,Server**表示整个服务器
 *  **Server**中有多个服务**Service**
 *  每个服务**Service**包含着多个**Coyote**实现的连接器组件**Connector**和一个容器组件**Container**
 *  在**Tomcat**启动时,会初始化一个**Catalina**实例

<table> 
 <thead> 
  <tr> 
   <th>组件</th> 
   <th align="left">作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Catalina</td> 
   <td align="left">解析Tomcat配置文件<br>根据配置文件创建服务器Server,并根据命令对服器Server进行管理</td> 
  </tr> 
  <tr> 
   <td>Server</td> 
   <td align="left">服务器Server表示整个Catalina Servlet容器及其余相关组件<br>服务器Server负责组装并启动Servlet引擎和Tomcat连接器<br>服务器Server通过实现Lifecycle接口,提供了一种优雅的启动和关闭整个系统的方式</td> 
  </tr> 
  <tr> 
   <td>Service</td> 
   <td align="left">服务Service是服务器Server的内部组件,一个服务器Server可以包含多个服务Service<br>服务Service将多个连接器Connector绑定到一个容器Container上</td> 
  </tr> 
  <tr> 
   <td>Connector</td> 
   <td align="left">连接器<br>用于处理与客户端通信<br>接收客户端请求,然后转发给相应的容器处理,最后向客户端返回响应结果</td> 
  </tr> 
  <tr> 
   <td>Container</td> 
   <td align="left">容器<br>处理用户的Servlet请求,并返回对象给web用户模块</td> 
  </tr> 
 </tbody> 
</table>

## Container结构 ##

*  **Tomcat**中的容器**Container**包含**4**种组件:
    
     *  **Engine**
     *  **Host**
     *  **Context**
     *  **Wrapper**
 *  这**4**种组件是有层级的父子关系
 *  **Tomcat**通过一种分层架构,使得**Servlet**容器有更好的灵活性  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 4]

<table> 
 <thead> 
  <tr> 
   <th>容器组件</th> 
   <th align="left">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Engine</td> 
   <td align="left">表示整个Catalina的Servlet引擎<br>用来管理多个虚拟站点,一个Service最多只能有一个Engine,但是一个Engine可以包含多个Host</td> 
  </tr> 
  <tr> 
   <td>Host</td> 
   <td align="left">表示一个主机或者是一个虚拟站点<br>可以给Tomcat配置多个虚拟主机地址,一个虚拟主机地址下可以包含多个Context</td> 
  </tr> 
  <tr> 
   <td>Context</td> 
   <td align="left">表示一个web应用程序<br>一个尾部应用程序可以包含多个Wrapper</td> 
  </tr> 
  <tr> 
   <td>Wrapper</td> 
   <td align="left">表示一个Servlet容器<br>Wrapper作为容器中的最底层,不可以包含子容器</td> 
  </tr> 
 </tbody> 
</table>

*  **Tomcat**采用组件化的设计,构成组件都是可配置的 **,Tomcat**中对使用**server.xml**来对容器**Container**进行配置
 *  **Tomcat**使用组合模式来管理这些容器**Container,** 这些容器具有父子关系,形成一个树形结构,具体实现方法:
    
     *  所有容器组件都实现了**Container**接口
     *  组合模式可以使得用户对单容器对象和组合容器对象的使用具有一致性
        
         *  **单容器对象:** 最底层的**Wrapper**
         *  **组合容器对象:** 指父容器**Context,Host**和**Engine**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 5]

*  容器**Container**接口继承了**LifeCycle**接口,用来统一管理各个组件的生命周期

# Tomcat启动流程 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 6][]

*  启动**Tomcat,** 需要启动**bin**目录下的**startup**脚本,在**startup**脚本中,调用了**catalina**脚本
 *  在**catalina**脚本中,调用了**Bootstrap**中的**main()** 方法
 *  在**Bootstrap**的**main()** 方法中调用了**init()** 方法,来创建**Catalina**并初始化类加载器
 *  在**Bootstrap**的**main()** 方法中调用了**load()** 方法,又调用了**Catalina**的**load()** 方法
 *  在**Catalina**的**load()** 方法中,需要进行初始化工作,并且需要构造**Digister**对象,用于解析**XML**
 *  在**Catalina**中创建**Server,** 并依次调用后续组件**Server, Service, Engine, Host, Context**的初始化**init()** 方法
 *  然后在**Service**中调用初始化**init()** 方法初始化**Executor**组件,接着在**Service**中调用**Connector**的**init()** 方法初始化**Connector,** 最后调用**ProtocolHandler**组件的初始化**init()** 方法
 *  初始化完成后,在**Bootstrap**的**main()** 方法中调用**start()** 方法,依次启动后续组件
 *  依次调用后续组件**Catalina, Server, Service, Engine, Host, Context**的启动**start()** 方法
 *  然后在**Service**中调用启动**start()** 方法启动**Executor**组件,接着在**Service**中调用**Connector**的**init()** 方法初始化**Connector,** 最后调用**ProcotolHandler**组件的启动**start()** 方法
 *  **Tomcat流程启动完成后,就完成加载Tomcat配置文件,初始化容器,监听对应的端口号,准备接受客户端请求**

## Lifecycle ##

*  由于**Tomcat**中所有组件均存在初始化,启动,停止等生命周期方法,所以在设计**Tomcat**时,基于生命周期管理抽象出一个生命周期管理接口**Lifecycle**
 *  **Server**组件 **,Service**组件 **,Container**组件 **,Executor**组件以及**Connctor**组件都实现了生命周期**Lifecycle**接口,从而具有生命周期中的核心方法:
    
     *  **init() :** 初始化组件
     *  **start() :** 启动组件
     *  **stop() :** 停止组件
     *  **destory() :** 销毁组件  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 7]

## Tomcat组件接口的默认实现 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 8]

*  **Tomcat**中提供了对**Server, Service, Engine, Host, Context**这些接口的默认实现
 *  对于**Endpoint**组件而言 **,Tomcat**中没有对应的**Endpoint**接口,但是有一个抽象类**AbstractEndpoint,** 包括三个实现类:
    
     *  **NioEndpoint - NIO**
     *  **Nio2Endpoint - NIO2**
     *  **AprEndpoint - APR**
 *  在**Tomcat 8.5**中,采用**NioEndpoint**默认实现  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 9]
 *  **ProtocolHandler:**
    
     *  **Coyote**协议接口
     *  通过封装**Endpoint**和**Processor,** 实现针对具体协议的处理功能
     *  **Tomcat**中按照协议和**IO**提供了**6**中**ProtocolHandler**实现. 默认使用的协议是**Http11NioProtocol :**
        
         *  **HTTP**协议:
            
             *  **Http11NioProtocol - NIO.** Tomcat默认使用的协议
             *  **Http11Nio2Procotol - NIO2**
             *  **Http11AprProcotol - APR.** 需要依赖于APR库
         *  **AJP**协议:
            
             *  **AjpNioProcotol - NIO**
             *  **AjpNio2Procotol - NIO2**
             *  **AjpAprProcotol - APR.** 需要依赖于APR库

## 总结 ##

*  **Tomcat**启动流程是一个标准化的启动流程:
    
     *  统一按照生命周期管理接口**Lifecycle**的定义进行启动
     *  首先调用**init()** 方法进行组件的逐级初始化操作
     *  然后调用**start()** 方法启动
 *  **Tomcat**中每一级组件除了完成自身的处理流程之外,还要负责调用子组件以响应生命周期管理方法
 *  组件与组件之间是松耦合的,这样可以很容易通过配置文件对**Tomcat**的组件进行配置修改和替换

# Tomcat请求处理流程 #

## Tomcat请求流程 ##

*  **Tomcat**中是通过**Mapper**组件类来完成请求处理流程的
 *  **Mapper**组件的功能就是将用户请求的**URL**定位到一个**Servlet,Mapper**组件的工作原理:
    
     *  **Mapper**组件中保存了**Web**应用的配置信息,即容器组件与访问路径的映射关系. 这些配置信息可以看作是一个多层次的**Map,** 包括:
        
         *  **Host**容器中配置的域名
         *  **Context**容器里的**Web**应用路径
         *  **Wrapper**容器里**Servlet**映射的路径
     *  当有一个请求时 **,Mapper**组件通过解析**URL**中的域名和路径,再到对应的**Web**的配置信息中查找对应的路径,就能定位到一个**Servlet,** 然后请求**Servlet**中的执行方法. 一个请求**URL**只能定位到一个**Wrapper,** 即一个**Servlet**  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 10]
 *  **Connector**组件**Endpoint**中的**Acceptor**监听客户端套接字连接并接收**Socket.** 然后将连接传递给**Executor**处理,开始执行请求响应任务
 *  **Processor**组件读取消息报文,解析请求行,请求体,请求头.封装成**Request**对象
 *  **Mapper**组件根据请求行的**URL**值和请求头的**Host**值匹配**Host**容器 **,Context**容器 **,Wrapper**容器处理请求
 *  **CoyoteAdapter**组件负责将**Connector**组件和**Engine**容器关联起来,将生成的**Reuqest**对象和响应对象**Response**传递到**Engine**容器中,调用**Pipeline**
 *  **Engine**容器的管道开始处理流程,管道中包含若干个**Valve,** 每个**Valve**负责部分处理逻辑,执行完**Valve**后,会执行基础的**StandardEngineValve,** 负责调用**Host**容器的**Pipeline**
 *  **Host**容器的管道开始处理流程,管道中包含若干个**Valve,** 每个**Valve**负责部分处理逻辑,执行完**Valve**后,会执行基础的**StandardHostValve,** 负责调用**Context**容器的**Pipeline**
 *  **Context**容器的管道开始处理流程,管道中包含若干个**Valve,** 每个**Valve**负责部分处理逻辑,执行完**Valve**后,会执行基础的**StandardContextValve,** 负责调用**Wrapper**容器的**Pipeline**
 *  **Wrapper**容器的管道开始处理流程,管道中包含若干个**Valve,** 每个**Valve**负责部分处理逻辑,执行完**Valve**后,会执行基础的**StandardWrapperValve,** 执行**Wrapper**容器对象的**Servlet**对象的处理方法  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 11]
 *  在**Tomcat**的整体架构中,各个组件之间是松耦合的,确保了整体架构的伸缩性和扩展性
 *  在**Tomcat**内部的每个容器**Container**采用责任链模式完成具体的请求处理,来保证灵活性和扩展性
 *  在**Tomcat**中定义了**Pipeline**和**Vavle**两个接口:
    
     *  **Pipeline:** 构建责任链
     *  **Valve:** 代表责任链上的每一个处理器
     *  **Pipeline**中维护了一个基础的**Valve,** 即**StandardXxxValve.** 始终位于**Pipeline**的末端,在最后执行,封装了具体的请求处理和输出响应过程
     *  可以调用**addVavle()方法为Pipeline**添加自定义的**Valve,** 自定义添加的**Valve**位于末尾的基础**Valve**之前,并且按照添加顺序执行
     *  **Pipeline**通过获取首个**Valve**来启动整个责任链的执行

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/114ce74fe38c448e9fadb60e7cf82abe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/692848ad3fb1442ead63ae8501fcc104.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/1e523c07859f4770b10b5e053e465573.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/a0eada5aaa8240e9b94d228eacaef913.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/9c48834c54c64e89ae86bf141fd08066.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/b6958d50ce4846cdbc26e75a39d7832b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/4be26b767f5b4e46a26a4c0a198cbf33.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/416e0308669f487b8f29815e5477310d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/7d4f19d787fb49588c4df7afa0d5d615.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221123/5cefa7eaf45f4e419aec0cd003b2ac34.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221123/c59af0b7ec544fa793ca1fb131c866c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221123/e76c7599a7224ad58068f8efc9a0f964.png