理解Tomcat，掌握Tomcat【进阶版】

当小说一样阅读，一定会有收获的哇。你大概率会越来越牛逼。

目录

一、内嵌 Tomcat 闪亮登场：为何独具魅力

（一）传统 Web 应用部署之 “痛”

（二）内嵌 Tomcat 带来的 “曙光”

二、初识内嵌 Tomcat：核心概念全知晓

（一）什么是内嵌 Tomcat

（二）内嵌 Tomcat 的工作原理

三、在 Spring Boot 中玩转内嵌 Tomcat：实战开启

（一）Spring Boot 与内嵌 Tomcat 的完美邂逅

（二）创建 Spring Boot + 内嵌 Tomcat 项目

四、深入探究 Spring Boot 内嵌 Tomcat 的配置：掌控细节

（一）基础配置调整

（二）高级配置玩法

五、基于内嵌 Tomcat 开发 Servlet：经典回归

（一）编写简单的 Servlet

（二）注册与映射 Servlet

六、内嵌 Tomcat 与 JSP 协同作战：动态页面的魅力

（一）引入 JSP 支持

（二）编写与运行 JSP 页面

七、内嵌 Tomcat 的性能优化：让你的应用 “飞” 起来

（一）JVM 调优

（二）优化 Tomcat 自身配置

亲爱的家人们，今天我要给你们分享一个在 Java Web 开发领域超级实用、宛如给项目插上 “隐形翅膀” 的技术 —— 内嵌 Tomcat。你们知道吗，平常咱们开发 Web 应用，部署起来有时候挺麻烦的，得在服务器上安装配置 Tomcat，还得操心各种参数设置、文件部署的事儿。但有了内嵌 Tomcat 就不一样啦，它就像是把一个迷你版的、超级智能的 Web 服务器直接装进咱们的 Java 项目里，让咱们随时随地就能启动 Web 应用，测试、开发都变得无比便捷，下面我就详细给你们唠唠。

一、内嵌 Tomcat 闪亮登场：为何独具魅力

（一）传统 Web 应用部署之 “痛”

以前，要是咱们想让 Java Web 应用跑起来，得先去 Tomcat 官网下载安装包，在服务器或者本地机器上解压、配置，像设置端口号、虚拟主机这些，一堆事儿。部署应用的时候，得把打包好的 WAR 文件小心翼翼地放到 Tomcat 的 webapps 目录下，要是不小心放错地方，或者 WAR 文件有点问题，应用就启动不起来，还得费劲排查。而且每次修改代码后，都得重复打包、重新部署的过程，耗时又耗力，开发效率大打折扣，就像出门旅游，拖着个又大又沉的行李箱，走哪儿都不方便。

（二）内嵌 Tomcat 带来的 “曙光”

内嵌 Tomcat 就像是一个贴心的小助手，把这些麻烦事儿都简化了。它直接集成在咱们的 Java 项目里，不需要额外安装外部 Tomcat。咱们写好代码，一键启动项目，内嵌 Tomcat 就自动运行起来，接收客户端请求，处理后返回结果，整个过程行云流水。比如说，咱们在开发一个小型的企业内部管理系统，用内嵌 Tomcat，开发人员在自己电脑上就能快速测试功能，修改代码即时生效，不用来回折腾部署，就像出门背个轻便的双肩包，想去哪儿探索就去哪儿，轻松自在，大大提高了开发效率，让咱们能更快地把项目推向市场。

二、初识内嵌 Tomcat：核心概念全知晓

（一）什么是内嵌 Tomcat

简单来说，内嵌 Tomcat 就是将 Tomcat 服务器以一种特殊的方式嵌入到咱们的 Java 项目中，成为项目的一部分，而不是作为一个外部独立的服务器存在。它利用 Tomcat 的核心功能，在项目启动时，自动启动一个 Web 服务器实例，监听指定的端口，等待客户端请求。这个内嵌的 Tomcat 和咱们平常使用的外部 Tomcat 在功能上基本一致，都能处理 HTTP 请求、加载 Servlet、运行 JSP 页面等，只是它的运行方式更加灵活、便捷，专为快速开发和测试场景量身打造。

（二）内嵌 Tomcat 的工作原理

当咱们在项目中引入内嵌 Tomcat 相关的库后，项目启动过程中，会触发一系列初始化操作。首先，它会根据咱们在代码里或者配置文件中的设置，创建一个 Tomcat 容器实例，配置好端口号、上下文路径等基本参数，就像搭建一个小型舞台，准备好演出的场地。接着，它会扫描项目中的 Servlet、JSP 等 Web 组件，把它们加载到容器中，就像演员们陆续上台就位。一旦项目启动完成，内嵌 Tomcat 就开始监听端口，当客户端（比如浏览器）发送 HTTP 请求时，它按照既定的规则，将请求路由到对应的 Servlet 或其他 Web 组件进行处理，处理完后再把结果返回给客户端，整个过程就像一场精彩的舞台剧，各个环节紧密配合，为观众（用户）呈现完美的演出。

三、在 Spring Boot 中玩转内嵌 Tomcat：实战开启

（一）Spring Boot 与内嵌 Tomcat 的完美邂逅

Spring Boot 可是内嵌 Tomcat 的 “黄金搭档”。Spring Boot 遵循 “约定大于配置” 的原则，默认就集成了内嵌 Tomcat，这简直是为咱们开发者打开了一扇便捷之门。咱们只需要创建一个 Spring Boot 项目，引入 Web 相关的起步依赖，比如 “spring-boot-starter-web”，Spring Boot 在背后就自动把内嵌 Tomcat 配置得妥妥当当，连端口号都帮咱们设好了默认值 8080，咱们几乎不用操心任何和 Tomcat 相关的复杂配置，就能快速启动一个 Web 应用，专注于业务逻辑的编写，就像拥有了一个智能管家，把生活琐事都安排得井井有条，咱们只管享受安逸的生活。

（二）创建 Spring Boot + 内嵌 Tomcat 项目

我们一般都是用这个，现在谁还不用springboot

在咱们常用的开发工具，比如 Intellij IDEA 里，创建 Spring Boot 项目简单得很。打开 IDEA，点击 “File” 菜单，选择 “New”->“Project”，在弹出的窗口里找到 “Spring Initializr”，这可是咱们创建 Spring Boot 项目的 “魔法入口”。填好项目的基本信息，像 “Group”（一般是公司或者组织的反向域名，比如 com.example）、“Artifact”（项目名字，自己取一个就行，比如 my-web-app）、“Version”（初始版本号，一般从 1.0.0 开始），接着在 “Dependencies” 选项卡里，勾选 “Spring Web”，这一步至关重要，勾选它就相当于给咱们的项目装上了 Web 开发的 “引擎”，同时也自动引入了内嵌 Tomcat。然后点击 “Finish”，IDEA 就会帮咱们生成一个 Spring Boot 项目骨架，里面已经包含了内嵌 Tomcat，咱们只需要在这个基础上添砖加瓦，编写业务代码就行。

四、深入探究 Spring Boot 内嵌 Tomcat 的配置：掌控细节

（一）基础配置调整

虽说 Spring Boot 帮咱们做了大部分默认配置，但有时候咱们还是得根据项目需求微调一下。比如说，咱们想修改项目运行的端口号，在 Spring Boot 项目里，只需要在 application.properties 或者 application.yml 文件里添加一行配置就行。如果用 application.properties：

server.port=8081

要是用 application.yml：

server:
  port: 8081

就这么简单，把默认的 8080 端口改成了 8081，是不是超级方便？咱们还可以配置上下文路径，同样在配置文件里，像这样：

server.servlet.context-path=/my-app

server:
  servlet:
    context-path: /my-app

这就意味着咱们的 Web 应用访问路径变成了 “http://localhost:8081/my-app”，通过这些基础配置的调整，咱们能让项目更加贴合实际需求，就像给房子装修，根据自己的喜好调整布局和风格。

（二）高级配置玩法

这里就不那么重要了，作为扩展。

1. 自定义 Tomcat 连接器
   有时候，咱们项目对性能、连接处理有特殊要求，就得深入到 Tomcat 的连接器配置了。在 Spring Boot 里，咱们可以通过创建一个自定义的 TomcatServletWebServerFactory bean 来实现。比如说，咱们想调整连接超时时间和最大线程数，代码如下：

import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TomcatConfig {
    @Bean
    public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
        factory.setConnectionTimeout(5000);
        factory.setMaxThreads(200);
        return factory;
    }
}

这里咱们创建了一个配置类，定义了一个 TomcatServletWebServerFactory 类型的 bean，设置连接超时时间为 5000 毫秒，最大线程数为 200，这样就能根据项目的并发情况优化连接处理，让咱们的 Web 应用在高并发场景下也能稳定运行，就像给汽车发动机调校，提升性能。
2. 配置 SSL 加密
要是咱们的 Web 应用需要安全传输，也就是使用 SSL 加密，Spring Boot 也能轻松搞定。首先，咱们得有 SSL 证书，可以自己生成，也可以从证书颁发机构获取。假设咱们已经有了证书文件和私钥文件，在 application.yml 文件里配置如下：

server:
  ssl:
    enabled: true
    key-store-type: PKCS12
    key-store: classpath:keystore.p12
    key-store-password: your-password
    key-alias: your-alias

这里指定了启用 SSL，证书类型是 PKCS12，证书文件路径（这里是放在 classpath 下的 keystore.p12），证书密码和别名，通过这些配置，咱们的 Web 应用就能以安全加密的方式传输数据，就像给信件套上信封，贴上邮票，确保信息安全送达，让用户放心使用。

五、基于内嵌 Tomcat 开发 Servlet：经典回归

（一）编写简单的 Servlet

虽说现在有很多高级的 Web 开发框架，但 Servlet 作为 Java Web 开发的基石，依然有着不可替代的作用。在内嵌 Tomcat 的项目里编写 Servlet 也很简单。首先，咱们创建一个 Java 类，继承 HttpServlet，比如：

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html><body><h1>Hello, Embedded Tomcat!</h1></body></html>");
    }
}

这里咱们创建了一个 HelloServlet，在 doGet 方法里，设置响应的内容类型为 HTML，然后向客户端输出一个简单的 HTML 页面，显示 “Hello, Embedded Tomcat!”，就像在网页上挂出一个欢迎标语，向世界宣告咱们的存在。

（二）注册与映射 Servlet

编写好 Servlet 后，咱们得让内嵌 Tomcat 知道它的存在，也就是要进行注册和映射。在 Spring Boot 里，咱们可以通过两种方式。一种是使用注解，在 Servlet 类上加上 “@WebServlet” 注解，像这样：

import javax.servlet.annotation.WebServlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html><body><h1>Hello, Embedded Tomcat!</h1></body></html>");
    }
}

这里的 “@WebServlet ("/hello")” 表示这个 Servlet 映射到 “/hello” 路径，当客户端访问 “http://localhost:8080/hello”（假设端口是 8080）时，就会调用这个 Servlet。另一种方式是通过配置类，创建一个 ServletRegistrationBean，代码如下：

import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ServletConfig {
    @Bean
    public ServletRegistrationBean<HelloServlet> helloServletRegistrationBean() {
        ServletRegistrationBean<HelloServlet> registrationBean = new ServletRegistrationBean<>(new HelloServlet());
        registrationBean.addUrlMappings("/hello");
        return registrationBean;
    }
}

这种方式更加灵活，适用于一些复杂的场景，通过这两种方式，咱们就能让 Servlet 在内嵌 Tomcat 中发挥作用，处理各种业务逻辑，就像给工厂安排工人，让他们在各自的岗位上发光发热。

六、内嵌 Tomcat 与 JSP 协同作战：动态页面的魅力

（一）引入 JSP 支持

在一些项目里，咱们需要动态生成 HTML 页面，这时候 JSP 就派上用场了。虽说现在有一些替代技术，但 JSP 依然有着广泛的应用。要在内嵌 Tomcat 的 Spring Boot 项目里引入 JSP 支持，首先得在 pom.xml 文件里添加相关依赖：

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <version>9.0.46</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</code:version>
    <version>2.3.3</version>
</dependency>

这些依赖分别引入了 Tomcat 对 JSP 的解析引擎、Servlet API 和 JSP API，是让 JSP 正常工作的必备条件，就像给厨师配备齐全的调料，才能做出美味佳肴。

（二）编写与运行 JSP 页面

引入依赖后，咱们就可以编写 JSP 页面了。在项目的 “src/main/resources” 目录下，创建一个 “WEB-INF/jsp” 目录（这是 Tomcat 识别 JSP 页面的默认目录结构），然后在里面创建一个简单的 JSP 页面，比如 “hello.jsp”：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello JSP</title>
</head>
<body>
    <h1>Hello, from JSP with Embedded Tomcat!</h1>
</body>
</html>

接着，咱们需要创建一个 Servlet 或者使用 Spring MVC 的控制器来转发请求到这个 JSP 页面。假设咱们用 Servlet，代码如下：

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/jsp-hello")
public class JspHelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(request, response);
    }
}

这里咱们创建了一个 JspHelloServlet，在 doGet 方法里，使用 “getRequestDispatcher” 方法将请求转发到 “/WEB-INF/jsp/hello.jsp” 页面，当客户端访问 “http://localhost:8080/jsp-hello” 时，就会看到由 JSP 生成的动态页面，展示 “Hello, from JSP with Embedded Tomcat!”，就像魔术师变出精彩的魔术，给用户带来惊喜，让 Web 应用更加丰富多彩。

七、内嵌 Tomcat 的性能优化：让你的应用 “飞” 起来

（一）JVM 调优

内嵌 Tomcat 运行在 Java 虚拟机（JVM）上，合理调整 JVM 参数能显著提升性能。在项目启动时，咱们可以通过设置一些环境变量来调整 JVM 参数。比如说，增加内存分配，防止 Tomcat 因为内存不足而卡顿，在启动命令里添加：

java -Xms512m -Xmx1024m -jar your-app.jar

这表示给项目初始分配 512MB 内存，最大可用 1024MB 内存，你可以根据实际情况，比如项目的复杂程度、并发量，调整这些数值，让内存利用达到最优，就像给汽车发动机加足油，让它动力十足，跑得更快。

（二）优化 Tomcat 自身配置

除了 JVM 调优，咱们还可以直接优化 Tomcat 的配置。前面咱们提到过自定义 Tomcat 连接器，通过调整连接超时时间、最大线程数等参数来优化性能。另外，咱们还可以优化 Tomcat 的缓存机制。比如说，对于一些静态资源，咱们可以设置更长的缓存过期时间，减少重复加载，在 Spring Boot 里，可以通过配置类来实现：

import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.unit.DataSize;

@Configuration
public class TomcatCacheConfig {
    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory> tomcatServletWebServerFactoryCustomizer() {
        return factory -> {
            factory.addContextCustomizers(context -> {
                context.setSessionTimeout(30, TimeUnit.MINUTES);
                context.getServletContext().setAttribute(
                        ServletContextResource.ResourceCache.getResourceCacheName(),
                        new ServletContextResource.ResourceCache(
                                DataSize.ofMegabytes(5),
                                DataSize.ofMegabytes(10),
                                TimeUnit.MINUTES,
                                TimeUnit.MINUTES
                        )
                );
            });
        };
    }
}

这里咱们设置了会话超时时间为 30 分钟，并且配置了一个资源缓存，缓存大小为 5MB 到 10MB，缓存过期时间为 30 分钟，通过这些优化，让内嵌 Tomcat 运行得更加高效，为用户提供更快的访问速度，就像给高速公路升级，让车辆行驶更加顺畅。