06.2.2.2 启动流程与内嵌容器
所属:全栈开发面试题库 / 06 后端框架与工程实践 / 06.2 Java Spring 生态 / 06.2.2 Spring Boot
本节要解决的问题
- 从
SpringApplication.run到应用就绪,中间经过哪些阶段,各阶段做什么? - 内嵌 Web 容器在哪一步创建、如何启动、参数从哪里来?
- 可执行 jar 凭什么能
java -jar运行,虚拟线程、懒加载、分层镜像如何影响启动?
版本前提:Spring Boot 3.x / Java 17+;虚拟线程能力要求 Boot 3.2+ / JDK 21。
06.2.2.2-001 Spring Boot 的启动流程是怎样的?
一句话结论
SpringApplication.run 依次完成:推断应用类型与加载监听器 → 准备环境 → 创建上下文 → 准备上下文 → 刷新容器(创建内嵌容器、实例化单例)→ 执行 Runner → 发布就绪事件。
概念解释
启动分「准备阶段」和「容器刷新阶段」两段:准备阶段搭建环境与上下文,刷新阶段复用 Spring AbstractApplicationContext#refresh 完成 Bean 装配,最后由 Runner 做启动后业务初始化。
原理流程
- 创建
SpringApplication:推断应用类型(Servlet / Reactive / None),加载ApplicationContextInitializer与ApplicationListener。 prepareEnvironment:创建Environment,发布ApplicationEnvironmentPreparedEvent;ConfigDataEnvironmentPostProcessor在此加载配置文件。createApplicationContext:按 Web 类型反射创建AnnotationConfigServletWebServerApplicationContext等上下文。prepareContext:设置环境、注册主配置类、应用初始化器与监听器、打印 Banner。refreshContext:调用refresh:invokeBeanFactoryPostProcessors:解析@Configuration、@ComponentScan、自动配置;registerBeanPostProcessors:注册 AOP、事务、注解处理器;onRefresh:创建内嵌 Web 容器;finishBeanFactoryInitialization:实例化所有非懒加载单例;finishRefresh:启动容器、发布ContextRefreshedEvent。
afterRefresh:callRunners执行ApplicationRunner/CommandLineRunner。- 发布
ApplicationReadyEvent;启动失败发布ApplicationFailedEvent。
示例
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
return new SpringApplication(primarySource).run(args);
}
常见误区
- 认为 Tomcat 在
main第一行就启动:实际在刷新阶段的onRefresh创建、finishRefresh才真正监听端口。 - 把启动后初始化写进构造器:应放在 Runner 或
ApplicationReadyEvent监听中,避免容器未就绪就访问依赖。
追问
ApplicationRunner与CommandLineRunner区别?前者参数是ApplicationArguments(含选项参数解析),后者是原始String[];都可用@Order排序。- 启动异常如何定位?
ApplicationFailedEvent与FailureAnalyzers会打印结构化失败报告。
06.2.2.2-002 内嵌 Tomcat 是怎么启动的?
一句话结论
ServletWebServerApplicationContext#onRefresh 通过 ServletWebServerFactory 创建 Web 容器并注册为 Bean;finishRefresh 阶段由 WebServerStartStopLifecycle 调用 start() 真正监听端口。
概念解释
内嵌容器不是独立进程,而是上下文创建的一个组件。工厂 Bean 默认是 TomcatServletWebServerFactory,由 ServletWebServerFactoryAutoConfiguration 注册;Connector、线程池、连接数等参数来自 server.tomcat.* 配置。
原理流程
onRefresh调用createWebServer()。- 从容器取
ServletWebServerFactory,getWebServer(...)创建Tomcat,设置 Connector、Context、Servlet 与 Filter。 WebServer注册为 Bean,并注册WebServerStartStopLifecycle。- 容器刷新完成时,生命周期接口
start调用webServer.start(),Tomcat 绑定端口。
示例
server:
port: 8080
tomcat:
threads:
max: 200
min-spare: 10
max-connections: 8192
accept-count: 100
connection-timeout: 20s
常见误区
- 把
max-connections当成工作线程数:连接数上限与工作线程池上限是两个维度,前者排队连接,后者处理请求。 - 认为内嵌 Tomcat 与独立 Tomcat 行为完全一致:连接器与默认参数有差异,生产压测要按实际配置验证。
追问
- 如何替换容器?排除
spring-boot-starter-tomcat,引入spring-boot-starter-jetty或spring-boot-starter-undertow。 - NIO 与 APR 区别?NIO 基于 Java NIO;APR 依赖本地库,现代版本默认 NIO,APR 场景需单独配置。
06.2.2.2-003 Spring Boot 可执行 jar 的结构是什么?为什么能 java -jar 运行?
一句话结论
jar 内分 BOOT-INF/classes(应用类与资源)、BOOT-INF/lib(嵌套依赖 jar)和 loader 目录;JarLauncher 创建自定义类加载器加载嵌套 jar,再反射调用 Start-Class 的 main。
概念解释
普通 java -jar 只能从 jar 根目录加载类,无法直接读取嵌套在 BOOT-INF/lib 里的 jar。Boot 提供 JarLauncher 作为 Main-Class,它构造 LaunchedClassLoader 把嵌套 jar 加入类路径,再加载业务主类。
示例
app.jar
├── META-INF/
│ └── MANIFEST.MF
│ Main-Class: org.springframework.boot.loader.JarLauncher
│ Start-Class: com.example.Application
├── BOOT-INF/
│ ├── classes/ # 应用类与 resources
│ └── lib/ # 依赖 jar
└── org/springframework/boot/loader/ # loader 自身
常见误区
- 把依赖 jar 放到 jar 根目录:约定位置是
BOOT-INF/lib,自定义类加载器只扫描该目录。 - 直接解压 jar 后用普通类路径运行:loader 对嵌套结构有假设,解压运行需自行组织 classpath。
追问
Main-Class与Start-Class为什么分开?loader 必须先启动才能加载业务类,Start-Class是 loader 反射调用的真正入口。- 分层 jar 有什么用?把依赖、快照、应用类分目录,配合 Docker 层缓存减少镜像推送体积。
06.2.2.2-004 devtools 热部署的原理和局限是什么?
一句话结论
devtools 用双类加载器:base 加载不变依赖,restart 加载应用类;classpath 变化时重建 restart 类加载器实现快速重启,不是字节码级热替换。
概念解释
重启类加载器只装业务代码,重建成本远低于冷启动;依赖类留在 base 类加载器中复用。静态状态、连接池、本地缓存在重启后都会丢失,因此只适合开发环境。
示例
spring:
devtools:
restart:
enabled: true
trigger-file: .reload-trigger # 手动触发,避免频繁重启
livereload:
enabled: true
常见误区
- 把 devtools 当成 JRebel:前者重建类加载器,后者做字节码热替换,能力不同。
- 生产保留 devtools:会带来性能与安全风险,打包后 restart 自动禁用,但仍应排除依赖。
追问
- 为什么生产要排除 devtools?避免不必要的重启监听、livereload 端口与类加载器开销。
- 静态修改如何生效?资源变化触发 livereload 浏览器刷新;类变化触发 restart。
06.2.2.2-005 虚拟线程怎么开启?有哪些坑?
一句话结论
Boot 3.2+ 配置 spring.threads.virtual.enabled=true 后,Tomcat 请求处理与 @Async 默认执行器切换为虚拟线程;适合 I/O 密集型阻塞代码,需警惕 pinning、ThreadLocal 泛滥、连接池上限与 native 方法钉住载体线程。
概念解释
虚拟线程由 JVM 调度到载体平台线程上,阻塞时让出载体线程,从而以很小成本承载大量并发任务。但 synchronized 块内阻塞、JNI/native 调用、过量 ThreadLocal 会削弱收益;数据库连接数仍是物理瓶颈。
示例
spring:
threads:
virtual:
enabled: true
// 不推荐:synchronized 块内阻塞会钉住载体线程
synchronized (lock) { jdbcTemplate.query(...); }
// 推荐:ReentrantLock 不 pin
lock.lock();
try { jdbcTemplate.query(...); } finally { lock.unlock(); }
常见误区
- 认为开了虚拟线程就能无限并发:数据库连接池、下游限流、锁竞争仍是上限,虚拟线程不增加物理资源。
- 忽略
synchronizedpinning:JDK 21 中块内阻塞会钉住载体线程;JDK 24(JEP 491)已大幅缓解,升级前需评估,临界区改用ReentrantLock。
追问
- 虚拟线程要池化吗?不要,虚拟线程用完即弃;平台线程才需要线程池。
- 怎么观测 pinning?启动参数
-Djdk.tracePinnedThreads=full打印钉住栈。 - 为什么连接池不能按虚拟线程数量配置?物理数据库连接有限,过大会拖垮数据库。
06.2.2.2-006 SpringApplication 如何推断 Web 应用类型?
一句话结论
按 classpath 上的关键类推断:存在 Servlet Web 栈且无 WebFlux 为 SERVLET;存在 WebFlux 且无 Servlet MVC 为 REACTIVE;都没有为 NONE;可显式覆盖。
概念解释
类型决定创建哪种 ApplicationContext 与是否启动 Web 容器。推断规则读取类路径标记,避免两种 Web 栈同时生效时歧义。
示例
SpringApplication app = new SpringApplication(Application.class);
app.setWebApplicationType(WebApplicationType.REACTIVE);
app.run(args);
常见误区
- 同时引入 spring-webmvc 与 spring-webflux:推断结果取决于依赖组合,应按需排除,不要靠默认猜测。
- 命令行应用意外启动 Web 容器:引入 Web starter 后类型变为 SERVLET,非 Web 任务要排除 Web 依赖。
追问
- 类型为 NONE 时会注册 Web Bean 吗?不会,Web 条件自动配置不生效。
- 推断依据哪些类?Servlet 栈标记
javax.servlet/jakarta.servlet与 DispatcherServlet;Reactive 标记DispatcherHandler。
06.2.2.2-007 ApplicationRunner 与 CommandLineRunner 有什么区别?
一句话结论
两者都在容器刷新完成后执行启动后逻辑;ApplicationRunner 接收封装好的 ApplicationArguments,CommandLineRunner 接收原始参数数组,可用 @Order 控制顺序。
概念解释
Runner 是启动收尾阶段的扩展点,此时单例已就绪、容器可对外提供依赖。需要解析命令行选项(--key=value)用 ApplicationRunner;只需原始参数用 CommandLineRunner。
示例
@Component
@Order(1)
public class InitRunner implements ApplicationRunner {
@Override
public void run(ApplicationArguments args) {
// 预热缓存、加载字典等
}
}
常见误区
- 在 Runner 里做长耗时阻塞任务:会推迟
ApplicationReadyEvent,就绪探针长期未通过;重任务应异步化。 - 多个 Runner 不声明顺序:执行顺序不确定,有依赖关系时必须
@Order。
追问
- Runner 抛异常会怎样?启动失败,发布
ApplicationFailedEvent,进程退出码非零。 - 与
@PostConstruct区别?@PostConstruct在 Bean 初始化阶段执行,依赖尚未完全就绪;Runner 在容器刷新完成后执行。
06.2.2.2-008 启动过程中的关键事件分别在什么时机发布?
一句话结论
ApplicationEnvironmentPreparedEvent(环境就绪)→ ContextRefreshedEvent(容器刷新完成)→ ApplicationStartedEvent(容器就绪但 Runner 未执行)→ ApplicationReadyEvent(Runner 完成、应用可服务)→ 失败时 ApplicationFailedEvent。
概念解释
事件是各阶段的扩展挂点:监听环境事件可早期调整配置;监听就绪事件做上线后动作;Started 与 Ready 的区别在于 Runner 是否已执行。
对比
| 事件 | 时机 | 典型用途 |
|---|---|---|
ApplicationEnvironmentPreparedEvent |
Environment 创建后 | 早期配置加载、环境变量注入 |
ContextRefreshedEvent |
容器刷新完成 | 通用容器就绪回调 |
ApplicationStartedEvent |
刷新完成、Runner 前 | 启动指标打点 |
ApplicationReadyEvent |
Runner 执行完毕 | 注册中心上线、预热完成 |
ApplicationFailedEvent |
任一步骤失败 | 失败告警、资源清理 |
常见误区
- 在
ContextRefreshedEvent里访问尚未初始化的懒加载 Bean:懒加载单例此时可能不存在。 - 把上线动作放到 Started:Runner 还没跑,就绪状态不完整,应放 Ready。
追问
- 监听器如何注册?
spring.factories/ imports 机制,或容器中的ApplicationListenerBean。 - 事件是同步还是异步发布?默认同步发布,监听器阻塞启动流程。
06.2.2.2-009 如何替换内嵌 Web 容器?
一句话结论
排除默认 Tomcat starter,引入 Jetty 或 Undertow 的 starter;自动配置按 classpath 上的容器工厂选择对应实现,业务代码基本无感。
概念解释
ServletWebServerFactoryAutoConfiguration 提供各容器的工厂配置,类路径出现哪套容器就装配哪套。替换容器后连接器参数名随容器而异,压测与配置需重新核对。
示例
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
常见误区
- 保留 Tomcat 依赖又引 Undertow:两套容器类路径并存,工厂选择出现歧义。
- 直接复制 Tomcat 线程参数到 Undertow:参数前缀与模型不同,不能照搬。
追问
- Reactive 应用用什么容器?Reactive 栈默认 Netty,可按 starter 配置替换。
- 替换容器影响内嵌部署形态吗?不影响,仍是可执行 jar。
06.2.2.2-010 Tomcat 线程池与连接参数如何理解?
一句话结论
threads.max 是工作线程上限,max-connections 是同时可接受的连接数,accept-count 是连接满后操作系统队列长度;三者配合决定并发承载与排队行为。
概念解释
Tomcat 连接器分层:连接先到 OS 队列(accept-count),进入容器后受 max-connections 约束,请求交给工作线程池处理;线程都忙碌时连接在容器侧排队。
对比
| 参数 | 含义 | 调大的代价 |
|---|---|---|
threads.max |
最大工作线程 | 上下文切换、内存上升 |
threads.min-spare |
常驻最小线程 | 空闲内存占用 |
max-connections |
并发连接上限 | 文件描述符与内存 |
accept-count |
排队连接数 | 排队等待,不提升吞吐 |
常见误区
- 线程数设成上千:I/O 阻塞场景下过大线程数增加切换成本,吞吐反而下降。
- 以为 accept-count 能提升处理能力:它只排等待队列,不增加处理线程。
追问
- 阻塞型业务线程池怎么定?按 CPU、I/O 等待比例与下游容量压测确定,不要照搬默认值。
- 连接超时配置项?
connection-timeout限定连接建立与请求读取等待时间。
06.2.2.2-011 Banner 如何自定义与关闭?
一句话结论
默认读取 banner.txt 与 banner.gif/png 资源;可通过 SpringApplication.setBanner 编程定制,配置 spring.main.banner-mode=off 关闭。
概念解释
Banner 在 prepareContext 阶段打印,支持占位符变量(版本号、应用名)。容器化部署通常关闭或精简,避免日志噪音。
示例
spring:
main:
banner-mode: off # console | log | off
# banner.txt
${application.title} :: v${application.version:unknown}
常见误区
- 把大尺寸图片当 banner:编码与日志可读性差,生产建议文本或关闭。
- 误以为 banner 在容器刷新后打印:发生在准备上下文阶段,早于 Bean 装配。
追问
- 编程式 Banner 接口?
Banner接口的printBanner方法,可按环境差异化输出。 - 版本号从哪里取?
build-info生成的META-INF/build.properties或属性占位符。
06.2.2.2-012 懒加载 spring.main.lazy-initialization 有什么副作用?
一句话结论
开启后非必需 Bean 首次被请求时才初始化,启动更快、内存占用更低;但首次请求变慢,启动期错误延后暴露,基础设施问题不能在上线前发现。
概念解释
懒加载把单例初始化从启动阶段推迟到首次使用。对 Web 应用,Controller 关联的服务与依赖在首个请求触发装配;定时任务、事件监听等非 Web 触发点可能长期不初始化。
示例
spring:
main:
lazy-initialization: true
常见误区
- 全量开启后以为启动稳定:配置错误、Bean 缺失只在首个相关请求才暴露,违背「快速失败」原则。
- 忽略后台任务 Bean:
@Scheduled、消息监听容器可能因懒加载不按预期启动。
追问
- 能否对单个 Bean 关闭懒加载?
@Lazy(false)或在配置中按类型排除。 - 启动慢但首请求敏感的场景怎么选?关键链路 Bean 保持 eager,非核心功能懒加载。
06.2.2.2-013 分层 jar 与 Docker 镜像缓存怎么配合?
一句话结论
分层 jar 把依赖层、快照层、应用类层分开;Dockerfile 先复制依赖层再复制应用类层,代码变更只失效应用层,利用镜像层缓存减小构建与推送体积。
概念解释
spring-boot-maven-plugin 的 layers 按内容变化频率分组:第三方依赖最稳定,应用类变化最频繁。镜像构建顺序与层顺序一致,才能命中缓存。
示例
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<layers><enabled>true</enabled></layers>
</configuration>
</plugin>
常见误区
- 应用类层放在依赖层之前:代码一改依赖层缓存也失效,分层失去意义。
- 把配置打进应用层又频繁变更配置:镜像层缓存命中率下降,配置应外置。
追问
- 如何解压分层 jar?Boot 3.3+:
java -Djarmode=tools -jar app.jar extract;旧版用layertools模式。 - 层清单在哪定义?
layers.xml可自定义分层规则。
06.2.2.2-014 嵌套 jar 的类加载器是如何工作的?
一句话结论
JarLauncher 启动后构造 LaunchedClassLoader,以 BOOT-INF/classes 为应用类路径、BOOT-INF/lib/*.jar 为类库路径,父加载器为系统类加载器,再反射调用 Start-Class#main。
概念解释
隔离的类加载器保证应用类与 loader 类分离,支持嵌套 jar 资源读取;类加载委托遵循父委托模型,应用类优先从 BOOT-INF/classes 加载。
示例
LaunchedClassLoader
├─ BOOT-INF/classes/ 应用类
├─ BOOT-INF/lib/*.jar 依赖
└─ parent: 系统类加载器(loader 自身)
常见误区
- 依赖 jar 内的 SPI 服务找不到:嵌套加载器对
META-INF/services的读取有约定,自定义 SPI 需放在可见位置。 - 用普通 URLClassLoader 替换:会丢失嵌套 jar 协议与资源定位能力。
追问
- 热部署双类加载器与这个加载器关系?devtools 在重启场景下再叠一层 restart 类加载器。
- 类加载冲突怎么排查?打印类加载来源
class.getProtectionDomain().getCodeSource()。
06.2.2.2-015 启动失败时 FailureAnalyzer 报告能提供什么信息?
一句话结论
关键启动异常被对应 FailureAnalyzer 捕获,输出结构化报告:失败原因、触发条件、建议修复动作,而不是裸堆栈;常见于端口占用、缺少 Bean、配置绑定失败。
概念解释
分析器按异常类型匹配(如 PortInUseException、NoSuchBeanDefinitionException、BindException),把底层异常翻译成可读结论与修复提示。ApplicationFailedEvent 在分析后发布。
示例
***************************
APPLICATION FAILED TO START
***************************
Description:
Port 8080 was already in use.
Action:
Identify and stop the process that's listening on port 8080 or configure this service...
常见误区
- 只看堆栈顶部:分析器的 Description/Action 才是直接结论,堆栈用于定位触发链。
- 自定义异常不提供分析器:日志仍是裸堆栈,可实现
FailureAnalyzer补充报告。
追问
- 如何注册自定义分析器?
META-INF/spring.factories中声明FailureAnalyzer实现。 - 分析器能阻止退出吗?不能,只负责诊断;进程仍按失败退出。
06.2.2.2-016 启动类放置位置与组件扫描范围有什么关系?
一句话结论
@ComponentScan 默认扫描启动类所在包及其子包;启动类应放在最外层基础包,业务包都在其子树内,否则组件、配置类扫描不到。
概念解释
扫描起点是主配置类所在包。包结构与代码组织不一致时,外层包的组件不会被扫描,自动配置仍可生效,但业务 Bean 缺失。
示例
com.example.app.Application ← 启动类放这里
com.example.app.order.service.* ← 子包,可扫描
com.example.common.* ← 外层包,扫不到
常见误区
- 启动类放
com.example.app.order:其他业务模块包不在子树,漏扫。 - 用
@ComponentScan("com")兜底:扫描过宽,启动慢且可能误装配,应明确包路径。
追问
- 如何显式指定扫描包?
@SpringBootApplication(scanBasePackages = "...")或@ComponentScan。 - 扫描不到但自动配置正常属于什么问题?业务包路径问题,不是 starter 问题。
06.2.2.2-017 AOT 与 CDS 对启动速度有什么作用?
一句话结论
AOT 在构建期生成 BeanDefinition 与代理、减少运行期反射;CDS 共享类归档预热类加载元数据;两者都压缩启动期准备时间,适合冷启动敏感的场景。
概念解释
AOT( Ahead-of-Time )由 Boot 3 的 spring-aot 插件在构建阶段处理应用,产出可被 GraalVM Native 或 JVM 直接使用的优化产物;CDS 把类元数据归档复用,缩短类加载与验证时间。
示例
# 构建期 AOT 处理
mvn -Pnative package
# CDS 归档(Boot 3.3+ 支持训练与使用)
java -XX:SharedArchiveFile=app.jsa -jar app.jar
常见误区
- 以为 AOT 等于原生镜像:AOT 产物也可在 JVM 上运行;Native Image 是另一套编译与反射约束。
- 忽略反射/动态代理配置:Native 场景下未登记的反射访问会运行期失败。
追问
- 启动慢首选哪类手段?先消除扫描过大、同步初始化、网络等待等运行期问题,再考虑 AOT/CDS。
- AOT 对开发体验的影响?构建产物固化,改代码需重新生成,开发环境通常仍用 JIT 模式。
06.2.2.2-018 可执行 war 与外部容器部署是什么形态?
一句话结论
war 包可部署到外部 Tomcat/Jetty,也能 java -jar 运行内嵌容器;需要继承 SpringBootServletInitializer 并重写 configure,适配外部容器的 Servlet 启动流程。
概念解释
外部容器通过 Servlet 3.0+ 的 ServletContainerInitializer 机制引导 Spring 应用;SpringBootServletInitializer 桥接外部容器启动与 SpringApplication 引导。
示例
public class Application extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(Application.class);
}
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
常见误区
- 打 war 仍依赖内嵌容器自动配置:外部部署时要排除内嵌容器依赖,由外部容器提供 Servlet 实现。
- 多应用共享外部容器时忽略类隔离:会话、类加载与端口规划需按容器规范处理。
追问
- 什么场景用 war?统一运维的传统应用服务器、需要同容器部署多个应用。
- Boot 3 下 war 部署注意什么?Servlet API 已迁移
jakarta.*,外部容器版本必须兼容 Jakarta EE。
06.2.2.2-019 容器关闭时 Web 容器与 Bean 的销毁顺序如何?
一句话结论
收到停止信号后,生命周期接口按逆序执行:Web 容器先停止接收新连接并处理在途请求,随后发布上下文关闭事件,Bean 单例按依赖逆序销毁,释放连接池与资源。
概念解释
WebServerStartStopLifecycle 实现生命周期接口,启动时注册、关闭时先停 Web 服务;Bean 销毁由容器的销毁阶段统一管理,@PreDestroy 与 DisposableBean 在此阶段调用。
原理流程
- 容器停止信号进入生命周期关闭流程。
- Web 容器关闭 Connector,拒绝新请求,等待在途请求完成。
- 发布
ContextClosedEvent。 - 销毁单例 Bean:释放线程池、连接池、注销注册。
- JVM 退出。
常见误区
- 在
@PreDestroy里发起远程调用:关闭阶段资源可能已回收,远程注销应提前到停机前钩子。 - 忽略销毁顺序:依赖同一资源的 Bean 销毁顺序不当会抛连接已关闭异常。
追问
- 优雅停机在哪配置?
server.shutdown=graceful配合spring.lifecycle.timeout-per-shutdown-phase。 - 长任务关闭时怎么办?幂等设计 + 队列重新投递,不能依赖进程内等待。
06.2.2.2-020 Reactive 应用的启动流程与 Servlet 有何不同?
一句话结论
Reactive 栈创建 ReactiveWebServerApplicationContext,默认 Netty 作为容器,事件循环模型而非线程池阻塞模型;Bean 装配阶段相同,容器类型与请求处理模型不同。
概念解释
启动的准备、刷新、Runner 阶段一致;差异在应用类型推断、上下文实现、Web 服务器工厂与请求链路(DispatcherHandler 而非 DispatcherServlet)。
对比
| 维度 | Servlet 应用 | Reactive 应用 |
|---|---|---|
| 上下文 | AnnotationConfigServletWebServerApplicationContext |
ReactiveWebServerApplicationContext |
| 默认容器 | Tomcat | Netty |
| 调度模型 | 工作线程池阻塞处理 | 事件循环 + 非阻塞链路 |
| 入口分发 | DispatcherServlet |
DispatcherHandler |
常见误区
- 在 Reactive 链路里用阻塞式 JDBC/REST 调用:会阻塞事件循环线程,破坏响应式模型。
- 两套栈混用却期望统一行为:过滤器、拦截器、参数绑定机制不同,不能照搬 MVC 经验。
追问
- Reactive 应用能否用 Tomcat?可以替换容器工厂,但链路仍是非阻塞模型。
- 如何选择栈?业务以阻塞式 I/O、熟悉 MVC 为主选 Servlet;高并发流式、非阻塞链路选 Reactive。