1. Tomcat 基础

1.1 下载安装

官方地址 https://tomcat.apache.org/download-80.cgi

1.2 目录结构

bin ：存放 Tomcat 的启动、停止等批处理脚本文件

• startup.bat, startup.sh : 启动脚本
• shutdown.bat, shutdown.sh ：停止脚本

conf ：用于存放 Tomcat 的相关配置文件

• context.xml ：用于定义所有 web 应用均需加载的 Context 配置，如果 web 应用指定了自己的 context.xml ，该文件将被覆盖
• catalina.properties ：Tomcat 的环境变量配置
• catalina.policy ：Tomcat 运行的安全策略配置
• logging.properties ：Tomcat 的日志配置文件， 可以通过该文件修改 Tomcat 的日志级别及日志路径等
• server.xml ：Tomcat 服务器的核心配置文件
• tomcat-users.xml ：定义 Tomcat 默认的用户及角色映射信息配置 web.xml
• web.xml ：Tomcat 中所有应用默认的部署描述文件， 主要定义了基础 Servlet 和 MIME 映射

lib ：Tomcat 服务器的依赖包
logs ：Tomcat 默认的日志存放目录
webapps ：Tomcat 默认的 web 应用部署目录
work ：web 应用 JSP 代码生成和编译的临时目录

1.3 源码编译

官方地址 https://github.com/apache/tomcat 也可以使用我编译后带解析的地址 https://github.com/masteryourself-opensource/tomcat（已改造成 maven 工程）

直接运行 org.apache.catalina.startup.Bootstrap#main 方法

2. Tomcat 架构

2.1 整体架构

Tomcat 要实现的两个核心功能是：

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

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

2.2 连接器 Coyote

2.2.1 Coyote 架构

Coyote 是 Tomcat 的连接器框架的名称 , 是 Tomcat 服务器提供的供客户端访问的外部接 口。客户端通过 Coyote 与服务器建立连接、发送请求并接受响应

Coyote 封装了底层的网络通信（Socket 请求及响应处理），为 Catalina 容器提供了统一的接口，使 Catalina 容器与具体的请求协议及 IO 操作方式完全解耦。Coyote 将 Socket 输入转换封装为 Request 对象，交由 Catalina 容器进行处理，处理请求完成后, Catalina 通过 Coyote 提供的 Response 对象将结果写入输出流

Coyote 作为独立的模块，只负责具体协议和 IO 的相关操作， 与 Servlet 规范实现没有直接关系，因此即便是 Request 和 Response 对象也并未实现 Servlet 规范对应的接口， 而是在 Catalina 中将他们进一步封装为 ServletRequest 和 ServletResponse

2.2.2 IO 模型与协议

在 Coyote 中 ， Tomcat 支持的多种 I/O 模型和应用层协议，具体包含哪些 IO 模型和应用层协议

Tomcat 支持的 IO 模型（自 8.5/9.0 版本起，Tomcat 移除了 对 BIO 的支持）

Tomcat 支持的应用层协议

在 8.0 之前，Tomcat 默认采用的 I/O 方式为 BIO，之后改为 NIO。无论 NIO、NIO2 还是 APR， 在性能方面均优于以往的 BIO。 如果采用APR， 甚至可以达到 Apache HTTP Server 的性能

Tomcat 为了实现支持多种 I/O 模型和应用层协议，一个容器可能对接多个连接器，就好比一个房间有多个门。但是单独的连接器或者容器都不能对外提供服务，需要把它们组装起来才能工作，组装后这个整体叫作 Service 组件。这里请你注意，Service 本身没有做什么重要的事情，只是在连接器和容器外面多包了一层，把它们组装在一起。Tomcat 内可能有多个 Service，这样的设计也是出于灵活性的考虑。通过在 Tomcat 中配置多个 Service，可以实现通过不同的端口号来访问同一台机器上部署的不同应用

2.2.3 连接器组件

2.2.3.1 EndPoint

EndPoint：Coyote 通信端点，即通信监听的接口，是具体 Socket 接收和发送处理器，是对传输层的抽象，因此 EndPoint 用来实现 TCP/IP 协议的
Tomcat 并没有 EndPoint 接口，而是提供了一个抽象类 AbstractEndpoint，里面定义了两个内部类：Acceptor 和 SocketProcessor。Acceptor 用于监听 Socket 连接请求。SocketProcessor 用于处理接收到的 Socket 请求，它实现 Runnable 接口，在 Run 方法里调用协议处理组件 Processor 进行处理。为了提高处理能力，SocketProcessor 被提交到线程池来执行。而这个线程池叫作执行器（Executor)，后面会详细介绍定制化

2.2.3.2 Processor

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

2.2.3.3 ProtocolHandler

Coyote 协议接口， 通过 Endpoint 和 Processor ， 实现针对具体协议的处理能力。Tomcat 按照协议和 I/O 提供了 6 个实现类 ：AjpNioProtocol ，AjpAprProtocol，AjpNio2Protocol ， Http11NioProtocol ，Http11Nio2Protocol ，Http11AprProtocol。我们在配置 tomcat/conf/server.xml 时 ，至少要指定具体的 ProtocolHandler , 当然也可以指定协议名称 ， 如 HTTP/1.1 ，如果安装了 APR，那么将使用 Http11AprProtocol ， 否则使用 Http11NioProtocol

2.2.3.4 Adapter

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

2.3 容器 Catalina

Tomcat 是一个由一系列可配置的组件构成的 Web 容器，而 Catalina 是 Tomcat 的 servlet 容器。
Catalina 是 Servlet 容器实现，包含了之前讲到的所有的容器组件，以及后续章节涉及到的安全、会话、集群、管理等 Servlet 容器架构的各个方面。它通过松耦合的方式集成 Coyote，以完成按照请求协议进行数据读写。同时，它还包括我们的启动入口、Shell 程序等

Tomcat 本质上就是一款 Servlet 容器， 因此 Catalina 才是 Tomcat 的核心 ， 其他模块都是为 Catalina 提供支撑的。 比如 ：通过 Coyote 模块提供链接通信，Jasper 模块提供 JSP 引擎，Naming 提供 JNDI 服务，Juli 提供日志服务

2.3.1 Catalina 架构

如上图所示，Catalina 负责管理 Server，而 Server 表示着整个服务器。Server 下面有多个服务 Service，每个服务都包含着多个连接器组件 Connector（Coyote 实现）和一个容器组件 Container。在 Tomcat 启动的时候， 会初始化一个 Catalina 的实例

Catalina 各个组件的职责

2.3.2 Container 架构

Tomcat 设计了四种容器，分别是 Engine、Host、Context 和 Wrapper，这四种容器不是平行关系，而是父子关系。Tomcat 是一种分层架构，使得 Servlet 容器具有很好的灵活性

Container 各个组件的职责

我们也可以再通过 Tomcat 的 server.xml 配置文件来加深对 Tomcat 容器的理解。Tomcat 采用了组件化的设计，它的构成组件都是可配置的，其中最外层的是 Server，其他组件按照一定的格式要求配置在这个顶层容器中

<?xml version="1.0" encoding="UTF-8"?>
<Server port="8005" shutdown="SHUTDOWN">
  <Service name="Catalina">
    <!-- 定义线程池 -->
    <Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
        maxThreads="150" minSpareThreads="4"/>
    <!-- 可以配置多个 Connector 连接器, 可以使用 executor="tomcatThreadPool" 配置线程池 -->
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    <!-- 用来管理虚拟站点 -->
    <Engine name="Catalina" defaultHost="localhost">
      <!-- 表示一个 web 应用程序 -->
      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">
      </Host>
    </Engine>
  </Service>
</Server>

Tomcat 是如何管理这些容器的呢？这些容器具有父子关系，形成一个树形结构，所以 Tomcat 使用了组合模式来管理这些容器。具体实现方法是所有容器组件都实现了 Container 接口，因此组合模式可以使得用户对单容器对象和组合容器对象的使用具有一致性。这里单容器对象指的是最底层的 Wrapper，组合容器对象指的是上面的 Context、Host 或者 Engine

3. Tomcat 源码解析

3.1 启动流程

1. 启动 tomcat，需要调用 bin/startup.bat ，在 linux 目录下需要调用 bin/startup.sh ，这个脚本调用了 catalina.bat 文件
2. 在 catalina.bat 脚本文件中，调用了 BootStrap 的 main 方法
3. 在 BootStrap 的 main 方法中调用了 init 方法，来创建 Catalina 以及初始化类加载器
4. 在 BootStrap 的 main 方法中调用了 load 方法，在其中又调用了 Catalina 的 load 方法
5. 在 Catalina 的 load 方法中，需要进行一些初始化工作，并需要构造 Digester 对象，用于解析 XML
6. 然后再调用后续组件的初始化操作，加载 Tomcat 的配置文件，初始化容器组件，监听对应的端口号，准备接收客户端请求

   3.2 启动流程解析

   3.2.1 LifeCycle

   由于所有的组件均存在初始化、启动、停止等生命周期方法，拥有生命周期管理的特性， 所以Tomcat 在设计的时候， 基于生命周期管理抽象成了一个接口 Lifecycle ，而组件 Server、Service、Container、Executor、Connector 组件 ， 都实现了一个生命周期的接口，从而具有了以下生命周期中的核心方法

   3.2.2 组件实现

   StandardXxx

   上面我们提到的 Server、Service、Engine、Host、Context 都是接口，默认实现类是 StandardServer、StandardService、StandardEngine、StandardHost、StandardContext

Endpoint

对于 Endpoint 组件来说，在 Tomcat 中没有对应的 Endpoint 接口， 但是有一个抽象类 AbstractEndpoint ，其下有三个实现类： NioEndpoint、Nio2Endpoint、AprEndpoint ， 这三个实现类，分别对应 Coyote 支持的三种 IO 模型：NIO，NIO2，APR
在 Tomcat8.5 版本中，默认采用的是 NioEndpoint

ProtocolHandler

Coyote协议接口，通过封装 Endpoint 和 Processor ， 实现针对具体协议的处理功能，Tomcat按照协议和 IO 提供了 6 个实现类
AJP 协议

• AjpNioProtocol ：采用 NIO 的 IO 模型
• AjpNio2Protocol：采用 NIO2 的 IO 模型
• AjpAprProtocol ：采用 APR 的 IO 模型，需要依赖于 APR 库

HTTP 协议

• Http11NioProtocol ：采用 NIO 的 IO 模型，默认使用的协议
• Http11Nio2Protocol：采用 NIO2 的 IO 模型
• Http11AprProtocol ：采用 APR 的 IO 模型，需要依赖于 APR库

  3.3 请求流程

  设计了这么多层次的容器，Tomcat 是怎么确定每一个请求应该由哪个 Wrapper 容器里的 Servlet 来处理的呢？答案是，Tomcat 是用 Mapper 组件来完成这个任务的。

Mapper 组件的功能就是将用户请求的 URL 定位到一个 Servlet，它的工作原理是： Mapper 组件里保存了 Web 应用的配置信息，其实就是容器组件与访问路径的映射关系，比如 Host 容器里配置的域名、Context 容器里的 Web 应用路径，以及 Wrapper 容器里 Servlet 映射的路径，你可以想象这些配置信息就是一个多层次的 Map

当一个请求到来时，Mapper 组件通过解析请求 URL 里的域名和路径，再到自己保存的 Map 里去查找，就能定位到一个 Servlet。请注意，一个请求 URL 最后只会定位到一个 Wrapper 容器，也就是一个 Servlet

1. Connector 组件 Endpoint 中的 Acceptor 监听客户端套接字连接并接收 Socket
2. 将连接交给线程池 Executor 处理，开始执行请求响应任务
3. Processor 组件读取消息报文，解析请求行、请求体、请求头，封装成 Request 对象
4. Mapper 组件根据请求行的 URL 值和请求头的 Host 值匹配由哪个 Host 容器、Context 容器、Wrapper 容器处理请求
5. CoyoteAdaptor 组件负责将 Connector 组件和 Engine 容器关联起来，把生成的 Request 对象和响应对象 Response 传递到 Engine 容器中，调用 Pipeline
6. Engine 容器的管道开始处理，管道中包含若干个 Valve、每个 Valve 负责部分处理逻辑。执行完 Valve 后会执行基础的 Valve—StandardEngineValve，负责调用 Host 容器的 Pipeline
7. Host 容器的管道开始处理，流程类似，最后执行 Context 容器的 Pipeline
8. Context 容器的管道开始处理，流程类似，最后执行 Wrapper 容器的 Pipeline
9. Wrapper 容器的管道开始处理，流程类似，最后执行 Wrapper 容器对应的 Servlet 对象的处理方法

   3.4 请求流程解析

   
   在前面所讲解的 Tomcat 的整体架构中，我们发现 Tomcat中 的各个组件各司其职，组件之间松耦合，确保了整体架构的可伸缩性和可拓展性，那么在组件内部，如何增强组件的灵活性和拓展性呢？ 在 Tomcat中，每个 Container 组件采用责任链模式来完成具体的请求处理

在 Tomcat 中定义了 Pipeline 和 Valve 两个接口，Pipeline 用于构建责任链， 后者代表责任链上的每个处理器。Pipeline 中维护了一个基础的 Valve，它始终位于 Pipeline 的末端（最后执行），封装了具体的请求处理和输出响应的过程。当然，我们也可以调用 addValve()方法， 为 Pipeline 添加其他的 Valve， 后添加的 Valve 位于基础的 Valve 之前，并按照添加顺序执行。Pipiline 通过获得首个Valve 来启动整合链条的执行

4. 服务器配置

Tomcat 服务器的配置主要集中于 tomcat/conf 下的 catalina.policy、 catalina.properties、context.xml、server.xml、tomcat-users.xml、web.xml 文件

4.1 server.xml

server.xml 是 Tomcat 服务器的核心配置文件，包含了 Tomcat 的 Servlet 容器（Catalina）的所有配置

4.1.1 Server

Server 是 server.xml 的根元素，用于创建一个 Server 实例，默认使用的实现类是org.apache.catalina.core.StandardServer

<Server port="8005" shutdown="SHUTDOWN">
</Server>

Server 内嵌的子元素有 Listener、GlobalNamingResources、Service

默认配置的 5 个Listener 含义

<!-- 用于以日志形式输出服务器、操作系统、JVM 的版本信息 -->
<Listener className="org.apache.catalina.startup.VersionLoggerListener" />
<!-- 用于加载（服务器启动）和销毁（服务器停止）ARP。如果找不到 ARP，则会输出日志，并不影响 Tomcat 启动 -->
<Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
<!-- 用于避免 JRE 内存泄露问题 -->
<Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
<!-- 用户加载（服务器启动）和销毁（服务器停止）全局命名服务 -->
<Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
<!-- 用于在 Context 停止时重建 Executor 池中的线程，以避免 ThreadLocal 相关的内存泄露 -->
<Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />

GlobalNamingResources 中定义了全局命名服务

<GlobalNamingResources>
<!-- Editable user database that can also be used by
     UserDatabaseRealm to authenticate users
-->
<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>

4.1.2 service

该元素用于创建 Service 实例，默认使用 org.apache.catalina.core.StandardService 。默认情况下，Tomcat 仅指定了 Service 的名称， 值为 “Catalina”

Service 可以内嵌的元素为 ：Listener、Executor、Connector、Engine，其中 Listener 用于为 Service 添加生命周期监听器， Executor 用于配置 Service 共享线程池，Connector 用于配置 Service 包含的链接器， Engine 用于配置 Service中 链接器对应的 Servlet 容器引擎

<Service name="Catalina">
</Service>

一个 Server 服务器，可以包含多个 Service 服务

4.1.3 Executor

默认情况下，Service 并未添加共享线程池配置。 如果我们想添加一个线程池， 可以在下添加如下配置

<Executor name="tomcatThreadPool" 
    namePrefix="catalina‐exec‐" 
    maxThreads="200" 
    minSpareThreads="100" 
    maxIdleTime="60000" 
    maxQueueSize="Integer.MAX_VALUE" 
    prestartminSpareThreads="false" 
    threadPriority="5" 
    className="org.apache.catalina.core.StandardThreadExecutor"/>

如果不配置共享线程池，那么 Catalina 各组件在用到线程池时会独立创建

4.1.4 Connector（性能优化）

Connector 用于创建链接器实例。默认情况下，server.xml 配置了两个链接器，一个支持 HTTP 协议，一个支持 AJP 协议。因此大多数情况下，我们并不需要新增链接器配置，只是根据需要对已有链接器进行优化

<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" /> 
<Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />

完整的配置参考如下

<Connector port="8080" 
    protocol="HTTP/1.1" 
    maxThreads="1000" 
    minSpareThreads="100" 
    acceptCount="1000" 
    maxConnections="1000" 
    connectionTimeout="20000" 
    keepAliveTimeout="300000"
    compression="on" 
    compressionMinSize="2048" 
    disableUploadTimeout="true" 
    redirectPort="8443" 
    URIEncoding="UTF8" />

4.1.5 Engine

Engine 作为 Servlet 引擎的顶级元素，内部可以嵌入： Cluster、Listener、Realm、 Valve 和 Host

<Engine name="Catalina" defaultHost="localhost">
</Engine>

属性说明

4.1.6 Host

Host 元素用于配置一个虚拟主机， 它支持以下嵌入元素：Alias、Cluster、Listener、 Valve、Realm、Context。如果在Engine下配置Realm， 那么此配置将在当前 Engine 下的所有 Host 中共享。 同样，如果在 Host 中配置 Realm ， 则在当前 Host 下的所有 Context 中共享

Context中的 Realm 优先级 > Host 的 Realm 优先级 > Engine 中的 Realm 优先级

<Host name="localhost"  appBase="webapps"
    unpackWARs="true" autoDeploy="true">
</Host>

4.1.7 Context

Context 用于配置一个 Web 应用，默认的配置如下

<Context docBase="myApp" path="/myApp">
</Context>

它支持的内嵌元素为：CookieProcessor， Loader， Manager，Realm，Resources， WatchedResource，JarScanner，Valve

4.2 tomcat-users.xml

该配置文件中，主要配置的是 Tomcat 的用户，角色等信息，用来控制 Tomcat 中 manager， host-manager 的访问权限

4.2.1 host-manager

Tomcat启动之后，可以通过 http://localhost:8080/host-manager/html 访问该 Web 应用。 host-manager 默认添加了访问权限控制，当打开网址时，需要输入用户名和密码（在 conf/tomcat-users.xml 中配置）

对应的角色有两种

1. admin-gui：用于控制页面访问权限
2. admin-script：用于控制以简单文本的形式进行访问

   <role rolename="admin-gui"/> 
   <role rolename="admin-script"/> 
   <user username="masteryourself" password="masteryourself" roles="admin-gui, admin-script"/>

   4.2.2 manager

   manager 的访问地址为 http://localhost:8080/manager， 同样 manager 也添加了页面访问控制，因此我们需要为登录用户分配角色为

   <role rolename="manager-gui"/> 
   <role rolename="manager-script"/> 
   <user username="masteryourself" password="masteryourself" roles="admin-gui, admin-script, manager-gui, manager-script"/>

   4.3 JVM 参数配置

   4.3.1 catalina.bat

   set JAVA_OPTS=‐server ‐Xms2048m ‐Xmx2048m ‐XX:MetaspaceSize=256m ‐XX:MaxMetaspaceSize=256m ‐XX:SurvivorRatio=8

   4.3.2 catalina.sh

   JAVA_OPTS="‐server ‐Xms1024m ‐Xmx2048m ‐XX:MetaspaceSize=256m ‐ XX:MaxMetaspaceSize=512m ‐XX:SurvivorRatio=8"

   | 配置 | 含义 | | —- | —- | | -Xms | 堆内存的初始大小 | | -Xmx | 堆内存的最大大小 | | -Xmn | 新生代的内存大小，官方建议是整个堆得 3/8 | | -XX:MetaspaceSize | 元空间内存初始大小， 在 JDK1.8 版本之前配置为 -XX:PermSize（永久代） | | -XX:InitialCodeCacheSize
   -XX:ReservedCodeCacheSize | 代码缓存区大小 | | -XX:NewRatio | 设置新生代和老年代的相对大小比例。这种方式的优点是新生代大小会随着整个堆大小动态扩展
   如 -XX:NewRatio=3 指定老年代 / 新生代为 3/1。 老年代占堆大小的 3/4，新生代占 1/4 | | -XX:SurvivorRatio | 指定伊甸园区 (Eden) 与幸存区大小比例
   如 -XX:SurvivorRatio=10 表示伊甸园区 (Eden) 是 幸存区 To 大小的 10 倍 (也是幸存区 From 的 10 倍)。 所以伊甸园区 (Eden) 占新生代 大小的 10/12， 幸存区 From 和幸存区 To 每 个占新生代的 1/12
   注意， 两个幸存区永远是一样大的 |

5. Web 应用配置

web.xml 是web应用的描述文件， 它支持的元素及属性来自于 Servlet 规范定义 。 在 Tomcat 中，Web 应用的描述信息包括 tomcat/conf/web.xml 中默认配置 以及 Web 应用 WEB-INF/web.xml 下的定制配置

5.1 ServletContext 初始化参数

我们可以通过添加 ServletContext 初始化参数，它配置了一个键值对，这样我们可以在应用程序中使用 javax.servlet.ServletContext.getInitParameter() 方法获取参数

<context‐param> 
    <param‐name>contextConfigLocation</param‐name> 
    <param‐value>classpath:applicationContext‐*.xml</param‐value> 
    <description>Spring Config File Location</description> 
</context‐param>

5.2 会话配置

用于配置 Web 应用会话，包括超时时间、Cookie 配置以及会话追踪模式。它将覆盖 server.xml 和 context.xml 中的配置

<session‐config> 
      <!-- 会话超时时间，默认是 30 分钟 -->
    <session‐timeout>30</session‐timeout>
</session‐config>

5.3 Servlet 配置

<servlet>
    <servlet‐name>myServlet</servlet‐name> 
    <servlet‐class>org.masteryourself.tutotial.tomcat.MyServlet</servlet‐class> 
    <init‐param> 
        <param‐name>fileName</param‐name> 
        <param‐value>init.conf</param‐value> 
    </init‐param> 
    <load‐on‐startup>1</load‐on‐startup> 
    <enabled>true</enabled> 
</servlet> 
<servlet‐mapping> 
    <servlet‐name>myServlet</servlet‐name> 
    <url‐pattern>*.do</url‐pattern> 
    <url‐pattern>/myservet/*</url‐pattern> 
</servlet‐mapping>

5.4 Listener 配置

Listener 用于监听 servlet 中的事件，例如 context、request、session 对象的创建、修改、删除，并触发响应事件。Listener 是观察者模式的实现，在servlet 中主要用于对 context、request、session对象的生命周期进行监控。在 servlet2.5 规范中共定义了 8 种 Listener。在启动时，ServletContextListener 的执行顺序与 web.xml 中的配置顺序一 致， 停止时执行顺序相反。

<listener> 
    <listener‐class>org.springframework.web.context.ContextLoaderListener</listener‐class> 
</listener>

5.5 Filter 配置

filter 用于配置 web 应用过滤器， 用来过滤资源请求及响应。经常用于认证、日志、加密、数据转换等操作， 配置如下

<filter> 
    <filter‐name>myFilter</filter‐name> 
    <filter‐class>org.masteryourself.tutotial.tomcat.MyFilter</filter‐class> 
    <async‐supported>true</async‐supported> 
    <init‐param> 
        <param‐name>language</param‐name> 
        <param‐value>CN</param‐value> 
    </init‐param> 
</filter> 
<filter‐mapping> 
    <filter‐name>myFilter</filter‐name> 
    <url‐pattern>/*</url‐pattern> 
</filter‐mapping>

5.6 欢迎页配置

welcome-file-list 用于指定 web 应用的欢迎文件列表，请求顺序是从上至下

<welcome‐file‐list> 
    <welcome‐file>index.html</welcome‐file> 
    <welcome‐file>index.htm</welcome‐file> 
    <welcome‐file>index.jsp</welcome‐file> 
</welcome‐file‐list>

5.7 错误页面配置

error-page 用于配置 Web 应用访问异常时定向到的页面，支持 HTTP 响应码和异常类两种形式

<error‐page> 
    <error‐code>404</error‐code> 
    <location>/404.html</location> 
</error‐page> <error‐page> 
<error‐code>500</error‐code> 
<location>/500.html</location> 
</error‐page> 
<error‐page> 
    <exception‐type>java.lang.Exception</exception‐type> 
    <location>/error.jsp</location> 
</error‐page>

6. 安全配置

6.1 配置安全

1. 删除 webapps 目录下的所有文件，禁用 tomcat 管理界面
2. 2.注释或删除 tomcat-users.xml 文件内的所有用户权限
3. 更改关闭 tomcat 指令或禁用

• tomcat 的 server.xml 中定义了可以直接关闭 Tomcat 实例的管理端口（默认 8005）。 可以通过 telnet 连接上该端口之后，输入 SHUTDOWN （此为默认关闭指令）即可关闭 Tomcat 实例（注意，此时虽然实例关闭了，但是进程还是存在的） ```xml

4. 定义错误页面
- 避免将堆栈信息响应给用户，也提供了用户体验
<a name="k86qp"></a>
## 6.2 HTTPS 安全
1. 生成秘钥文件
```bash
ruanrenzhao@MacBook-Pro conf % keytool -genkey -alias tomcat -keyalg RSA -keystore tomcat.keystore
输入密钥库口令:  
再次输入新口令: 
您的名字与姓氏是什么?
  [Unknown]:  masteryourself
您的组织单位名称是什么?
  [Unknown]:  masteryourself
您的组织名称是什么?
  [Unknown]:  masteryourself
您所在的城市或区域名称是什么?
  [Unknown]:  shanghai
您所在的省/市/自治区名称是什么?
  [Unknown]:  shanghai
该单位的双字母国家/地区代码是什么?
  [Unknown]:  CN
CN=masteryourself, OU=masteryourself, O=masteryourself, L=shanghai, ST=shanghai, C=CN是否正确?
  [否]:  Y
输入 <tomcat> 的密钥口令
    (如果和密钥库口令相同, 按回车):  
再次输入新口令:

1. 将秘钥库文件 tomcat.keystore 复制到 tomcat/conf 目录下

2. 配置 tomcat/conf/server.xml

   <Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol" 
    maxThreads="150" schema="https" secure="true" SSLEnabled="true"> 
    <SSLHostConfig certificateVerification="false"> 
        <Certificate certificateKeystoreFile="/Users/ruanrenzhao/Downloads/apache-tomcat-8.5.73/conf/tomcat.keystore"
            certificateKeystorePassword="masteryourself" type="RSA" /> 
    </SSLHostConfig> 
   </Connector>

3. 使用 https 协议访问 Tomcat [https://localhost:8443/](https://localhost:8443/)