轩辕李的博客
轩辕李
2022-04-08
目录

Tomcat体系介绍及应用

随着互联网技术的飞速发展，各种Web应用在我们的日常生活中扮演着越来越重要的角色。

在Web应用的开发过程中，Web服务器是一个至关重要的组成部分。在众多的Web服务器产品中，Tomcat以其轻量级、易用性和高性能赢得了广泛的好评。

本文将对Tomcat（以9.x为例）体系进行详细介绍，并探讨其在实际应用中的应用场景。

# 一、Tomcat体系简介

Tomcat，全名Apache Tomcat，是Apache软件基金会（Apache Software Foundation）下的一个开源项目，用于提供一个符合Java Servlet和JavaServer Pages（JSP）规范的Web服务器环境。

Tomcat可以作为独立的Web服务器运行，同时也可以与其他流行的Web服务器（如Apache、Nginx等）协同工作，为Web应用提供动态内容处理能力。

# 二、Tomcat体系结构

Tomcat体系结构主要由以下几个核心组件构成：

# 1、Tomcat整体架构图

┌─────────────────────────────────────────────────┐
│                    Server                       │
│  ┌────────────────────────────────────────────┐ │
│  │                 Service                    │ │
│  │  ┌──────────┐  ┌────────────────────────┐ │ │
│  │  │Connector │  │        Engine          │ │ │
│  │  │ (Coyote) │  │  ┌──────────────────┐ │ │ │
│  │  │          │──│  │      Host        │ │ │ │
│  │  │ HTTP/1.1 │  │  │  ┌────────────┐ │ │ │ │
│  │  │          │  │  │  │  Context   │ │ │ │ │
│  │  └──────────┘  │  │  │  ┌──────┐ │ │ │ │ │
│  │                │  │  │  │Wrapper│ │ │ │ │ │
│  │  ┌──────────┐  │  │  │  │(Servlet)│ │ │ │ │
│  │  │Connector │  │  │  │  └──────┘ │ │ │ │ │
│  │  │ (Coyote) │  │  │  └────────────┘ │ │ │ │
│  │  │   AJP    │──│  └──────────────────┘ │ │ │
│  │  └──────────┘  └────────────────────────┘ │ │
│  └────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────┘

# 2、Catalina组件

Catalina是Tomcat的核心组件，作为一个Servlet容器，它实现了Java Servlet规范。Catalina的源码位于org.apache.catalina包下。其主要功能包括加载、解析和执行Web应用中的Servlet。

# 2.1、Catalina组件架构

Catalina采用了经典的容器-组件设计模式，所有组件都实现了Lifecycle接口，支持统一的生命周期管理：

public interface Lifecycle {
    void init() throws LifecycleException;
    void start() throws LifecycleException;
    void stop() throws LifecycleException;
    void destroy() throws LifecycleException;
}

Catalina的核心组件包括以下几个部分：

# 2.2、Server

Server是Catalina的顶级组件，对应于Tomcat实例。在一个Tomcat服务器中，可以配置多个Service。Server组件的实现类是org.apache.catalina.core.StandardServer。

主要职责：

  • 管理Service组件的生命周期
  • 提供全局命名资源（JNDI）
  • 监听shutdown端口（默认8005）用于关闭服务器

配置示例（server.xml）：

<Server port="8005" shutdown="SHUTDOWN">
  <Service name="Catalina">
    <!-- Service配置 -->
  </Service>
</Server>

# 2.3、Service

Service组件负责组织一个或多个Connector与一个Engine之间的关系。每个Service都有一个唯一的名字，对应一个具体的应用场景。Service组件的实现类是org.apache.catalina.core.StandardService。

主要职责：

  • 维护Connector和Container（Engine）之间的关联
  • 管理Executor线程池
  • 协调请求处理流程

配置示例：

<Service name="Catalina">
  <Connector port="8080" protocol="HTTP/1.1" />
  <Connector port="8009" protocol="AJP/1.3" />
  <Engine name="Catalina" defaultHost="localhost">
    <!-- Engine配置 -->
  </Engine>
</Service>

# 2.4、Engine

Engine组件是Catalina的核心处理器，负责处理来自Connector的请求，并将请求分发给相应的Host。一个Engine可以包含多个Host，每个Host对应一个虚拟主机。Engine组件的实现类是org.apache.catalina.core.StandardEngine。

# 2.5、Host

Host组件代表一个虚拟主机，负责处理来自Engine的请求，并将请求分发给相应的Context。一个Host可以包含多个Context，每个Context对应一个Web应用。Host组件的实现类是org.apache.catalina.core.StandardHost。

# 2.6、Context

Context组件代表一个Web应用，负责处理来自Host的请求，并将请求分发给相应的Servlet。一个Context可以包含多个Servlet，每个Servlet对应一个具体的请求处理逻辑。Context组件的实现类是org.apache.catalina.core.StandardContext。

# 2.7、Wrapper

Wrapper组件代表一个Servlet实例，负责处理来自Context的请求。Wrapper组件的实现类是org.apache.catalina.core.StandardWrapper。

# 3、Coyote组件

Coyote是Tomcat的连接器（Connector）组件，负责接收来自客户端的请求，以及将响应数据返回给客户端。Coyote的源码位于org.apache.coyote包下。Coyote支持多种协议，如HTTP、HTTPS和AJP等。Coyote的核心组件包括以下几个部分：

# 3.1、ProtocolHandler

ProtocolHandler是Coyote的顶层接口，负责处理客户端的连接和请求。根据不同的协议，Coyote提供了不同的实现，如org.apache.coyote.http11.Http11Protocol（处理HTTP/1.1协议）和org.apache.coyote.ajp.AjpProtocol（处理AJP协议）等。

# 3.2、Processor

Processor组件负责处理来自ProtocolHandler的请求，并将请求转发给Catalina组件。Processor的具体实现依赖于所使用的协议。例如，对于HTTP/1.1协议，org.apache.coyote.http11.Http11Processor负责处理请求。对于AJP协议，org.apache.coyote.ajp.AjpProcessor负责处理请求。

# 3.3、Adapter

Adapter组件是Coyote与Catalina之间的桥梁，负责将Coyote的请求对象转换为Catalina可以处理的请求对象。Adapter的实现类是org.apache.catalina.connector.CoyoteAdapter。它将Coyote的Request对象转换为Catalina的org.apache.catalina.connector.Request对象，同时将Coyote的Response对象转换为Catalina的org.apache.catalina.connector.Response对象。

# 3.4、Endpoint

Endpoint组件是Coyote的底层通信接口，负责实现与客户端的网络连接。Endpoint的实现依赖于所使用的I/O模型，如阻塞I/O（BIO）、非阻塞I/O（NIO）和异步I/O（AIO）等。对于HTTP/1.1协议，Tomcat提供了如下几种实现：

  • org.apache.tomcat.util.net.JIoEndpoint：基于Java标准I/O（BIO）实现的Endpoint。
  • org.apache.tomcat.util.net.NioEndpoint：基于Java NIO实现的Endpoint。
  • org.apache.tomcat.util.net.Nio2Endpoint：基于Java NIO2（AIO）实现的Endpoint。

对于AJP协议，Tomcat也提供了类似的实现：

  • org.apache.tomcat.util.net.AjpBIOEndpoint：基于Java标准I/O（BIO）实现的AJP Endpoint。
  • org.apache.tomcat.util.net.AjpNioEndpoint：基于Java NIO实现的AJP Endpoint。
  • org.apache.tomcat.util.net.AjpNio2Endpoint：基于Java NIO2（AIO）实现的AJP Endpoint。

# 4、Jasper组件

Jasper是Tomcat的JSP引擎，负责将JSP页面转换为Java Servlet，并在运行时执行。Jasper的源码位于org.apache.jasper包下。Jasper的主要功能包括JSP页面的解析、编译和执行。以下是Jasper的核心组件：

# 4.1、JspC

JspC是Jasper的JSP编译器，负责将JSP页面转换为Java源代码（Servlet）。JspC的实现类是org.apache.jasper.JspC。在编译过程中，JspC首先解析JSP页面的标签和脚本，然后将这些内容转换为Java代码。编译完成后，JSP页面对应的Servlet将被加载和执行。

# 4.2、JspServlet

JspServlet是Jasper的核心Servlet，负责处理来自客户端的JSP请求。JspServlet的实现类是org.apache.jasper.servlet.JspServlet。在运行时，JspServlet会根据请求的URL找到对应的JSP页面，并调用Jasper编译器将JSP页面编译成Servlet。然后，JspServlet会调用生成的Servlet的service()方法处理请求，并将响应数据返回给客户端。

# 4.3、JspRuntimeContext

JspRuntimeContext是Jasper的运行时上下文，负责管理JSP页面的编译和加载。JspRuntimeContext的实现类是org.apache.jasper.runtime.JspRuntimeContext。它维护了一个JSP页面与Servlet之间的映射关系，以及Servlet的加载状态。在运行时，JspRuntimeContext负责检查JSP页面是否需要重新编译，以及加载和卸载Servlet。

# 5、Cluster组件

Cluster是Tomcat的集群管理组件，用于实现Web应用的高可用性、负载均衡和会话共享等功能。Cluster的源码位于org.apache.catalina.ha包下。以下是Cluster的核心组件：

# 5.1、Cluster

Cluster接口是集群管理的顶层接口，定义了集群的基本行为。Cluster的实现类是org.apache.catalina.ha.tcp.SimpleTcpCluster。一个Cluster实例包含一个或多个ClusterListener、一个或多个Valve以及一个或多个Channel。

# 5.2、ClusterListener

ClusterListener接口是集群事件监听器的顶层接口。ClusterListener负责监听集群中的成员变化和会话状态变化等事件。ClusterListener的实现类包括org.apache.catalina.ha.session.ClusterSessionListener（处理会话状态同步）和org.apache.catalina.ha.session.JvmRouteBinderListener（处理会话故障转移）等。

# 5.3、Valve

Valve是一个请求处理组件，负责在请求处理流程中实现集群特定的功能。例如，org.apache.catalina.ha.tcp.ReplicationValve用于在集群中复制会话状态，确保会话数据在多个集群节点间保持一致。

# 5.4、Channel

Channel是集群通信的核心组件，负责在集群节点之间传输消息。Channel的实现类是org.apache.catalina.tribes.group.GroupChannel。Channel包含一个Sender用于发送消息，一个Receiver用于接收消息，以及一个Interceptor链用于处理消息。Channel的通信协议可以根据实际需求进行配置，例如使用TCP或UDP协议。

# 5.5、Membership

Membership组件负责管理集群中的成员信息。Membership的实现类是org.apache.catalina.tribes.membership.McastService。它通过多播协议实现集群成员的自动发现，以及成员的加入和离开通知。

# 5.6、GroupChannel

GroupChannel是Channel的默认实现类，负责实现集群间的通信功能。GroupChannel的实现类是org.apache.catalina.tribes.group.GroupChannel。它使用Apache Tribes库实现了基于消息传递的集群通信，支持点对点、广播和多播等通信模式。

# 三、Tomcat请求处理流程

# 1、请求处理的完整流程

当一个HTTP请求到达Tomcat时，会经历以下处理流程：

客户端请求
    ↓
[Connector]
    ├─ Endpoint.Acceptor → 接收连接
    ├─ Endpoint.Poller → 检测I/O事件
    ├─ Processor → 解析HTTP协议
    └─ Adapter → 创建Request/Response
    ↓
[Engine] → 根据Host匹配
    ↓
[Host] → 根据Context Path匹配
    ↓
[Context] → 根据URL Pattern匹配
    ↓
[Wrapper] → 调用Servlet.service()
    ↓
[Servlet] → 业务处理
    ↓
响应返回客户端

# 2、关键处理阶段详解

# 2.1、连接接收阶段

// Acceptor接收新连接
ServerSocketChannel serverSocket = ServerSocketChannel.open();
serverSocket.bind(new InetSocketAddress(port));

while (running) {
    SocketChannel socket = serverSocket.accept();
    // 将新连接交给Poller处理
    poller.register(socket);
}

# 2.2、请求解析阶段

// Processor解析HTTP请求
public void process(SocketChannel socket) {
    // 1. 读取请求行
    String requestLine = readLine(socket);
    // GET /app/servlet HTTP/1.1
    
    // 2. 解析请求头
    Map<String, String> headers = parseHeaders(socket);
    
    // 3. 读取请求体（如果有）
    if (headers.containsKey("Content-Length")) {
        byte[] body = readBody(socket, contentLength);
    }
}

# 2.3、请求映射阶段

// Mapper组件进行URL映射
public void map(MessageBytes uri, MappingData mappingData) {
    // 1. 解析URI: /app/servlet
    // 2. 匹配Host: localhost
    // 3. 匹配Context: /app
    // 4. 匹配Wrapper: /servlet
    // 5. 设置映射结果
    mappingData.host = findHost(serverName);
    mappingData.context = findContext(contextPath);
    mappingData.wrapper = findWrapper(servletPath);
}

# 四、Tomcat的安装与配置

Tomcat的安装过程相对简单，主要包括以下步骤：

（1）下载Tomcat安装包：访问Tomcat官方网站（http://tomcat.apache.org），选择合适的版本进行下载。

（2）解压安装包：将下载的安装包解压到指定目录，如“/usr/local/tomcat”。

（3）配置环境变量：为了方便使用Tomcat，可以将其安装目录添加到环境变量中。在系统的环境变量配置文件中（如.bashrc或.bash_profile），添加以下内容：

export CATALINA_HOME=/usr/local/tomcat
export PATH=$CATALINA_HOME/bin:$PATH

（4）启动Tomcat：通过执行catalina.sh start或catalina.bat start命令启动Tomcat服务器。

（5）验证安装：在浏览器中访问http://localhost:8080，如果看到Tomcat的欢迎页面，说明安装成功。

# 五、Tomcat性能优化

# 1、JVM优化

# 1.1、JVM参数配置

# 基础内存配置
JAVA_OPTS="-Xms2048m -Xmx4096m -XX:MetaspaceSize=256m -XX:MaxMetaspaceSize=512m"

# GC优化（G1垃圾收集器）
JAVA_OPTS="$JAVA_OPTS -XX:+UseG1GC -XX:MaxGCPauseMillis=200"

# GC日志
JAVA_OPTS="$JAVA_OPTS -Xlog:gc*:file=logs/gc.log:time,uptime,level,tags:filecount=10,filesize=10M"

# JIT编译优化
JAVA_OPTS="$JAVA_OPTS -XX:+TieredCompilation -XX:ReservedCodeCacheSize=256m"

# 2、连接器优化

# 2.1、NIO连接器优化配置

<Connector port="8080"
    protocol="org.apache.coyote.http11.Http11NioProtocol"
    connectionTimeout="20000"
    maxThreads="500"
    minSpareThreads="50"
    acceptCount="200"
    maxConnections="10000"
    processorCache="500"
    compression="on"
    compressionMinSize="2048"
    compressableMimeType="text/html,text/xml,text/plain,text/css,text/javascript,application/javascript,application/json"
    URIEncoding="UTF-8"/>

# 3、线程池优化

# 3.1、共享线程池配置

<!-- 定义共享线程池 -->
<Executor name="tomcatThreadPool"
    namePrefix="catalina-exec-"
    maxThreads="500"
    minSpareThreads="50"
    maxIdleTime="60000"
    maxQueueSize="1000"
    prestartminSpareThreads="true"/>

<!-- 连接器使用共享线程池 -->
<Connector executor="tomcatThreadPool"
    port="8080"
    protocol="org.apache.coyote.http11.Http11NioProtocol"/>

# 4、会话管理优化

# 4.1、持久化会话配置

<Context>
    <!-- 使用JDBC持久化会话 -->
    <Manager className="org.apache.catalina.session.PersistentManager"
        saveOnRestart="true"
        maxActiveSessions="-1"
        minIdleSwap="60"
        maxIdleSwap="120"
        maxIdleBackup="300">
        <Store className="org.apache.catalina.session.JDBCStore"
            connectionURL="jdbc:mysql://localhost:3306/tomcat"
            driverName="com.mysql.cj.jdbc.Driver"
            sessionTable="tomcat_sessions"/>
    </Manager>
</Context>

# 5、静态资源优化

# 5.1、配置静态资源缓存

<Context>
    <!-- 配置静态资源缓存 -->
    <Resources cachingAllowed="true"
        cacheMaxSize="100000"
        cacheObjectMaxSize="2048"/>
    
    <!-- 配置过期时间 -->
    <WatchedResource>WEB-INF/web.xml</WatchedResource>
    <WatchedResource>${catalina.base}/conf/web.xml</WatchedResource>
</Context>

# 六、Tomcat的应用场景

作为一个轻量级的Web服务器，Tomcat广泛应用于以下场景：

（1）企业级Web应用：Tomcat适用于各种规模的企业级Web应用，包括企业门户、电子商务、在线教育、物联网等。通过与其他Web服务器（如Apache、Nginx等）的配合，可以实现Web应用的高性能、高可用性和安全性。

（2）云计算平台：Tomcat可以很好地支持云计算平台，如Amazon Web Services（AWS）、Google Cloud Platform（GCP）和Microsoft Azure等。通过容器化技术（如Docker、Kubernetes等），可以轻松地在云平台上部署和管理Tomcat服务器。

（3）微服务架构：随着微服务架构的兴起，许多开发者选择将Web应用拆分成多个独立的、可独立部署和扩展的服务。Tomcat作为一个轻量级的Web服务器，非常适合作为微服务的基础设施。

（4）开发和测试环境：由于Tomcat的轻量级特性，它非常适合作为开发和测试环境的Web服务器。开发者可以在本地搭建一个Tomcat服务器，方便地进行Web应用的开发和调试。

# 七、Spring Boot中的嵌入式Tomcat

Spring Boot是一个流行的Java Web开发框架，它简化了基于Spring的Web应用开发。

Spring Boot提供了一套默认配置，使得开发者能够轻松地构建、部署和运行Web应用。在Spring Boot中，内嵌的Tomcat作为默认的Web服务器，提供了Web应用的运行环境。

Spring Boot中的内嵌Tomcat具有以下特点：

  1. 内嵌：与传统的独立Tomcat服务器不同，Spring Boot中的Tomcat是作为一个库（如tomcat-embed-core）被引入到项目中。这意味着开发者无需单独安装和配置Tomcat服务器，只需通过Spring Boot的配置即可实现Web服务器的功能。

  2. 自动配置：Spring Boot提供了一套自动配置机制，它会根据项目的依赖关系和配置属性自动配置内嵌Tomcat。例如，如果项目中包含了Spring MVC依赖，Spring Boot会自动配置一个Servlet容器，并注册DispatcherServlet。开发者可以通过application.properties或application.yml文件配置Tomcat的参数，如端口号、连接超时时间等。

  3. 易于集成：内嵌的Tomcat与Spring Boot的其他组件（如Spring MVC、Spring Security等）紧密集成，使得开发者可以专注于业务逻辑的开发，而无需过多关注Web服务器的配置和管理。

  4. 灵活性：虽然Spring Boot默认使用内嵌的Tomcat作为Web服务器，但开发者可以根据实际需求选择其他内嵌服务器，如Jetty或Undertow。通过简单地修改项目的依赖和配置，即可实现对不同Web服务器的切换。

在Spring Boot项目中使用内嵌Tomcat的步骤如下：

  1. 在项目的构建文件（如pom.xml或build.gradle）中添加spring-boot-starter-web依赖。这会自动引入内嵌Tomcat以及相关的Spring MVC组件。

  2. 创建一个Spring Boot应用主类，并使用@SpringBootApplication注解标注。在主类的main方法中，调用SpringApplication.run()方法启动应用。

  3. （可选）在application.properties或application.yml文件中配置Tomcat的相关参数。

# 1、Tomcat配置参数

在application.properties或application.yml文件中配置

  1. 服务器端口：
server.port=8080
  1. 上下文路径：
server.servlet.context-path=/myapp
  1. 会话超时时间（以秒为单位）：
server.servlet.session.timeout=1800

  1. 连接器相关配置：

    • 最大连接数：
    server.tomcat.max-connections=10000
    • 接受连接队列大小：
    server.tomcat.accept-count=100
    • 最大线程数：
    server.tomcat.max-threads=200

    注意：最大线程数+连接队列大小的和不能超过最大连接数
    问题：如果Tomcat配置了NIO，为啥还有使用多线程呢？ 引入多线程主要是为了解决高并发和长耗时问题的。多线程和NIO协同工作，可以提高服务器的性能和可扩展性。 参考 Java网络编程-NIO

    • 最小空闲线程数：
    server.tomcat.min-spare-threads=10
    • 连接超时时间（以毫秒为单位）：
    server.tomcat.connection-timeout=20000

  2. URI编码：

    server.tomcat.uri-encoding=UTF-8

  3. 配置SSL（HTTPS）：

    • 开启HTTPS：
    server.ssl.enabled=true
    • 密钥库类型：
    server.ssl.key-store-type=PKCS12
    • 密钥库文件：
    server.ssl.key-store=classpath:keystore.p12
    • 密钥库密码：
    server.ssl.key-store-password=mykeystorepassword
    • 密钥别名：
    server.ssl.key-alias=mykeyalias
    • 密钥密码：
    server.ssl.key-password=mykeypassword

这些只是一部分常用的配置参数。根据实际需求，你可以在官方文档中查找更多关于Tomcat配置的参数：Spring Boot官方文档 - Tomcat配置 (opens new window)。

# 2、连接器参数配置参考

以8核16G的服务器为例，以下是一些建议性的Tomcat连接器参数配置。

  1. 最大连接数（max-connections）：建议设置为400-800。这个范围内的值可以充分利用服务器资源，同时避免过高的并发连接导致资源耗尽。

  2. 接受连接队列大小（accept-count）：建议设置为100-200。这个范围内的值可以确保在高并发请求下有足够的队列容量，同时避免大量等待请求导致服务器过载。

  3. 最大线程数（max-threads）：建议设置为200-400。这个范围内的值可以确保服务器在高并发访问下具有足够的处理能力，同时避免过高的线程数导致服务器资源耗尽。

  4. 最小空闲线程数（min-spare-threads）：建议设置为50-100。这个范围内的值可以确保在空闲时服务器具有一定的请求处理能力，同时避免过高的空闲线程数导致资源浪费。

  5. 连接超时时间（connection-timeout）：建议设置为30000（30秒）。这个值可以确保服务器在客户端未发送请求时释放空闲连接，从而避免资源浪费。

在实际部署和运行过程中，需要对服务器性能和应用程序负载进行监控，根据实际情况对参数进行调整。如果可能，进行压力测试和基准测试以获得更准确的配置建议。

# 八、Tomcat监控与诊断

# 1、JMX监控

# 1.1、启用JMX

JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote"
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote.port=9999"
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote.ssl=false"
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote.authenticate=false"

# 1.2、监控指标

  • 线程池状态：currentThreadCount、currentThreadsBusy
  • 请求处理：requestCount、errorCount、processingTime
  • 会话管理：activeSessions、sessionCounter
  • 连接器状态：connectionCount、maxConnections

# 2、访问日志分析

# 2.1、配置访问日志

<Valve className="org.apache.catalina.valves.AccessLogValve"
    directory="logs"
    prefix="access_log"
    suffix=".txt"
    pattern="%h %l %u %t &quot;%r&quot; %s %b %D %{User-Agent}i"
    rotatable="true"
    renameOnRotate="true"/>

# 2.2、日志格式说明

  • %h - 远程主机名
  • %l - 远程逻辑用户名
  • %u - 认证用户名
  • %t - 时间戳
  • %r - 请求行
  • %s - HTTP状态码
  • %b - 响应字节数
  • %D - 处理时间（毫秒）
  • %{User-Agent}i - User-Agent请求头

# 3、线程转储分析

# 3.1、获取线程转储

# 方法1：使用jstack
jstack <pid> > thread_dump.txt

# 方法2：使用kill命令
kill -3 <pid>

# 方法3：使用JMX
jcmd <pid> Thread.print

# 3.2、分析要点

  • 死锁检测：查找"Found one Java-level deadlock"
  • 阻塞线程：查找"BLOCKED"状态的线程
  • 高CPU线程：结合top命令定位
  • 线程池耗尽：检查"http-nio-8080-exec"线程状态

# 4、内存分析

# 4.1、堆转储分析

# 生成堆转储
jmap -dump:format=b,file=heap.hprof <pid>

# 自动生成OOM时的堆转储
JAVA_OPTS="$JAVA_OPTS -XX:+HeapDumpOnOutOfMemoryError"
JAVA_OPTS="$JAVA_OPTS -XX:HeapDumpPath=/path/to/dumps"

# 九、Tomcat安全配置

# 1、基础安全配置

# 1.1、删除默认应用

# 删除不必要的默认应用
rm -rf webapps/docs
rm -rf webapps/examples
rm -rf webapps/host-manager
rm -rf webapps/manager
rm -rf webapps/ROOT

# 1.2、修改默认端口

<!-- 修改shutdown端口 -->
<Server port="-1" shutdown="SHUTDOWN">

<!-- 修改HTTP端口 -->
<Connector port="8888" protocol="HTTP/1.1"/>

# 2、用户认证配置

# 2.1、配置用户角色

<!-- conf/tomcat-users.xml -->
<tomcat-users>
    <role rolename="admin-gui"/>
    <role rolename="manager-gui"/>
    <user username="admin" password="{加密密码}" roles="admin-gui,manager-gui"/>
</tomcat-users>

# 3、SSL/TLS配置

# 3.1、生成证书

# 生成自签名证书
keytool -genkey -alias tomcat -keyalg RSA -keystore tomcat.keystore

# 3.2、配置HTTPS

<Connector port="8443"
    protocol="org.apache.coyote.http11.Http11NioProtocol"
    maxThreads="150"
    SSLEnabled="true"
    scheme="https"
    secure="true">
    <SSLHostConfig>
        <Certificate certificateKeystoreFile="conf/tomcat.keystore"
            certificateKeystorePassword="changeit"
            type="RSA"/>
    </SSLHostConfig>
</Connector>

# 4、安全头配置

<!-- 配置安全响应头 -->
<filter>
    <filter-name>httpHeaderSecurity</filter-name>
    <filter-class>org.apache.catalina.filters.HttpHeaderSecurityFilter</filter-class>
    <init-param>
        <param-name>antiClickJackingEnabled</param-name>
        <param-value>true</param-value>
    </init-param>
    <init-param>
        <param-name>antiClickJackingOption</param-name>
        <param-value>DENY</param-value>
    </init-param>
</filter>

# 十、总结

Tomcat是一个功能强大、易用的Web服务器，适用于各种规模和类型的Web应用。

未来，随着互联网技术的不断发展，Web服务器将面临更高的性能、安全和可扩展性要求。

Tomcat作为一个开源项目，将不断迭代和升级，以满足这些挑战。同时，我们期待Tomcat在更多的应用场景中发挥其优势，为Web应用开发者提供更好的支持。

祝你变得更强！

编辑 (opens new window)
#Tomcat
上次更新: 2025/08/15
响应式编程初探
Redis实践应用

← Redis实践应用→

最近更新
01
AI时代的编程心得
09-11
02
Claude Code与Codex的协同工作
09-01
03
Claude Code实战之供应商切换工具
08-18
更多文章>
Theme by Vdoing | Copyright © 2018-2025 京ICP备2021021832号-2 | MIT License