1.5 一行 refresh()，撑起整个 Spring：IoC 容器启动全链路源码拆解

一行 refresh()，撑起整个 Spring：IoC 容器启动全链路源码拆解

🎯 本文定位：Spring IoC 容器核心第五篇，逐行解析容器启动最核心的 12 个步骤，源码基于v6.2.0

一、面试题引入

高频面试问题：

• Spring 容器启动时都做了什么？
• refresh() 方法的执行流程是怎样的？
• BeanFactoryPostProcessor 和 BeanPostProcessor 分别在什么时候执行？
• 为什么 Bean 要在容器启动时就实例化，而不是使用时才创建？

为什么这道题能区分候选人水平：

能说出"启动时加载配置、创建 Bean"的人很多，但能按顺序说出 12 个步骤、解释每个步骤的作用和设计意图、说明各扩展点的执行时机的人极少。这道题能直接反映候选人对 Spring 源码的理解深度。

二、功能与用法（知其然）

2.1 refresh() 的地位

refresh() 是 Spring 容器启动的总指挥，无论使用哪种 ApplicationContext：

// AnnotationConfigApplicationContext
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this();
register(componentClasses);
refresh(); // 🔥 启动容器
}

// ClassPathXmlApplicationContext
public ClassPathXmlApplicationContext(String... configLocations) {
this(configLocations, true, null); // 内部会调用 refresh()
}

// Spring Boot
public ConfigurableApplicationContext run(String... args) {
// …
refreshContext(context); // 🔥 最终也是调用 refresh()
// …
}

2.2 refresh() 的 12 个步骤总览

public void refresh() throws BeansException, IllegalStateException {
// 1️⃣ 准备刷新
prepareRefresh();

// 2️⃣ 获取 BeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// 3️⃣ 准备 BeanFactory
prepareBeanFactory(beanFactory);

try {
// 4️⃣ 子类扩展点
postProcessBeanFactory(beanFactory);

// 5️⃣ 执行 BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(beanFactory);

// 6️⃣ 注册 BeanPostProcessor
registerBeanPostProcessors(beanFactory);

// 7️⃣ 初始化消息源
initMessageSource();

// 8️⃣ 初始化事件广播器
initApplicationEventMulticaster();

// 9️⃣ 子类扩展点
onRefresh();

// 🔟 注册监听器
registerListeners();

// 1️⃣1️⃣ 实例化所有单例
finishBeanFactoryInitialization(beanFactory);

// 1️⃣2️⃣ 完成刷新
finishRefresh();
}
catch (RuntimeException | Error ex) {
destroyBeans();
cancelRefresh(ex);
throw ex;
}
}

2.3 12 步骤速查表

三、源码实现拆解（知其所以然）

3.1 Step 1：prepareRefresh() – 准备刷新

源码路径：org.springframework.context.support.AbstractApplicationContext

protected void prepareRefresh() {
// 记录启动时间
this.startupDate = System.currentTimeMillis();
// 设置容器状态
this.closed.set(false);
this.active.set(true);

if (logger.isDebugEnabled()) {
logger.debug("Refreshing " + this);
}

// 🔥 初始化属性源（Web 环境下会替换占位符属性源）
initPropertySources();

// 🔥 验证必需的属性是否已配置
getEnvironment().validateRequiredProperties();

// 保存早期监听器
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}
else {
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}

// 用于存储早期事件
this.earlyApplicationEvents = new LinkedHashSet<>();
}

设计意图：

• 容器状态管理（active/closed）
• 属性源初始化（Web 环境下替换 ServletContext 占位符）
• 早期事件容器（在事件广播器初始化前发布的事件会暂存这里）

3.2 Step 2：obtainFreshBeanFactory() – 获取 BeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 🔥 刷新 BeanFactory（模板方法，子类实现）
refreshBeanFactory();
// 返回 BeanFactory
return getBeanFactory();
}

两种实现：

// GenericApplicationContext.java（Spring Boot 使用）
@Override
protected final void refreshBeanFactory() throws IllegalStateException {
if (!this.refreshed.compareAndSet(false, true)) {
throw new IllegalStateException("GenericApplicationContext does not support multiple refresh");
}
this.beanFactory.setSerializationId(getId());
}

// AbstractRefreshableApplicationContext.java（传统 XML 配置使用）
@Override
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory); // 🔥 加载 XML 配置
this.beanFactory = beanFactory;
}
catch (IOException ex) {
throw new ApplicationContextException(...);
}
}

3.3 Step 3：prepareBeanFactory() – 准备 BeanFactory

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 设置类加载器
beanFactory.setBeanClassLoader(getClassLoader());

// 🔥 设置 SpEL 表达式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

// 添加属性编辑器注册器
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

// 🔥 添加 ApplicationContextAwareProcessor
// 处理 EnvironmentAware, ApplicationContextAware 等回调
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

// 🔥 忽略这些接口的自动装配（因为通过 Aware 回调注入）
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);

// 🔥 注册可解析的依赖（@Autowired 时可以注入这些类型）
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);

// 🔥 添加监听器探测器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

// LoadTimeWeaver 处理
if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}

// 🔥 注册环境相关的单例 Bean
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
}
}

核心配置：

3.4 Step 4：postProcessBeanFactory() – 子类扩展点

// AbstractApplicationContext.java（默认空实现）
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}

// ServletWebServerApplicationContext.java（Spring Boot Web 环境）
@Override
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
super.postProcessBeanFactory(beanFactory);
// 注册 Web 作用域
beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(ServletContextAware.class);
registerWebApplicationScopes();
}

3.5 Step 5：invokeBeanFactoryPostProcessors() – 执行 BeanFactoryPostProcessor

这是最重要的步骤之一！

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 🔥 委托给 PostProcessorRegistrationDelegate
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

// LoadTimeWeaver 支持
if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null &&
beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}

PostProcessorRegistrationDelegate 核心逻辑：

public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

Set<String> processedBeans = new HashSet<>();

if (beanFactory instanceof BeanDefinitionRegistry registry) {
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

// 🔥 第一步：处理手动添加的 BeanFactoryPostProcessor
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor registryProcessor) {
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}

List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

// 🔥 第二步：执行实现 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor
// ConfigurationClassPostProcessor 在这里执行！
String[] postProcessorNames = beanFactory.getBeanNamesForType(
BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
currentRegistryProcessors.clear();

// 🔥 第三步：执行实现 Ordered 的 BeanDefinitionRegistryPostProcessor
postProcessorNames = beanFactory.getBeanNamesForType(
BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
currentRegistryProcessors.clear();

// 🔥 第四步：执行剩余的 BeanDefinitionRegistryPostProcessor（循环直到没有新的）
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(
BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
currentRegistryProcessors.clear();
}

// 🔥 第五步：执行所有的 postProcessBeanFactory() 方法
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
// … 后续处理普通 BeanFactoryPostProcessor …
}

执行顺序：

3.6 Step 6：registerBeanPostProcessors() – 注册 BeanPostProcessor

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

注册顺序：

注意：这里只是注册，还没有执行。执行是在 Bean 创建过程中。

3.7 Step 7-8：初始化 MessageSource 和 EventMulticaster

protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
// 使用用户定义的 MessageSource
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
}
else {
// 使用默认的 DelegatingMessageSource
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
}
}

protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
// 使用用户定义的
this.applicationEventMulticaster = beanFactory.getBean(
APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
}
else {
// 使用默认的 SimpleApplicationEventMulticaster
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
}
}

设计模式：约定优于配置——如果有指定名称的 Bean 就用它，否则用默认实现。

3.8 Step 9：onRefresh() – 子类扩展点

// AbstractApplicationContext.java（默认空实现）
protected void onRefresh() throws BeansException {
// For subclasses: do nothing by default.
}

// ServletWebServerApplicationContext.java（Spring Boot）
@Override
protected void onRefresh() {
super.onRefresh();
try {
// 🔥 创建并启动 Web 服务器
createWebServer();
}
catch (Throwable ex) {
throw new ApplicationContextException("Unable to start web server", ex);
}
}

3.9 Step 10：registerListeners() – 注册监听器

protected void registerListeners() {
// 🔥 注册静态指定的监听器
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}

// 🔥 从容器中获取监听器 Bean 的名称（不实例化）
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}

// 🔥 发布早期事件
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}

3.10 Step 11：finishBeanFactoryInitialization() – 实例化单例

这是容器启动最耗时的步骤！

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 初始化 Bootstrap 执行器（用于并行初始化）
if (beanFactory.containsBean(BOOTSTRAP_EXECUTOR_BEAN_NAME) &&
beanFactory.isTypeMatch(BOOTSTRAP_EXECUTOR_BEAN_NAME, Executor.class)) {
beanFactory.setBootstrapExecutor(
beanFactory.getBean(BOOTSTRAP_EXECUTOR_BEAN_NAME, Executor.class));
}

// 初始化 ConversionService
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}

// 注册默认的嵌入值解析器
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}

// 提前初始化 BeanFactoryInitializer
String[] initializerNames = beanFactory.getBeanNamesForType(BeanFactoryInitializer.class, false, false);
for (String initializerName : initializerNames) {
beanFactory.getBean(initializerName, BeanFactoryInitializer.class).initialize(beanFactory);
}

// 提前初始化 LoadTimeWeaverAware Bean
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
beanFactory.getBean(weaverAwareName);
}

// 停止使用临时类加载器
beanFactory.setTempClassLoader(null);

// 🔥 冻结配置，不再允许修改 BeanDefinition
beanFactory.freezeConfiguration();

// 🔥🔥🔥 核心：实例化所有非懒加载的单例
beanFactory.preInstantiateSingletons();
}

3.11 Step 12：finishRefresh() – 完成刷新

protected void finishRefresh() {
// 清除资源缓存
resetCommonCaches();
clearResourceCaches();

// 🔥 初始化生命周期处理器
initLifecycleProcessor();

// 🔥 调用 LifecycleProcessor.onRefresh()
getLifecycleProcessor().onRefresh();

// 🔥 发布 ContextRefreshedEvent
publishEvent(new ContextRefreshedEvent(this));
}

ContextRefreshedEvent 的作用：通知所有监听器容器已启动完成，可以执行依赖容器的操作。

四、设计动机分析（知其所以必然）

4.1 为什么要预实例化单例？

Fail-Fast 设计：

• 配置错误在启动时就暴露，而非运行时
• 循环依赖问题在启动时就能发现
• 热点代码提前编译优化（JIT）

如果想延迟初始化：

@Lazy
@Component
public class LazyService { }

// 或全局配置
spring.main.lazy–initialization=true

4.2 为什么 BeanFactoryPostProcessor 要在 BeanPostProcessor 之前执行？

BeanFactoryPostProcessor：修改 BeanDefinition
↓
BeanPostProcessor：拦截 Bean 实例化/初始化
↓
Bean 创建

原因：BeanFactoryPostProcessor 可能会注册新的 BeanPostProcessor，所以必须先执行。

4.3 为什么事件广播器要在监听器之前初始化？

initApplicationEventMulticaster() → registerListeners() → 发布早期事件

原因：监听器注册需要广播器存在；早期事件需要广播器来发布。

4.4 模板方法模式的应用

public abstract class AbstractApplicationContext {

public void refresh() {
// 固定骨架流程
prepareRefresh();
// …
postProcessBeanFactory(beanFactory); // 🔥 子类扩展
// …
onRefresh(); // 🔥 子类扩展
// …
}

// 模板方法，子类可重写
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { }
protected void onRefresh() throws BeansException { }
}

五、局限性与扩展

5.1 refresh() 只能调用一次

// GenericApplicationContext
if (!this.refreshed.compareAndSet(false, true)) {
throw new IllegalStateException("GenericApplicationContext does not support multiple refresh");
}

解决方案：如果需要刷新配置，使用 AbstractRefreshableApplicationContext 或 Spring Cloud 的 @RefreshScope。

5.2 启动性能优化

5.3 监控启动过程

@Bean
public ApplicationStartup applicationStartup() {
return new BufferingApplicationStartup(2048);
}

通过 /actuator/startup 端点查看启动步骤耗时。

六、面试回答分层

P6 回答（功能用法层）

“refresh() 是 Spring 容器启动的核心方法，主要做这几件事：创建 BeanFactory、执行 BeanFactoryPostProcessor 处理配置类、注册 BeanPostProcessor、初始化事件广播器和消息源、实例化所有非懒加载的单例 Bean、最后发布 ContextRefreshedEvent 事件。”

P7 回答（实现原理层）

“refresh() 包含 12 个步骤。第 5 步 invokeBeanFactoryPostProcessors 最重要，ConfigurationClassPostProcessor 在这里解析 @Configuration、@ComponentScan、@Import 等注解并注册 BeanDefinition。第 11 步 finishBeanFactoryInitialization 调用 preInstantiateSingletons() 实例化所有单例，这是启动最耗时的步骤。BeanFactoryPostProcessor 按 PriorityOrdered → Ordered → 普通的顺序执行，BeanPostProcessor 注册在第 6 步，但执行是在 Bean 创建过程中。”

P8 回答（设计思想层）

“refresh() 体现了模板方法模式，定义了容器启动的骨架流程，通过 postProcessBeanFactory()、onRefresh() 等钩子方法让子类扩展。Spring Boot 就在 onRefresh() 中启动 Web 服务器。preInstantiateSingletons() 体现了 Fail-Fast 设计，让配置问题在启动时暴露而非运行时。事件机制的设计很精妙：广播器初始化后才注册监听器，之前的事件暂存 earlyApplicationEvents，注册完成后统一发布，保证不丢失早期事件。Spring 6.x 增加了 bootstrapExecutor 支持并行初始化，体现了对启动性能的持续优化。”

七、面试必杀一句话

refresh() 的 12 步可以总结为"三阶段"：准备阶段（1-4步）配置 BeanFactory 环境，注册阶段（5-6步）解析配置注册处理器，实例化阶段（7-12步）初始化基础设施并创建所有单例。ConfigurationClassPostProcessor 在第 5 步解析 @ComponentScan 注册 BeanDefinition，preInstantiateSingletons() 在第 11 步创建所有非懒加载单例，这两步是容器启动的核心。

八、关键源码速查表

下一章预告：《第二章：Spring依赖注入机制》—— 深入剖析 @Autowired 如何找到匹配的 Bean