先说结论

Spring IOC 容器的启动,主线只有一条:把"配置"变成 BeanDefinition,再由 BeanDefinition 实例化出单例 Bean。不管入口是 ClassPathXmlApplicationContext 还是 AnnotationConfigApplicationContext,核心都收敛到 AbstractApplicationContext#refresh() 这一个模板方法。读懂 refresh() 的执行顺序,再对照 doCreateBean() 的实例化三部曲,IOC 启动的全貌就掌握了。

再补一条读源码的定位原则:“注册期"和"实例化期"是两个独立阶段。注册期决定"容器里有哪些 BeanDefinition”,实例化期决定"这些定义怎么变成对象"。线上出问题时先归类——是 Bean 没注册上(扫描路径、条件注解、imports 文件的问题),还是 Bean 创建失败(依赖缺失、初始化回调抛异常),两类问题的排查入口完全不同,混在一起看只会绕远路。

从一行代码开始

AnnotationConfigApplicationContext context =
        new AnnotationConfigApplicationContext(AppConfig.class);

构造方法里依次做了三件事:

  1. 实例化容器:调用父类构造器,创建出底层的 DefaultListableBeanFactory(它就是 IOC 的"仓库",BeanDefinition 和单例对象都存在这里);
  2. 解析配置类:把 AppConfig.class 包装成 BeanDefinition 注册进去,后续由 ConfigurationClassPostProcessor 解析 @ComponentScan、@Import、@Bean 等注解,扫描出的类全部转成 BeanDefinition 注册到容器;
  3. 调用 refresh():执行容器刷新的完整流程。

三个入口的差异只在"配置怎么进来":XML 时代靠 ClassPathXmlApplicationContext 解析 XML 文件,注解时代靠 AnnotationConfigApplicationContext 读配置类,Spring Boot 则是 SpringApplication.run() 在两者之上再包一层(监听器、Environment 准备、自动装配)。底层仓库 DefaultListableBeanFactory 与 refresh() 流程在三种入口下完全一致——学 IOC 源码,学的是这套与入口无关的公共主干,学会了换任何入口都不迷路。

值得注意的是第 2 步:配置类本身也是 BeanDefinition,而负责解析配置类的 ConfigurationClassPostProcessor 恰恰是一个 BeanFactoryPostProcessor——“用 BFPP 解析配置、再注册更多 BeanDefinition"这个自举设计,是理解整个注册期的钥匙。配置类解析并不是在构造方法里一口气完成的,构造方法只是把解析器挂上,真正的解析发生在 refresh() 内部的第 4 步。

refresh() 的关键步骤

refresh() 是典型的模板方法,生产中最常打交道的几步如下(节选自 Spring 源码,保留真实方法名):

public void refresh() {
    // 1. 准备工作:记录启动时间、初始化环境属性、校验必需属性
    prepareRefresh();
    // 2. 拿到 BeanFactory(Annotation 场景就是第一步创建的那个)
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    // 3. BeanFactory 前置加工:注册 Environment、添加 ApplicationContextAwareProcessor 等
    prepareBeanFactory(beanFactory);
    // 4. 执行 BeanFactoryPostProcessor:ConfigurationClassPostProcessor 在这里生效,
    //    完成配置类解析与 BeanDefinition 注册(这是"注册期"的核心)
    invokeBeanFactoryPostProcessors(beanFactory);
    // 5. 注册 BeanPostProcessor:AOP 的 AnnotationAwareAspectJAutoProxyCreator 在这里注册
    registerBeanPostProcessors(beanFactory);
    // 6. 初始化 MessageSource、事件广播器等基础设施
    // 7. 实例化所有非懒加载的单例 Bean
    finishBeanFactoryInitialization(beanFactory);
    // 8. 发布 ContextRefreshedEvent,启动收尾
    finishRefresh();
}

这里有个高频面试点:BeanFactoryPostProcessor(BFPP)在所有普通 Bean 之前执行,它看到的是 BeanDefinition 而不是 Bean 实例;BeanPostProcessor(BPP)注册于第 5 步,之后创建的每个 Bean 都会经过它的 postProcessBeforeInitialization / postProcessAfterInitialization,AOP 代理就是在 BPP 里"偷梁换柱"生成的。

由此推出一条铁律:BFPP 里不能随便调 getBean。第 4 步执行时 BPP 还没注册,此时触发的提前实例化会绕过所有 BPP——AOP、@Async、@PostConstruct 的处理链都还没挂上,产出的就是裸对象,而且这个裸对象会被放进单例缓存,后续正常流程拿到的永远是它。

// 错误写法:在 BFPP 里调用 getBean 做"启动校验"
public class EncryptCheckPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        EncryptService service = beanFactory.getBean(EncryptService.class);
        // 灾难:EncryptService 在 BPP 注册前被提前实例化,
        // 它身上的 AOP 代理、@PostConstruct 初始化全部被跳过,
        // 后续所有注入点拿到的都是这个"半成品"缓存对象
    }
}

// 正确写法:BFPP 只操作 BeanDefinition,运行期验证挪到启动完成后
public class EncryptConfigPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 只读取、修改 BeanDefinition(占位符替换、改构造参数、动态注册新定义)
        BeanDefinition bd = beanFactory.getBeanDefinition("encryptService");
        bd.getPropertyValues().add("keySource", "kms");
        // 运行期验证放到 ApplicationRunner / ContextRefreshedEvent 监听里做,
        // 那时全部单例已就绪、BPP 链已完整
    }
}

单例 Bean 的出生三部曲

finishBeanFactoryInitialization() 最终调用 preInstantiateSingletons(),对每个非懒加载单例走 getBean() → doGetBean() → doCreateBean(),后者是实例化核心三部曲:

  1. createBeanInstance():根据 BeanDefinition 选构造器,反射创建出原始对象(此时属性全是 null);
  2. populateBean():属性填充,@Autowired、@Resource 的依赖注入就发生在这里;依赖的 Bean 尚未创建时,这里会递归触发对方的完整创建流程(循环依赖的问题也从这个递归里产生);
  3. initializeBean():依次执行 Aware 回调 → BeanPostProcessor#postProcessBeforeInitialization → @PostConstruct / InitializingBean#afterPropertiesSet / init-method → postProcessAfterInitialization(AOP 代理在最后一步生成并替换返回值)。

生产完成后放入 singletonObjects 一级缓存,之后所有 getBean() 直接命中缓存,不再重复创建。

两点补充:一是 preInstantiateSingletons() 按注册顺序逐个实例化,第一个 Bean 的创建就可能递归拉起一串依赖,启动日志里 BeanCreationException 的根因往往藏在链路深处,要看 “Caused by” 的最底层;二是 getBean() 可能返回的并不是 Bean 本身,而是 FactoryBean 的产品(加 & 前缀才能拿到工厂自己),MyBatis 的 Mapper、Feign 的代理对象都是经 FactoryBean 进入容器的——排查"容器里的对象类型和我写的不一样"时先想到这一层。

初始化回调的先后顺序值得专门记一遍,排查"初始化逻辑没执行"类问题时按这条链对表:

@Component
public class LifecycleDemo implements BeanNameAware, InitializingBean {

    public LifecycleDemo() {
        System.out.println("1. 构造器:对象已创建,属性还是 null");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("2. Aware 回调:容器基础设施就位");
    }

    @PostConstruct
    public void afterInject() {
        System.out.println("3. @PostConstruct:依赖注入已完成,可以安全初始化");
    }

    @Override
    public void afterPropertiesSet() {
        System.out.println("4. InitializingBean:紧跟 @PostConstruct 执行");
    }
    // 5. 自定义 init-method(@Bean(initMethod = "..."),最后执行)
    // 6. BeanPostProcessor#postProcessAfterInitialization —— AOP 代理在此生成
}

扩展点时序对照

想插手容器启动,先选对扩展点。不同扩展点能操作的对象、能拿到的上下文完全不同:

扩展点触发时机操作对象典型用途
BeanFactoryPostProcessor所有普通 Bean 之前(refresh 第 4 步)BeanDefinition占位符替换、动态注册 Bean、调整扫描范围
BeanPostProcessor#before每个 Bean 初始化回调之前Bean 实例解析自定义注解、补充处理逻辑
BeanPostProcessor#after每个 Bean 初始化回调之后Bean 实例生成 AOP / @Async 代理
Aware 系列回调populateBean 之后Bean 实例拿到 BeanFactory、ApplicationContext 等基础设施
ApplicationRunner / ContextRefreshedEvent全部单例就绪后完整容器启动校验、预热缓存、加载数据

一句话记住选型:改"定义"用 BFPP,改"实例"用 BPP,用"成品"做启动校验用 Runner。选错扩展点的典型症状是拿不到完整上下文——在 BFPP 里想注入别的 Bean、在 BPP#before 里想拿代理对象,都是时机错配,代码看起来能跑,行为却是错的。

实战提示

  • 启动慢先查扫描范围:ConfigurationClassPostProcessor 要扫描全量 class,@ComponentScan 包路径写得太宽(比如直接扫 com)是启动慢的常见原因;宽扫描还会把依赖 jar 里不相关的类拉进候选,拖慢后续的条件评估;
  • getBean 的触发时机:@Lazy 的 Bean 在第一次使用时才走 doCreateBean,所以有些依赖注入问题只在运行期暴露;给 @Lazy Bean 排障时,别在启动日志里找它的初始化痕迹;
  • 启动失败的读日志顺序:先找 BeanCreationException(实例化期问题),再看 UnsatisfiedDependencyException(依赖缺口),最后看 BFPP 抛出的异常(注册期问题)——异常类型直接指示问题处在哪个阶段;
  • 扩展点选型:想插手"注册期"用 BFPP,想插手"每个 Bean 的创建"用 BPP,两者时机不同,选错扩展点会拿不到完整上下文。

生产案例

某次新服务接入公司的统一配置加密组件,团队写了一个自定义 BeanFactoryPostProcessor,在 postProcessBeanFactory 里直接 getBean 校验加密 Bean 能否正常解密。结果一批 Bean 在 BPP 注册完成前就被提前实例化,AOP 代理没有生成,带 @Transactional 的 Bean 以裸对象状态进入缓存——测试环境没有装配完整 AOP 组件所以没有暴露,到预发环境事务全部失效。定位过程:对比正常环境与故障环境打印的 bean.getClass(),故障环境缺少 CGLIB 代理类名,立刻锁定提前实例化。修复方式是把"校验"退回"只修改 BeanDefinition”,把运行期验证挪进 ApplicationRunner。这次事故沉淀下来的规约是:BFPP 阶段出现的任何 getBean 调用都按红色告警处理,评审必拦。