Skip to content

3.2-1 Spring Boot 启动流程与内嵌容器 ​

所属:03 主流框架 / 3.2 Spring Boot 分级:A 状态:◐ 初稿 关联:3.1-1、3.1-2、3.1-7、3.2-2、3.2-4、3.2-6、3.2-8、3.2-9

  • 题型:流程 / 原理 / 排障

  • 一句话结论:SpringApplication.run 把启动拆成 准备环境 → 创建 ApplicationContext → prepareContext → refresh → afterRefresh → runners → ready 七段,每一段前后发一个事件(Starting / EnvironmentPrepared / ContextInitialized / Prepared / Started / Ready)。内嵌容器在 refresh 的 onRefresh 里创建(Tomcat/Jetty/Undertow),真正启动并绑定端口在 finishRefresh 的 Lifecycle 阶段(Boot 2.3+);因此“Bean 都初始化完了但端口被占用才报错”是正常现象。Runner 在 ApplicationStartedEvent 之后、ApplicationReadyEvent 之前执行,Runner 慢会直接拖慢 K8s readiness。

  • 分层要点:

    1. 构造 SpringApplication 时就已经做了决策:deduceWebApplicationType 根据 classpath 判断 NONE/SERVLET/REACTIVE(有 WebFlux 且无 MVC → REACTIVE;有 Servlet API → SERVLET);同时从 spring.factories 加载 ApplicationContextInitializer、ApplicationListener,并推断 main 类。
    2. run() 的主干七段:getRunListeners 并发布 ApplicationStartingEvent → prepareEnvironment(创建/配置 Environment,加载配置文件,发 ApplicationEnvironmentPreparedEvent)→ printBanner → createApplicationContext → prepareContext(设置环境、执行 Initializer、加载主配置类、发 ContextInitializedEvent/ApplicationPreparedEvent)→ refreshContext(十二步,3.1-1)→ afterRefresh → started → callRunners → ready。
    3. 环境准备是“配置从哪来”的答案:Boot 2.4+ 用 Config Data API(ConfigDataEnvironmentPostProcessor)加载 application.properties/yml、profile 变体、spring.config.import;EnvironmentPostProcessor 在 ApplicationEnvironmentPreparedEvent 阶段执行,日志系统也是在这一阶段初始化(LoggingApplicationListener)。所以日志级别配置能在 Banner 之前生效。
    4. 创建哪种上下文由 Web 类型决定:SERVLET → AnnotationConfigServletWebServerApplicationContext;REACTIVE → AnnotationConfigReactiveWebServerApplicationContext;NONE → AnnotationConfigApplicationContext。Boot 3 通过 ApplicationContextFactory 抽象,SpringApplication 仍是同一套流程。
    5. 内嵌容器“创建”和“启动”是两件事:ServletWebServerApplicationContext#onRefresh 调 createWebServer(),由 ServletWebServerFactory(如 TomcatServletWebServerFactory)创建 Tomcat 实例、装配 Connector/Context、应用所有 ServletContextInitializer(Filter、Servlet、Listener、DispatcherServlet);此时尚未绑定端口。finishRefresh 里 LifecycleProcessor.onRefresh 启动 WebServerStartStopLifecycle,才真正 webServer.start()。
    6. Runner 与就绪事件:ApplicationRunner/CommandLineRunner 按 @Order 排序执行,异常会导致启动失败并关闭上下文;执行完才发 ApplicationReadyEvent 和 readiness ACCEPTING_TRAFFIC。长耗时 Runner 会推迟就绪,K8s 探针容易判死;预热类逻辑应异步化或改成 SmartLifecycle 的独立阶段。
    7. 关闭是启动的逆过程:shutdown hook(registerShutdownHook 默认 true)或 SIGTERM 触发 context.close() → 发布 ContextClosedEvent → LifecycleProcessor.onClose 停止 Web 容器(server.shutdown=graceful 时先停止接新请求、等存量请求)→ 销毁单例。kill -9 不走这条链。
    8. 启动慢要分段定位:环境加载 → 类扫描/BeanDefinition 注册 → 单例实例化(含 @PostConstruct、AOP 代理)→ Web 容器 → Runner。对应手段是 ApplicationStartup/BufferingApplicationStartup、--debug 条件报告、-verbose:class、JFR、以及排除无用自动配置、懒加载、AOT。
  • 图/流程:

text
SpringApplication.run 主干:
  new SpringApplication(primarySources)
    → deduceWebApplicationType(NONE/SERVLET/REACTIVE)
    → load ApplicationContextInitializer / ApplicationListener

  run(args)
    1. getRunListeners → ApplicationStartingEvent
    2. prepareEnvironment
         → ConfigDataEnvironmentPostProcessor(application.yml / profile / import)
         → EnvironmentPostProcessor
         → ApplicationEnvironmentPreparedEvent
    3. printBanner
    4. createApplicationContext
         → Servlet / Reactive / 普通 上下文
    5. prepareContext
         → setEnvironment / applyInitializers
         → beanDefinitionLoader.load(primarySource)
         → ApplicationContextInitializedEvent
         → ApplicationPreparedEvent
    6. refreshContext
         → context.refresh()(3.1-1 十二步)
            onRefresh          → createWebServer(创建 Tomcat,不绑端口)
            finishRefresh      → Lifecycle 启动 → webServer.start()(绑端口)
    7. afterRefresh(模板方法,默认空)
    8. listeners.started → ApplicationStartedEvent + liveness CORRECT
    9. callRunners → ApplicationRunner / CommandLineRunner
   10. listeners.ready → ApplicationReadyEvent + readiness ACCEPTING_TRAFFIC
text
事件时间线:
  ApplicationStartingEvent
    → ApplicationEnvironmentPreparedEvent
      → ApplicationContextInitializedEvent
        → ApplicationPreparedEvent
          → ContextRefreshedEvent(Spring)
          → ApplicationStartedEvent
            → ApplicationReadyEvent
  失败:ApplicationFailedEvent
text
内嵌容器生命周期:
  onRefresh
    → ServletWebServerFactory.getWebServer(...)
      → new Tomcat()
      → TomcatWebServer 初始化(Connector / Context / ServletContextInitializer)
      → 不启动
  finishRefresh
    → DefaultLifecycleProcessor.onRefresh
      → WebServerStartStopLifecycle.start()
        → TomcatWebServer.start()
          → Connector 绑定端口,开始 accept
      → WebServerInitializedEvent
  close
    → WebServerStartStopLifecycle.stop()
      → graceful:停止 accept,等待存量请求
      → TomcatWebServer.stop()
text
启动耗时拆解:
  环境与配置     → ConfigData / EnvironmentPostProcessor / 日志初始化
  扫描与定义     → @ComponentScan、自动配置条件评估
  单例实例化     → 构造器注入、@PostConstruct、AOP 代理、数据源预热
  Web 容器       → Tomcat 创建 + 启动
  Runner         → ApplicationRunner / CommandLineRunner
  • 版本/源码锚点:

    • org.springframework.boot.SpringApplication:run、prepareEnvironment、createApplicationContext、prepareContext、refreshContext、afterRefresh、callRunners、handleRunFailure。
    • SpringApplicationRunListener / EventPublishingRunListener:把 run 阶段转成 ApplicationEvent。
    • ApplicationContextInitializer、EnvironmentPostProcessor、ApplicationListener、FailureAnalyzer 通过 spring.factories 注册(Boot 3 仍用,自动配置除外)。
    • ServletWebServerApplicationContext#onRefresh/createWebServer、ServletWebServerFactory、TomcatServletWebServerFactory、TomcatWebServer、WebServerStartStopLifecycle、WebServerGracefulShutdownLifecycle。
    • ServletWebServerFactoryAutoConfiguration、WebServerFactoryCustomizerBeanPostProcessor、ServletContextInitializer。
    • Boot 2.3:Web 容器启动从 onRefresh 推迟到 finishRefresh(Lifecycle);新增优雅停机 server.shutdown=graceful。
    • Boot 2.4:Config Data API(spring.config.import、profile groups)、BootstrapContext/BootstrapRegistry。
    • Boot 2.6:ApplicationStartedEvent 同时发布 liveness,ApplicationReadyEvent 发布 readiness。
    • Boot 3.0:ApplicationContextFactory、Jakarta、Java 17;启动流程不变。
    • Boot 3.2:spring.threads.virtual.enabled 虚拟线程;3.2+ 支持 spring-boot-loader 的可执行 jar 结构不变。
    • 打包:spring-boot-maven-plugin repackage → JarLauncher/WarLauncher、LaunchedURLClassLoader、MANIFEST 的 Main-Class/Start-Class。
  • 启动阶段与可扩展点:

阶段关键动作扩展点常见用途
构造推断 Web 类型、加载 initializer/listenerSpringApplication 子类定制默认行为
环境准备加载配置、初始化日志EnvironmentPostProcessor、ApplicationListener<ApplicationEnvironmentPreparedEvent>解密配置、动态属性源
上下文创建选上下文类型、注册主配置类ApplicationContextFactory(Boot 3)自定义上下文
prepareContextInitializer、加载 BeanDefinitionApplicationContextInitializer注册早期 Bean、设 profile
refresh十二步 + 内嵌容器BeanFactoryPostProcessor、BeanPostProcessor、ServletContextInitializer改定义、加 Filter/Servlet
afterRefresh模板方法,默认空子类覆写自定义后处理
started发 ApplicationStartedEventApplicationListener启动埋点
runners执行 RunnerApplicationRunner/CommandLineRunner预热、校验、补偿
ready发 ApplicationReadyEventApplicationListener注册到注册中心、开流量
  • 内嵌容器关键点:
维度说明配置/入口
默认容器Tomcat;也可 Jetty/Undertow排除 spring-boot-starter-tomcat 换 starter
端口绑定时机finishRefresh 的 Lifecycle 阶段Boot 2.3+
端口默认 8080;0 为随机server.port、local.server.port
上下文路径影响所有 Servletserver.servlet.context-path
线程池Tomcat 默认 max 200、accept-count 100server.tomcat.threads.max、server.tomcat.accept-count
最大连接默认 8192server.tomcat.max-connections
优雅停机停止接新请求 + 等待存量server.shutdown=graceful、spring.lifecycle.timeout-per-shutdown-phase
HTTPS证书/密钥库server.ssl.*(Boot 3 用 SSL bundle)
HTTP/2需 TLS 或 h2cserver.http2.enabled
转发头反向代理场景server.forward-headers-strategy
虚拟线程Boot 3.2+spring.threads.virtual.enabled=true
  • 内嵌容器 vs 外置容器:
维度内嵌(jar)外置(war + Tomcat)
启动方式java -jar,main 方法容器启动,SpringBootServletInitializer
部署单元一个可执行 jarwar 包
容器配置代码/server.*server.xml、容器管理
多应用一进程一应用一个 Tomcat 多应用
JSP支持受限(需 war)原生支持
运维镜像友好、版本自控依赖中间件团队
典型场景云原生/容器传统企业部署
  • 启动失败与定位:
现象根因处理
Port already in use端口被占,直到 finishRefresh 才暴露lsof -i:8080、改端口、server.port=0
BeanCreationExceptionBean 初始化/依赖失败看 cause 链和 Bean 名(3.1-2)
配置没生效属性源顺序/profile 写错/actuator/env、--debug
Runner 抛异常导致启动失败Runner 异常会关闭上下文Runner 内自行兜底或改异步
启动成功但 K8s 判死Runner/预热超过 probe 时间异步预热、调 initialDelaySeconds
卡在环境准备远程配置中心超时配超时/降级、spring.cloud.config.fail-fast=false
日志不输出日志配置在环境准备阶段才生效检查 logging.config、banner 前日志
端口起来了但 404context-path/DispatcherServlet 映射检查 server.servlet.context-path
优雅停机无效kill -9、未配 gracefulSIGTERM + server.shutdown=graceful
启动慢扫描大、Bean 多、@PostConstruct 重AOT、懒加载、排除自动配置、异步预热
  • 深挖点(面试官常追的 6 个):

    1. run() 的精确顺序:getRunListeners → ApplicationStartingEvent → prepareEnvironment → ApplicationEnvironmentPreparedEvent → printBanner → createApplicationContext → prepareContext → ApplicationContextInitializedEvent → ApplicationPreparedEvent → refreshContext → afterRefresh → ApplicationStartedEvent → callRunners → ApplicationReadyEvent。任何一步抛异常都会进 handleRunFailure:发布 ApplicationFailedEvent、关闭上下文、交给 SpringBootExceptionHandler 决定退出码。事件顺序是面试高频考点,尤其 “Runner 在 Started 之后、Ready 之前”。
    2. 内嵌 Tomcat 什么时候创建、什么时候启动:ServletWebServerApplicationContext#onRefresh 调 createWebServer(),TomcatServletWebServerFactory#getWebServer 创建 Tomcat、设置 Connector、Context、注册 ServletContextInitializer,返回 TomcatWebServer 但不 start;finishRefresh 里 DefaultLifecycleProcessor 启动 WebServerStartStopLifecycle,才 Tomcat.start() 并绑定端口。Boot 2.3 之前是在 onRefresh 就启动,所以老版本“端口占用”报得更早。
    3. 为什么 Web 类型推断会出错:同时引入 spring-boot-starter-web 和 spring-boot-starter-webflux 时,Servlet 优先,得到 SERVLET;只引 WebFlux 才是 REACTIVE。可用 spring.main.web-application-type 强制。引错依赖会导致 MVC 的自动配置不生效或 WebFlux 不启用,表现为 404 或启动直接退出。
    4. Runner 与 ApplicationReadyEvent 的取舍:Runner 适合“启动即执行一次”的逻辑(缓存预热、补偿、校验),缺点是不受生命周期管理、异常直接失败、耗时会推迟就绪。更重且需要优雅启停的组件应该用 SmartLifecycle(有 phase、stop、isRunning),或者用 ApplicationReadyEvent 监听器 + 异步线程池。
    5. 可执行 jar 怎么跑起来的:spring-boot-maven-plugin 的 repackage 生成 JarLauncher 引导的 jar,MANIFEST 里 Main-Class 指向 JarLauncher、Start-Class 指向业务启动类;JarLauncher 用 LaunchedURLClassLoader 加载 BOOT-INF/classes 和 BOOT-INF/lib 下的嵌套 jar。这就是为什么 java -jar 能直接跑、而把 jar 解压后类路径会变。
    6. 优雅停机与 K8s 配合:server.shutdown=graceful 让 WebServerGracefulShutdownLifecycle 先停止接收新请求,等存量请求完成(受 spring.lifecycle.timeout-per-shutdown-phase 限制),再停容器;K8s 侧要配 preStop(sleep 或调 actuator shutdown)和足够的 terminationGracePeriodSeconds,否则 SIGTERM 后立刻 SIGKILL,优雅停机来不及。kill -9 完全不触发。
  • 追问链:

    1. Spring Boot 启动入口? → SpringApplication.run。
    2. run 分几段? → 环境、建上下文、prepare、refresh、afterRefresh、runners、ready。
    3. 第一个事件? → ApplicationStartingEvent。
    4. 环境准备做什么? → 创建 Environment、加载配置、初始化日志。
    5. 配置什么时候加载? → prepareEnvironment,Boot 2.4+ 走 Config Data。
    6. Banner 什么时候打印? → 环境准备之后、建上下文之前。
    7. 上下文类型怎么定? → deduceWebApplicationType。
    8. Web 类型有几种? → NONE/SERVLET/REACTIVE。
    9. Servlet 和 Reactive 同时存在? → 默认 SERVLET。
    10. 怎么强制类型? → spring.main.web-application-type。
    11. prepareContext 做什么? → 设环境、跑 Initializer、加载主配置类。
    12. Initializer 什么时候执行? → prepareContext,refresh 之前。
    13. refresh 做什么? → Spring 十二步(3.1-1)。
    14. 内嵌容器何时创建? → onRefresh。
    15. 内嵌容器何时启动? → finishRefresh 的 Lifecycle。
    16. 为什么端口占用报得晚? → 启动推迟到 finishRefresh(Boot 2.3+)。
    17. Tomcat 谁创建的? → TomcatServletWebServerFactory。
    18. 怎么换 Jetty/Undertow? → 排除 tomcat starter,换对应 starter。
    19. Filter/Servlet 怎么注册? → ServletContextInitializer、FilterRegistrationBean。
    20. DispatcherServlet 谁注册? → DispatcherServletAutoConfiguration。
    21. afterRefresh 做什么? → 默认空,模板方法。
    22. Runner 有几种? → ApplicationRunner、CommandLineRunner。
    23. Runner 顺序? → @Order/Ordered。
    24. Runner 抛异常? → 启动失败、上下文关闭。
    25. Runner 在哪个事件之间? → Started 之后、Ready 之前。
    26. Ready 事件能做什么? → 注册中心、开流量、埋点。
    27. 启动失败怎么处理? → handleRunFailure + ApplicationFailedEvent。
    28. 退出码怎么控制? → ExitCodeGenerator/ExitCodeExceptionMapper。
    29. 关闭流程? → shutdown hook → ContextClosedEvent → Lifecycle → 销毁单例。
    30. 优雅停机怎么配? → server.shutdown=graceful + 超时 + preStop。
    31. kill -9 会优雅停机吗? → 不会。
    32. 内嵌容器怎么打成 jar? → maven plugin repackage + JarLauncher。
    33. JarLauncher 用什么类加载器? → LaunchedURLClassLoader。
    34. war 怎么部署? → SpringBootServletInitializer。
    35. 内嵌和外置怎么选? → 云原生/容器选内嵌;传统中间件托管选外置。
    36. 启动慢怎么排查? → ApplicationStartup/JFR/分段计时。
    37. 怎么优化启动? → AOT、懒加载、排除自动配置、减少扫描、异步预热。
    38. 懒加载有什么风险? → 首次请求慢、启动期错误延后暴露。
    39. AOT 对启动的影响? → 预生成代理/反射元数据,减少运行期开销。
    40. 虚拟线程怎么开? → spring.threads.virtual.enabled=true(Boot 3.2+)。
    41. Tomcat 线程池默认多大? → max 200、accept-count 100。
    42. max-connections 是什么? → 最大连接数,默认 8192。
    43. 怎么改端口? → server.port,0 随机。
    44. context-path 影响什么? → 所有 Servlet 的访问前缀。
    45. HTTPS 怎么配? → server.ssl.*/SSL bundle。
    46. HTTP/2 怎么开? → server.http2.enabled。
    47. 反向代理下怎么拿真实 IP? → server.forward-headers-strategy。
    48. 启动事件能监听哪些? → Starting/EnvironmentPrepared/ContextInitialized/Prepared/Started/Ready/Failed。
    49. EnvironmentPostProcessor 什么时候跑? → 环境准备阶段。
    50. 面试怎么总结? → run 七段 → 事件顺序 → 容器创建/启动分离 → Runner/Ready → 关闭与优雅停机 → 启动优化。
  • 生产案例/取舍(示例,替换成你的项目):

    • 端口被占用,日志里 Bean 全部初始化成功才报错;确认是 Boot 2.3+ 的 finishRefresh 启动时机,排查时直接看 WebServerStartStopLifecycle。
    • ApplicationRunner 里全量加载 200 万条配置,启动 90s,K8s readiness 失败重启循环;改异步预热 + 分批。
    • Runner 抛异常导致整个应用启动失败;业务上允许失败,改成捕获 + 告警。
    • 同时引入 web 和 webflux,实际跑的是 MVC,WebFlux 的路由 404;移除多余 starter。
    • server.shutdown=graceful 配了但发布仍丢请求;K8s 没配 preStop,SIGTERM 后立即 SIGKILL。
    • 启动日志在 Banner 之前丢失;日志系统在环境准备阶段初始化,检查 logging.config 和早期日志。
    • 配置中心超时导致启动卡住 60s;设连接/读取超时 + fail-fast 关闭。
    • 自研 starter 在 prepareContext 注册 Bean 但依赖自动配置 Bean;改用 BeanFactoryPostProcessor 或 ApplicationContextInitializer 的正确时机。
    • 用 @PostConstruct 建连接池,启动偶发超时;改 SmartLifecycle + 重试。
    • war 部署到外置 Tomcat,SpringBootServletInitializer 没继承,404;补上并排除内嵌容器。
    • 优雅停机等 30s 仍有长请求被中断;调大 timeout-per-shutdown-phase 并给长任务加超时。
    • 启动耗时从 12s 降到 6s:排除未用自动配置 + 懒加载 + 关闭 JMX。
    • 取舍:内嵌容器换部署简单/镜像友好,代价是容器调优和 JSP 限制;Runner 换“启动即执行”,代价是阻塞就绪;懒加载换启动速度,代价是首请求抖动;AOT 换启动性能,代价是构建复杂度。
  • 易错点:

    • 认为内嵌容器在 onRefresh 就绑定端口(Boot 2.3+ 不是)。
    • 认为端口占用会在 Bean 初始化前报错。
    • 认为 ApplicationRunner 在 ApplicationReadyEvent 之后执行。
    • 认为 Runner 抛异常不影响启动。
    • 认为 ApplicationStartedEvent 表示可以接流量(那是 Ready)。
    • 认为 afterRefresh 做了很多事(默认空)。
    • 认为环境准备在上下文创建之后。
    • 认为 Banner 在配置加载之前打印。
    • 认为日志配置在 refresh 之后才生效。
    • 认为 Web 类型只看有没有 spring-boot-starter-web。
    • 认为 web + webflux 同时引入会用 WebFlux。
    • 认为 spring.main.web-application-type 不能覆盖推断。
    • 认为 kill -9 会执行优雅停机。
    • 认为配了 server.shutdown=graceful 就一定不丢请求(还要 preStop/超时)。
    • 认为内嵌 Tomcat 和外置 Tomcat 行为完全一致(JSP、类加载、配置)。
    • 认为 java -jar 用的是系统类加载器。
    • 认为 war 包不需要 SpringBootServletInitializer。
    • 认为 ApplicationReadyEvent 监听器异常不影响运行。
    • 认为启动失败一定会打印完整 cause。
    • 认为启动慢都是 JVM 慢(多数是扫描/Bean/预热)。
    • 认为懒加载没有副作用。
    • 认为 AOT 只影响 native image(也影响 JVM 启动)。
    • 认为虚拟线程一开就变快(受限于阻塞点和容器)。
    • 认为 server.tomcat.threads.max 等于最大并发连接。
    • 认为 context-path 只影响 Controller。
    • 认为内嵌容器不支持 HTTPS/HTTP2。
    • 认为 shutdown hook 在所有退出方式下都执行。
    • 认为 ApplicationContextInitializer 在 refresh 之后执行。
  • 30 秒口述稿:

SpringApplication.run 分七段:准备环境、创建上下文、prepareContext、refresh、afterRefresh、跑 Runner、发 Ready。每段前后有事件:Starting、EnvironmentPrepared、ContextInitialized、Prepared、Started、Ready,失败发 Failed。Web 类型在构造时按 classpath 推断是 SERVLET、REACTIVE 还是 NONE。内嵌 Tomcat 在 refresh 的 onRefresh 里创建,但真正启动和绑定端口在 finishRefresh 的 Lifecycle 阶段(Boot 2.3 起),所以端口占用报得比较晚。Runner 在 Started 之后、Ready 之前执行,慢会拖垮 K8s 就绪。关闭走 shutdown hook → ContextClosedEvent → Lifecycle 停容器 → 销毁单例,kill -9 不触发。

  • 3 分钟展开顺序:结论(run 七段 + 事件链 + 容器创建/启动分离)→ 构造阶段推断 Web 类型 → 环境准备与配置加载 → 创建/prepareContext → refresh 与内嵌容器 onRefresh/finishRefresh → Runner 与 Ready → 启动失败与关闭/优雅停机 → 打包与内嵌 vs 外置 → 启动慢的分段定位与优化。