Skip to content

3.1-1 Spring 容器启动流程 refresh() 十二步 ​

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

  • 题型:流程 / 原理

  • 一句话结论:AbstractApplicationContext#refresh() 是 Spring 启动的总编排:准备上下文 → 创建/准备 BeanFactory → 执行 BeanFactoryPostProcessor 解析配置/自动装配 → 注册 BeanPostProcessor → 初始化 MessageSource/事件广播器/子类 onRefresh/监听器 → 预实例化单例 → 发布 ContextRefreshedEvent。12 步顺序固定,BFPP 管“bean 定义”,BPP 管“bean 实例”,这是所有启动扩展点的骨架。

  • 分层要点:

    1. 入口与边界:SpringApplication.run 最终调用 refreshContext → ApplicationContext.refresh();AbstractApplicationContext#refresh 用 startupShutdownMonitor 同步,BeansException 失败会 destroyBeans + cancelRefresh,其他异常走 finally 的 resetCommonCaches。Spring 5.x/6.x 都是 12 步,Boot 3 在此之上换了 Jakarta、自动配置导入和 AOT 支持。
    2. 1–3 步:准备容器:prepareRefresh 置 active、初始化属性源、校验必需属性、准备早期监听器/事件;obtainFreshBeanFactory 创建/获取 DefaultListableBeanFactory 并加载 bean 定义;prepareBeanFactory 装配 ClassLoader、SpEL、ApplicationContextAwareProcessor、ApplicationListenerDetector、可解析依赖等基础设施。
    3. 4–6 步:解析配置与注册后置处理器:postProcessBeanFactory 给子类扩展(Web 容器注册 Servlet 作用域等);invokeBeanFactoryPostProcessors 执行 BeanDefinitionRegistryPostProcessor/BeanFactoryPostProcessor,ConfigurationClassPostProcessor 在这里解析 @Configuration、@ComponentScan、@Import、@Bean 和自动装配;registerBeanPostProcessors 实例化并注册 BeanPostProcessor,AOP、@Autowired、@PostConstruct 都靠它们。
    4. 7–10 步:初始化基础设施与事件:initMessageSource 初始化国际化;initApplicationEventMulticaster 初始化事件广播器;onRefresh 是子类钩子,Boot 在这里创建内嵌 Web 服务器;registerListeners 注册 ApplicationListener 并补发早期事件。
    5. 11 步:预实例化单例:finishBeanFactoryInitialization 设置 ConversionService、冻结配置、preInstantiateSingletons(),触发所有非懒加载单例的 getBean → createBean → doCreateBean;@PostConstruct、InitializingBean、AOP 代理、循环依赖三级缓存都发生在这一步。
    6. 12 步:完成刷新:finishRefresh 初始化 LifecycleProcessor、启动 SmartLifecycle、发布 ContextRefreshedEvent、注册 LiveBeansView;Boot 的 ApplicationRunner/CommandLineRunner 在 refresh 之后、ApplicationReadyEvent 之前执行。
    7. 两类后置处理器的边界:BeanFactoryPostProcessor 在 bean 实例化前修改/注册 BeanDefinition,不能代理 bean;BeanPostProcessor 在 bean 实例化/初始化前后修改 实例,AOP 代理、依赖注入、生命周期注解都靠它。BeanDefinitionRegistryPostProcessor 是 BFPP 的子类型,能注册新定义。
    8. 常见启动失败点:必需属性缺失、bean 定义冲突、@Configuration 解析失败、BFPP 过早访问 DB、BPP 顺序错误、@PostConstruct 抛异常、端口占用、SmartLifecycle 启动失败、ContextRefreshedEvent 监听器异常。定位要看 BeanCreationException 的 cause 链和启动日志中的 phase。
  • 图/流程:

text
refresh() 十二步:
   1. prepareRefresh
   2. obtainFreshBeanFactory
   3. prepareBeanFactory
   4. postProcessBeanFactory
   5. invokeBeanFactoryPostProcessors
   6. registerBeanPostProcessors
   7. initMessageSource
   8. initApplicationEventMulticaster
   9. onRefresh
  10. registerListeners
  11. finishBeanFactoryInitialization
  12. finishRefresh
text
BeanFactory 与 Bean 两条线:
  1-5 步:BeanFactory / BeanDefinition
    ├─ 加载定义
    ├─ BFPP 修改/注册定义
    └─ 自动装配、@Configuration 解析
  6-11 步:Bean 实例
    ├─ 注册 BPP
    ├─ getBean → doCreateBean
    ├─ 依赖注入、@PostConstruct、AOP
    └─ 单例池
  12 步:Lifecycle + ContextRefreshedEvent
text
Spring Boot 启动映射:
  SpringApplication.run
    → prepareEnvironment
    → createApplicationContext
    → prepareContext
    → refreshContext → context.refresh()(12 步)
    → afterRefresh
    → listeners.started
    → callRunners(ApplicationRunner/CommandLineRunner)
    → listeners.running(ApplicationReadyEvent)
text
第 11 步单例创建:
  preInstantiateSingletons
    → getBean
      → doGetBean
        → createBean
          → doCreateBean
            ├─ createBeanInstance(构造/工厂)
            ├─ populateBean(注入)
            ├─ initializeBean
            │    ├─ Aware
            │    ├─ BPP before
            │    ├─ @PostConstruct / afterPropertiesSet / init-method
            │    └─ BPP after(AOP 代理)
            └─ registerDisposableBean
  • 版本/源码锚点:

    • Spring Framework 5.3.x / 6.x:AbstractApplicationContext#refresh 仍是 12 步;ApplicationStartup 从 5.3 起引入,6.x 增加 AOT、Jakarta 命名空间。
    • Spring Boot 2.7 / 3.x:SpringApplication#run → refreshContext;ServletWebServerApplicationContext#onRefresh 创建内嵌容器;@SpringBootApplication 组合 @EnableAutoConfiguration。
    • 关键类:AbstractApplicationContext、AbstractRefreshableApplicationContext、GenericApplicationContext、DefaultListableBeanFactory、PostProcessorRegistrationDelegate、ConfigurationClassPostProcessor、AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、AnnotationAwareAspectJAutoProxyCreator、ServletWebServerApplicationContext。
    • 关键方法:prepareRefresh、obtainFreshBeanFactory、prepareBeanFactory、postProcessBeanFactory、invokeBeanFactoryPostProcessors、registerBeanPostProcessors、initMessageSource、initApplicationEventMulticaster、onRefresh、registerListeners、finishBeanFactoryInitialization、finishRefresh。
  • 十二步明细:

步方法关键动作扩展/注意
1prepareRefreshactive=true、initPropertySources、校验必需属性、早期监听器/事件属性缺失在这里失败
2obtainFreshBeanFactory创建/获取 BeanFactory、加载 BeanDefinitionXML 容器在此解析;Generic 容器通常已注册
3prepareBeanFactoryClassLoader、SpEL、AwareProcessor、ListenerDetector、可解析依赖基础设施,不是业务 bean
4postProcessBeanFactory子类定制 BeanFactoryWeb 作用域、ServletContext
5invokeBeanFactoryPostProcessors执行 BFPP/BeanDefinitionRegistryPostProcessor@Configuration、自动装配在这里
6registerBeanPostProcessors实例化/注册 BPPAOP、@Autowired、@PostConstruct
7initMessageSource初始化 MessageSource国际化
8initApplicationEventMulticaster初始化事件广播器可配异步 TaskExecutor
9onRefresh子类钩子Boot 创建 Tomcat/Jetty/Undertow
10registerListeners注册监听器、补发早期事件早期事件只发一次
11finishBeanFactoryInitialization预实例化非懒加载单例循环依赖/AOP/@PostConstruct
12finishRefreshLifecycleProcessor、ContextRefreshedEvent容器“刷新完成”
  • 两类后置处理器对比:
维度BeanFactoryPostProcessorBeanPostProcessor
作用对象BeanDefinitionBean 实例
时机实例化前(第 5 步)实例化/初始化前后(第 6 步注册,第 11 步执行)
典型ConfigurationClassPostProcessor、PropertySourcesPlaceholderConfigurerAutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、AOP 代理创建器
能否注册新定义能(RegistryPostProcessor)不能
能否代理 bean不能能
常见坑过早 getBean/访问 DB顺序错、BPP 自身被代理、自调用
  • 扩展点地图:
扩展点时机用途
ApplicationContextInitializerrefresh 前准备 Environment
BeanFactoryPostProcessor第 5 步改/注册 BeanDefinition
BeanDefinitionRegistryPostProcessor第 5 步最前扫描、注册 bean
BeanPostProcessor第 6 步注册,第 11 步执行注入、代理、生命周期
InstantiationAwareBeanPostProcessor实例化前后属性注入、短路创建
SmartInitializingSingleton所有单例后依赖全部单例的初始化
SmartLifecycle第 12 步启动/停止后台线程
ApplicationListener第 10/12 步事件驱动
ApplicationRunner/CommandLineRunnerrefresh 后启动任务
  • Spring Boot 对应关系:
Boot 阶段对应 refresh说明
prepareEnvironmentrefresh 前加载配置、Profile
createApplicationContextrefresh 前创建 AnnotationConfig 上下文
prepareContextrefresh 前注册主配置类、Initializer
refreshContext1–12 步启动核心
内嵌 Web 服务器第 9 步 onRefresh端口绑定、Servlet 容器
自动装配第 5 步ConfigurationClassPostProcessor + AutoConfigurationImportSelector
ApplicationRunnerrefresh 后不属于 12 步
ApplicationReadyEventrunners 后应用就绪
  • 深挖点(面试官常追的 6 个):

    1. 第 2 步不是所有容器都“加载 XML”:ClassPathXmlApplicationContext 继承 AbstractRefreshableApplicationContext,refreshBeanFactory 会销毁旧工厂、创建 DefaultListableBeanFactory 并 loadBeanDefinitions;AnnotationConfigApplicationContext/Boot 的 GenericApplicationContext 通常在 refresh 前已通过 AnnotatedBeanDefinitionReader 注册了配置类,第 2 步主要是确认/返回工厂。所以“第 2 步加载所有 bean 定义”只对 XML 容器成立。
    2. 第 5 步是自动装配的核心:ConfigurationClassPostProcessor 是 BeanDefinitionRegistryPostProcessor + PriorityOrdered,先于普通 BFPP 执行;它解析 @Configuration、@ComponentScan、@Import、@Bean、@PropertySource,并把 @Configuration 类 CGLIB 增强(proxyBeanMethods=true)。Boot 的 AutoConfigurationImportSelector 是 DeferredImportSelector,在用户配置之后处理,配合 @ConditionalOn* 决定装配。
    3. 第 6 步决定 AOP/注解是否生效:AutowiredAnnotationBeanPostProcessor 处理 @Autowired/@Value,CommonAnnotationBeanPostProcessor 处理 @PostConstruct/@PreDestroy/@Resource,AnnotationAwareAspectJAutoProxyCreator 在初始化后创建代理。BPP 自身通常不被自动代理(避免递归),顺序按 PriorityOrdered → Ordered → 非排序,ApplicationListenerDetector 会被移到最后。
    4. 第 11 步是 Bean 生命周期的主战场:preInstantiateSingletons 遍历非懒加载单例,getBean → doCreateBean:构造/工厂实例化、populateBean 注入、initializeBean(Aware → BPP before → @PostConstruct → afterPropertiesSet → init-method → BPP after)。AOP 代理在 BPP after 阶段产生;setter 循环依赖靠三级缓存,构造器循环依赖默认无解(@Lazy/ObjectProvider 可打破,3.1-4)。
    5. 第 12 步不是“所有 bean 都创建完”:非懒加载单例在第 11 步完成,但 @Lazy bean 仍会在首次使用时创建;SmartLifecycle 在第 12 步启动,ApplicationRunner 在 refresh 之后才跑。ContextRefreshedEvent 可能被父子容器各发一次,监听器要判断 event.getApplicationContext() == this,Boot 里更常用 ApplicationReadyEvent。
    6. 启动失败的定位顺序:先看异常最内层 cause(BeanCreationException → BeanDefinitionStoreException/UnsatisfiedDependencyException),再看日志中的 phase:第 5 步多是配置/自动装配/BeanDefinition 冲突,第 6 步多是 BPP 顺序/依赖,第 11 步多是构造/注入/@PostConstruct/循环依赖,第 12 步多是端口/Lifecycle/监听器。不要只看最外层 ApplicationContextException。
  • 追问链:

    1. refresh 十二步背一下? → prepareRefresh、obtainFreshBeanFactory、prepareBeanFactory、postProcessBeanFactory、invokeBeanFactoryPostProcessors、registerBeanPostProcessors、initMessageSource、initApplicationEventMulticaster、onRefresh、registerListeners、finishBeanFactoryInitialization、finishRefresh。
    2. refresh 入口在哪? → SpringApplication.run → refreshContext → AbstractApplicationContext#refresh。
    3. refresh 线程安全吗? → 用 startupShutdownMonitor 同步;GenericApplicationContext 只允许 refresh 一次,XML 容器可多次。
    4. prepareRefresh 做什么? → active、属性源、必需属性、早期监听器/事件。
    5. obtainFreshBeanFactory 做什么? → 创建/获取 BeanFactory,加载/确认 BeanDefinition。
    6. XML 和注解容器第 2 步一样吗? → 不一样;XML 容器加载 XML,Generic 容器通常已注册。
    7. prepareBeanFactory 做什么? → ClassLoader、SpEL、AwareProcessor、ListenerDetector、可解析依赖。
    8. postProcessBeanFactory 做什么? → 子类定制;Web 作用域/ServletContext。
    9. BFPP 和 BPP 区别? → 改定义 vs 改实例;第 5 步 vs 第 6/11 步。
    10. BeanDefinitionRegistryPostProcessor 是什么? → BFPP 子类型,能注册新 BeanDefinition。
    11. ConfigurationClassPostProcessor 作用? → 解析 @Configuration、@ComponentScan、@Import、@Bean。
    12. 自动装配在哪一步? → 第 5 步,ConfigurationClassPostProcessor + AutoConfigurationImportSelector。
    13. @Configuration 为什么被 CGLIB 增强? → proxyBeanMethods=true 保证 @Bean 方法调用返回单例。
    14. registerBeanPostProcessors 做什么? → 实例化/注册 BPP,排序。
    15. AOP 代理什么时候创建? → 第 11 步 bean 初始化后,由 AnnotationAwareAspectJAutoProxyCreator 创建。
    16. @Autowired 谁处理? → AutowiredAnnotationBeanPostProcessor。
    17. @PostConstruct 谁处理? → CommonAnnotationBeanPostProcessor。
    18. @PostConstruct 和 afterPropertiesSet 顺序? → @PostConstruct 先,afterPropertiesSet 后。
    19. initMessageSource 作用? → 国际化 MessageSource。
    20. initApplicationEventMulticaster 作用? → 事件广播器,可异步。
    21. onRefresh 作用? → 子类钩子;Boot 创建内嵌 Web 服务器。
    22. 内嵌 Tomcat 哪一步创建? → 第 9 步 onRefresh。
    23. registerListeners 做什么? → 注册监听器、补发早期事件。
    24. finishBeanFactoryInitialization 做什么? → 预实例化非懒加载单例。
    25. 单例 Bean 什么时候创建? → 第 11 步;懒加载首次 getBean。
    26. Bean 生命周期在哪? → 第 11 步 doCreateBean。
    27. 循环依赖在哪解决? → 第 11 步 getBean 的三级缓存;构造器循环依赖默认无解,可用 @Lazy/ObjectProvider 打破。
    28. finishRefresh 做什么? → LifecycleProcessor、ContextRefreshedEvent。
    29. SmartLifecycle 什么时候启动? → 第 12 步。
    30. ApplicationRunner 在 refresh 内吗? → 不在;refresh 之后。
    31. ContextRefreshedEvent 会发几次? → 父子容器可能各一次;按 context 过滤。
    32. ApplicationReadyEvent 和 ContextRefreshedEvent 区别? → 前者在 runners 后,应用就绪;后者容器刷新完成。
    33. refresh 失败会怎样? → BeansException 走 destroyBeans + cancelRefresh;其他异常由 Boot 的 handleRunFailure 关闭上下文,finally 都会 resetCommonCaches。
    34. BeanDefinition 冲突怎么处理? → BeanDefinitionOverrideException;Boot 可配 allow-bean-definition-overriding,但不建议滥用。
    35. BFPP 里能 getBean 吗? → 尽量别;会提前实例化,破坏生命周期。
    36. BPP 能修改 BeanDefinition 吗? → 不能,改定义用 BFPP。
    37. BPP 自己会被代理吗? → 通常不会,避免递归;有 BeanPostProcessorChecker 警告。
    38. @Async 什么时候生效? → AsyncAnnotationBeanPostProcessor 创建代理;自调用失效。
    39. @Transactional 什么时候生效? → 事务代理由 BPP 创建;自调用/private 失效。
    40. @Lazy 影响第 11 步吗? → 懒加载 bean 不预实例化。
    41. FactoryBean 什么时候初始化? → 第 11 步 getBean 时;&name 取 FactoryBean 本身。
    42. SmartInitializingSingleton 什么时候? → 所有非懒加载单例之后。
    43. Spring 6 AOT 改变了 refresh 吗? → 12 步仍在;AOT 在启动前生成定义/反射提示,面向 Native。
    44. Boot 3 和 Boot 2 启动差异? → Jakarta、AOT、自动配置导入文件;核心 refresh 不变。
    45. 启动慢怎么排查? → 看第 5 步配置解析、第 11 步 bean 创建、AOP、数据源、扫描范围;用启动日志/AsyncProfiler。
  • 生产案例/取舍(示例,替换成你的项目):

    • @PostConstruct 里自调用 @Transactional 方法,事务不生效;改为 ApplicationRunner 或 TransactionTemplate。
    • BFPP 里访问数据库导致启动失败;BFPP 只改定义,数据初始化放 ApplicationRunner/SmartLifecycle。
    • @Configuration(proxyBeanMethods=false) 提升启动速度,但直接调用 @Bean 方法会创建新对象;确认无直接调用。
    • 父子容器都监听 ContextRefreshedEvent 导致重复初始化;按 event.getApplicationContext() == this 过滤或用 ApplicationReadyEvent。
    • 内嵌 Tomcat 端口占用在 onRefresh 失败;启动日志能定位到第 9 步。
    • SmartLifecycle 启动顺序错乱;用 getPhase() 控制,phase 越小越早。
    • @Async 自调用不生效;拆到另一个 bean 或自注入代理。
    • BeanDefinitionOverrideException 因两个 starter 注册同名 bean;排除/改名,不盲目开 overriding。
    • 启动慢在 @ComponentScan 范围过大/大量 AOP;缩小扫描、懒加载、AOT。
    • 取舍:BFPP 换启动期灵活性,代价是过早实例化风险;BPP 换实例增强,代价是顺序/代理复杂;懒加载换启动速度,代价是首请求延迟;AOT 换启动/内存,代价是构建复杂。
  • 易错点:

    • 把 refresh 十二步和 Bean 生命周期混为一谈。
    • 认为第 2 步所有容器都加载 XML。
    • 认为 BFPP 能代理 bean。
    • 认为 BPP 能注册 BeanDefinition。
    • 认为自动装配在 onRefresh。
    • 认为内嵌 Tomcat 在 finishRefresh 创建。
    • 认为 ApplicationRunner 在 refresh 内。
    • 认为 @PostConstruct 在依赖注入之前。
    • 认为 @PostConstruct 里事务/异步一定生效。
    • 认为 @Configuration 一定是 CGLIB 代理(proxyBeanMethods=false 不是)。
    • 认为 @Lazy bean 也会在第 11 步创建。
    • 认为 ContextRefreshedEvent 只发一次。
    • 认为 SmartLifecycle 在 bean 初始化前启动。
    • 认为 refresh() 可以随便重复调用。
    • 认为 BFPP 里可以安全 getBean。
    • 认为 BPP 顺序无所谓。
    • 认为 @Autowired 由 BFPP 处理。
    • 认为 @PostConstruct 由 InitializingBean 处理。
    • 认为 AOP 代理在 finishRefresh 才创建。
    • 认为 BeanDefinitionOverrideException 只能靠开 overriding 解决。
    • 认为启动失败只看最外层异常。
    • 认为 Spring 6 AOT 不再走 refresh。
  • 30 秒口述稿:

refresh() 十二步:准备上下文、获取 BeanFactory、准备 BeanFactory、子类后处理、执行 BFPP 解析配置和自动装配、注册 BPP、初始化 MessageSource、事件广播器、子类 onRefresh、注册监听器、预实例化单例、finishRefresh 发 ContextRefreshedEvent。核心是 BFPP 管 BeanDefinition、BPP 管 Bean 实例;AOP、@Autowired、@PostConstruct、循环依赖都在第 11 步;Boot 的内嵌容器在第 9 步 onRefresh 创建,ApplicationRunner 在 refresh 之后。

  • 3 分钟展开顺序:结论(12 步 + BFPP/BPP 两条线)→ 1–3 准备容器 → 4–6 解析配置/注册 BPP → 7–10 基础设施/事件/Web 容器 → 11 单例与 Bean 生命周期 → 12 Lifecycle/事件 → Boot 映射 → 启动失败定位/取舍。