在 SpringBoot Web 开发中，Servlet 容器是核心基础设施。SpringBoot 提供了两种容器使用方式：嵌入式容器（默认）和外置容器，前者便捷轻量，后者适配传统 Web 场景（如 JSP 开发）。本文将从配置、实战、原理三个维度，完整讲解嵌入式容器的定制、Servlet 三大组件注册，以及外置容器的部署流程与底层逻辑。
一、嵌入式 Servlet 容器（Jar 包方式）
嵌入式容器是 SpringBoot 的默认方式，将 Tomcat/Jetty/Undertow 内置到应用中，打成可执行 Jar 包，通过java -jar即可启动。核心优势是简单、便携，但默认不支持 JSP，精细化定制需额外配置。
1.1 定制 Servlet 容器核心配置
SpringBoot 通过ServerProperties类封装所有容器配置，支持配置文件和编程式两种方式修改，最常用的是配置文件方式。
1.1.1 配置文件定制（application.properties/yml）
直接在配置文件中通过server前缀修改容器参数，覆盖默认值：
# 基础容器配置 server.port=8081 # 服务端口（默认8080） server.context-path=/tx # 应用上下文路径（SpringBoot2.0后推荐server.servlet.context-path） server.tomcat.uri-encoding=UTF-8 # Tomcat URI编码（解决中文乱码） # Tomcat精细化配置（可选） server.tomcat.max-threads=200 # 最大工作线程数 server.tomcat.connection-timeout=20000 # 连接超时时间（毫秒）若使用 YAML 格式，配置更易读：
server: port: 8081 servlet: context-path: /tx tomcat: uri-encoding: UTF-8 max-threads: 200 connection-timeout: 200001.1.2 核心配置说明
server.port：指定访问端口，避免端口冲突；server.context-path：设置访问前缀，配置后访问地址为http://localhost:8081/tx/xxx；server.tomcat.*：Tomcat 专属配置，SpringBoot 对 Jetty/Undertow 也提供了对应的前缀（如server.jetty.*）。
1.2 注册 Servlet 三大组件（无 web.xml）
SpringBoot 以 Jar 包启动时无web.xml文件，需通过@Bean注解将 Servlet、Filter、Listener 注册到容器中。
1.2.1 先定义自定义组件
① 自定义 Servlet
import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; public class MyServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException { resp.setContentType("text/html;charset=UTF-8"); resp.getWriter().write("自定义Servlet响应"); } }② 自定义 Filter
import javax.servlet.*; import java.io.IOException; public class MyFilter implements Filter { @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { System.out.println("MyFilter拦截请求..."); chain.doFilter(request, response); // 放行请求 } }③ 自定义 Listener
import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; public class MyListener implements ServletContextListener { @Override public void contextInitialized(ServletContextEvent sce) { System.out.println("Servlet容器初始化完成"); } @Override public void contextDestroyed(ServletContextEvent sce) { System.out.println("Servlet容器销毁"); } }1.2.2 注册组件到 Spring 容器
创建配置类，通过ServletRegistrationBean、FilterRegistrationBean、ServletListenerRegistrationBean封装组件并注册：
import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.boot.web.servlet.ServletListenerRegistrationBean; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import java.util.Arrays; @Configuration public class WebComponentConfig { // 1. 注册Servlet @Bean public ServletRegistrationBean<MyServlet> myServlet() { ServletRegistrationBean<MyServlet> registrationBean = new ServletRegistrationBean<>( new MyServlet(), "/myServlet"); // 拦截路径 return registrationBean; } // 2. 注册Filter @Bean public FilterRegistrationBean<MyFilter> myFilter() { FilterRegistrationBean<MyFilter> registrationBean = new FilterRegistrationBean<>(); registrationBean.setFilter(new MyFilter()); registrationBean.setUrlPatterns(Arrays.asList("/hello", "/myServlet")); // 拦截路径 return registrationBean; } // 3. 注册Listener @Bean public ServletListenerRegistrationBean<MyListener> myListener() { ServletListenerRegistrationBean<MyListener> registrationBean = new ServletListenerRegistrationBean<>( new MyListener()); return registrationBean; } }1.3 DispatcherServlet 的自动注册
SpringBoot 自动配置 SpringMVC 时，会通过DispatcherServletAutoConfiguration自动注册核心前端控制器DispatcherServlet，核心逻辑如下：
@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME) @ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME) public ServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet) { ServletRegistrationBean registration = new ServletRegistrationBean( dispatcherServlet, this.serverProperties.getServletMapping()); // 默认拦截路径：/ （拦截所有请求，包含静态资源，但不拦截JSP） // /* 会拦截JSP，开发中避免使用 registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME); registration.setLoadOnStartup(this.webMvcProperties.getServlet().getLoadOnStartup()); return registration; }- 默认拦截路径为
/，可通过server.servletPath修改； - 无需手动注册，SpringBoot 自动完成。
二、外置 Servlet 容器（War 包方式）
嵌入式容器虽便捷，但存在默认不支持 JSP、定制复杂等问题。外置容器需独立安装 Tomcat，将应用打成 War 包部署，适配传统 Web 开发场景。
2.1 嵌入式 VS 外置容器对比
| 特性 | 嵌入式容器（Jar） | 外置容器（War） |
|---|---|---|
| 打包方式 | 可执行 Jar 包 | War 包 |
| JSP 支持 | 默认不支持 | 原生支持 |
| 定制难度 | 较高（编程式） | 较低（容器配置） |
| 部署便捷性 | 极高（java -jar） | 需先启动容器 |
| 适用场景 | 微服务、小型应用 | 传统 Web、JSP 开发 |
2.2 外置 Tomcat 部署完整步骤
以 IDEA + Maven 为例，演示从项目创建到部署的全流程：
步骤 1：创建 War 类型项目
- IDEA 新建 SpringBoot 项目时，Packaging 选择 War；
- 若已有 Jar 项目，修改
pom.xml中<packaging>jar</packaging>为<packaging>war</packaging>。
步骤 2：排除嵌入式 Tomcat
将嵌入式 Tomcat 标记为provided（编译时依赖，运行时由外置容器提供），避免冲突：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> <scope>provided</scope> </dependency>步骤 3：编写 SpringBootServletInitializer 子类
外置容器无法执行main方法，需通过此类桥接 SpringBoot 应用：
import org.springframework.boot.builder.SpringApplicationBuilder; import org.springframework.boot.web.servlet.support.SpringBootServletInitializer; public class ServletInitializer extends SpringBootServletInitializer { @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { // 传入SpringBoot主程序类 return application.sources(SpringBoot04WebJspApplication.class); } }步骤 4：规范项目目录结构
War 项目需符合 Java EE 标准结构，核心目录如下：
spring-boot-war-demo/ ├── src/main/java/ # 源码目录 ├── src/main/resources/ # 配置文件目录 └── src/main/webapp/ # Web根目录（Jar项目无此目录） └── WEB-INF/ # 受保护目录 └── jsp/ # JSP页面目录（可选）步骤 5：部署并启动外置 Tomcat
- IDEA 中配置本地 Tomcat：「Add Configuration」→ 「Tomcat Server」→ 「Local」；
- 切换到「Deployment」标签，添加当前项目的 War 包；
- 设置「Application context」（访问前缀），启动 Tomcat 即可。
2.3 启动原理对比
① Jar 包（嵌入式容器）启动流程
执行main方法 → 启动SpringApplication → 创建IOC容器 → 初始化嵌入式Tomcat → 启动容器并提供服务核心：应用主导，SpringBoot 启动时先创建 IOC 容器，再启动容器。
② War 包（外置容器）启动流程
启动外置Tomcat → 扫描webapps目录下的War包 → 触发SpringBootServletInitializer → 加载SpringBoot主类 → 创建IOC容器 → Tomcat提供服务核心：容器主导，Tomcat 启动后，通过SpringBootServletInitializer加载 SpringBoot 应用。
三、总结
核心要点
- 嵌入式容器：
- 配置文件通过
server.*定制端口、上下文路径等参数； - 无 web.xml 时，通过
RegistrationBean注册 Servlet/Filter/Listener； - DispatcherServlet 由 SpringBoot 自动注册，默认拦截
/路径。
- 配置文件通过
- 外置容器：
- 需创建 War 项目，排除嵌入式 Tomcat，编写
SpringBootServletInitializer子类； - 启动逻辑为 “容器主导”，适配 JSP、传统 Web 部署场景。
- 需创建 War 项目，排除嵌入式 Tomcat，编写
- 场景选择：
- 微服务、无 JSP 场景优先用嵌入式容器（Jar 包）；
- 需 JSP、精细化定制容器时用外置容器（War 包）。
通过本文的配置和原理讲解，你可根据实际场景灵活选择 Servlet 容器方式，既享受 SpringBoot 的便捷性，又能适配传统 Web 开发需求。
