浅析 Spring 启动过程：从源码到核心方法

在 Java 企业级开发中，Spring 框架是最常用的基础框架之一。了解 Spring 的启动过程，对于理解 Spring 的工作原理、优化应用性能以及排查问题都有着至关重要的作用。本文将结合纯 Spring 的注解方式启动类，深入解读 Spring 启动过程的源码，重点分析 refresh()方法及其包含的关键步骤。

一、Spring 注解方式启动类 Demo

首先，我们创建一个简单的 Spring 项目，通过注解方式启动 Spring 容器。

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;@ComponentScan("com.coderzpw")      // 扫描该路径下的包
@Configuration
public class AppConfig {public static void main(String[] args) {// Spring容器启动AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);// 可以在这里获取Bean进行后续操作// 容器关闭applicationContext.close();}
}

在上述代码中：

• @Configuration注解表明该类是一个配置类，用于替代传统的 XML 配置文件。
• @ComponentScan("com.coderzpw") 注解用于扫描指定包及其子包下的所有@Component、@Service、@Repository、@Controller等注解标注的类，并将它们注册为 Spring 容器中的 Bean。
• 在main方法中，通过AnnotationConfigApplicationContext来创建 Spring 应用上下文，传入配置类AppConfig.class，从而启动 Spring 容器。

二、Spring 启动过程源码解析

当我们调用AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);时，Spring 的启动过程便开始了。接下来我们深入源码，一探究竟。

​AnnotationConfigApplicationContext构造函数

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {this();register(annotatedClasses);refresh();
}

上述代码中：

• this()调用了无参构造函数，在无参构造函数中会初始化reader和scanner，用于读取配置类和扫描 Bean。
• register(componentClasses)方法将传入的配置类注册到容器中。
• 最后调用的refresh()方法是 Spring 启动过程的核心，它完成了 Spring 容器的初始化、Bean 的加载、配置的解析等一系列关键操作。

refresh()方法详解

对 BeanPostProcessor、BeanFactoryPostProcessor不熟悉的同学可以查看下面文章：
【Spring BeanFactoryPostProcessor：机制解读与代码实践】
【Spring BeanPostProcessor：机制解读与代码实践】

refresh()方法位于AbstractApplicationContext类中，其源码如下：

@Override
public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {// 准备上下文环境，记录启动时间，标记活动状态等prepareRefresh();// 告诉子类刷新内部bean工厂ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();// 准备bean工厂，设置一些属性，如类加载器、表达式解析器等prepareBeanFactory(beanFactory);try {// 允许子类在bean工厂准备好后进行进一步的设置postProcessBeanFactory(beanFactory);// 执行BeanFactoryPostProcessor接口的实现类，在bean实例化之前修改bean的定义invokeBeanFactoryPostProcessors(beanFactory);// 注册BeanPostProcessor接口的实现类，用于在bean实例化、配置和初始化前后进行处理registerBeanPostProcessors(beanFactory);// 初始化消息源，用于国际化等功能initMessageSource();// 初始化应用事件广播器initApplicationEventMulticaster();// 留给子类初始化其他特殊bean的钩子方法onRefresh();// 注册监听器到事件广播器registerListeners();// 实例化所有剩余的非惰性单例beanfinishBeanFactoryInitialization(beanFactory);// 完成刷新过程，发布容器刷新完成事件等finishRefresh();}catch (BeansException ex) {if (logger.isWarnEnabled()) {logger.warn("Exception encountered during context initialization - " +"cancelling refresh attempt: " + ex);}// Destroy already created singletons to avoid dangling resources.destroyBeans();// Reset 'active' flag.cancelRefresh(ex);// Propagate exception to caller.throw ex;}finally {// Reset common introspection caches in Spring's core, since we// might not ever need metadata for singleton beans anymore...resetCommonCaches();}}
}

refresh()方法主要包含 12 个步骤，每个步骤都承担着不同的职责：

1. prepareRefresh();
   【准备工作】
   作用：在开始刷新容器之前，进行一些准备工作，如设置容器的启动时间、标记容器为活跃状态、清除缓存等。这是 IoC 容器启动的前奏，为后续的初始化操作做好准备。
2. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
   【获取Bean工厂】
   作用：获取或创建一个新的 BeanFactory 实例，BeanFactory 是 Spring IoC 容器的核心，负责管理 Bean 的定义和实例化。这个步骤是 IoC 容器启动的基础，后续的 Bean 加载和创建都依赖于BeanFactory。（重要：XML配置形势下，加载BeanDefinition就是在这个步骤，具体方法步骤：obtainFreshBeanFactory -> refreshBeanFactory -> loadBeanDefinitions）
3. prepareBeanFactory(beanFactory);
   【配置 Bean 工厂】【为BeanFactory做基础的配置】
   作用：对获取到的 BeanFactory 进行一些默认配置，如设置类加载器、添加默认的Bean 后置处理器（例如ApplicationContextAwareProcessor、ApplicationListenerDetector）、设置表达式解析器等。这些配置会影响后续 Bean 的创建和初始化过程。
4. postProcessBeanFactory(beanFactory);
   【后置处理 Bean 工厂】【子类做后置扩展处理】
   作用：允许子类对 BeanFactory 进行额外的后置处理，例如注册自定义的 BeanPostProcessor 或 BeanFactoryPostProcessor。这为开发者提供了扩展 IoC 容器功能的机会。
5. invokeBeanFactoryPostProcessors(beanFactory);
   【调用注册的BeanFactoryPostProcessor实现类】
   作用：调用所有注册的 BeanFactoryPostProcessor 实现类，这些处理器可以在 Bean 定义加载完成后、Bean 实例化之前对 Bean 定义进行修改。通过这个步骤，开发者可以动态地修改 Bean 的定义信息。
6. registerBeanPostProcessors(beanFactory);
   【注册 BeanPostProcessor的实现类】【只注册、不调用】
   作用：注册所有的 BeanPostProcessor实现类，这些处理器会在Bean实例化、配置和初始化前后进行额外的处理。例如，AutowiredAnnotationBeanPostProcessor可以处理@Autowired注解，实现自动装配功能
7. initMessageSource();
   【初始化消息源】
   作用：初始化消息源，用于支持国际化和消息解析。这在需要处理多语言的应用程序中非常有用。
8. initApplicationEventMulticaster();
   【初始化应用[事件广播器]】
   [事件广播器]：负责将事件广播给所有注册的监听器。
   [事件发布者（ApplicationEventPublisher）]：负责发布事件
   [事件监听器（ApplicationListener）]：负责监听特定类型的事件
   作用：初始化应用事件广播器，用于发布和监听应用程序中的事件。Spring 的事件机制允许组件之间进行松耦合的通信。
9. onRefresh();
   【留给子类扩展】【空实现】【子类特定的刷新操作】
   作用：允许子类实现特定的刷新逻辑，例如在 WebApplicationContext 中，会创建和初始化 Servlet 上下文。
10. registerListeners();
    【注册监听器】
    作用：注册应用程序中的事件监听器，这些监听器会监听由事件广播器发布的事件，并执行相应的处理逻辑。
11. finishBeanFactoryInitialization(beanFactory);
    【实例化所有剩余的单例 Bean】【Bean 实例化、初始化、BeanPostProcessor的执行】
    作用：实例化所有剩余的单例 Bean，这是 IoC 容器启动的核心步骤之一。在这个过程中，BeanFactory 会根据 Bean 定义创建 Bean 实例，并进行依赖注入和初始化操作。
12. finishRefresh();
    【完成刷新】
    作用：完成容器的刷新工作，清除缓存、发布容器刷新完成事件等。此时，IoC 容器已经完全启动并可以正常使用。

三、refresh()的核心方法/步骤

obtainFreshBeanFactory() - 获取Bean工厂

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {refreshBeanFactory();    // 触发BeanDefinition加载return getBeanFactory();
}

obtainFreshBeanFactory()是Spring容器启动流程中的核心方法，其核心性体现在：

• BeanFactory生命周期起点：负责创建或刷新BeanFactory实例，是IoC容器诞生的起点
• 配置加载入口：触发XML配置的解析流程，将配置转化为可操作的BeanDefinition对象

BeanDefinition加载流程解析

1. 传统Spring项目（XML配置为例）

核心步骤：

• refreshBeanFactory()：销毁旧容器 → 创建DefaultListableBeanFactory → 加载BeanDefinition
• loadBeanDefinitions()：通过XmlBeanDefinitionReader解析XML文件，生成BeanDefinition并注册

源码示例：

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);// ....initBeanDefinitionReader(beanDefinitionReader);loadBeanDefinitions(beanDefinitionReader);
}

2. SpringBoot项目（注解驱动）

• 实现差异：
  • 本质使用GenericApplicationContext代替AbstractRefreshableApplicationContext
  • obtainFreshBeanFactory()仅设置序列化ID，不执行配置加载
• 实际加载入口：
  • ConfigurationClassPostProcessor（后置处理器）扫描@Configuration类
  • @ComponentScan注解触发包扫描，动态注册BeanDefinition

prepareBeanFactory(beanFactory) - 配置 Bean 工厂

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {// 告诉内部 Bean 工厂使用上下文的类加载器等。beanFactory.setBeanClassLoader(getClassLoader());beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));// 注册ApplicationContextAwareProcessor （ApplicationContextAwareProcessor负责处理实现了ApplicationContextAware的类）beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));// // 注册早期后处理器，用于将内部 bean 检测为 ApplicationListeners。beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));// ...// 注册默认的 环境Beanif (!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());}
}

核心配置：

• 设置类加载器
• 添加默认的Bean 后置处理器（例如ApplicationContextAwareProcessor、ApplicationListenerDetector）
• 注册默认的 环境bean

invokeBeanFactoryPostProcessors() - 调用注册的BeanFactoryPostProcessor实现类

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {// 【核心】调用 BeanFactoryPostProcessorsPostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)// ...
}

进入invokeBeanFactoryPostProcessors：

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {// 【 1. 处理所有 BeanDefinitionRegistryPostProcessor（子接口）】if (beanFactory instanceof BeanDefinitionRegistry) {BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =new LinkedList<BeanDefinitionRegistryPostProcessor>();// 分阶段处理：PriorityOrdered → Ordered → 普通实现// 执行 PriorityOrdered invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);// 执行 OrderedinvokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);// 执行 普通实现invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);}else {// Invoke factory processors registered with the context instance.invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);}// ...// 【 2. 处理所有 BeanFactoryPostProcessor】// 分阶段处理：PriorityOrdered → Ordered → 普通实现List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();List<String> orderedPostProcessorNames = new ArrayList<String>();List<String> nonOrderedPostProcessorNames = new ArrayList<String>();for (String ppName : postProcessorNames) {if (processedBeans.contains(ppName)) {// skip - already processed in first phase above}else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {orderedPostProcessorNames.add(ppName);}else {nonOrderedPostProcessorNames.add(ppName);}}// 执行 PriorityOrdered invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);// 执行 OrderedinvokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);// 执行 普通实现invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);// ...
}

具体执行方法：invokeBeanFactoryPostProcessors

/*** 调用给定的BeanFactoryPostProcessor bean。*/
private static void invokeBeanFactoryPostProcessors(Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {for (BeanFactoryPostProcessor postProcessor : postProcessors) {// 执行具体的postProcessBeanFactory方法postProcessor.postProcessBeanFactory(beanFactory);}
}

其中ConfigurationClassPostProcessor是BeanFactoryPostProcessor的子类，会在该阶段执行其后置处理逻辑。负责解析 @Configuration 类及其注解（如 @ComponentScan、@Bean），动态注册新的 BeanDefinition
ConfigurationClassPostProcessor核心功能：

1. 扫描配置类： 识别 @Configuration 类，解析其上的 @ComponentScan、@Import 等注解
2. 处理条件注解： 根据 @Conditional 注解判断是否注册对应的 BeanDefinition

finishBeanFactoryInitialization() - 实例化、初始化所有剩余的单例 Bean【重要】【重要】【重要】

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {// ...// 实例化所有剩余的 （非 lazy-init） 单例。【核心】【重要】【bean实例化 -> 属性填充 -> 初始化】beanFactory.preInstantiateSingletons();
}

finishBeanFactoryInitialization() 方法核心作用总结：

1. 初始化基础服务
   • 设置类型转换服务（ConversionService），处理 @Value 和属性注入的类型转换
2. 冻结 Bean 配置
   • 调用 freezeConfiguration()，停止修改 BeanDefinition，确保后续实例化过程的线程安全
3. 实例化非懒加载单例 Bean
   • 遍历所有 BeanDefinition，触发 getBean() 实例化非抽象、单例且非懒加载的 Bean
   • 特殊处理 FactoryBean：根据 SmartFactoryBean.isEagerInit() 判断是否立即生成目标对象
4. 初始化回调与扩展
   • 触发 SmartInitializingSingleton.afterSingletonsInstantiated()，在所有单例创建完成后执行自定义逻辑
   • 处理 LoadTimeWeaverAware 接口，支持类加载期字节码增强（如 AspectJ LTW）
5. 资源回收与优化
   • 释放临时类加载器（TempClassLoader），避免内存泄漏

该方法涉及 Spring IoC 最复杂的实例化阶段，包括 bean的实例化、属性填充（解决循环依赖）、BeanPostProcesser的前置处理（部分Aware处理逻辑）、bean的初始化、BeanPostProcesser的后置处理（AOP 代理的生成时机）等细节

一篇文章是讲解不清楚finishBeanFactoryInitialization()的，请期待后续总结 ✿ヽ(°▽°)ノ✿