跳至主要內容

Spring 源码学习-理解Bean的生命周期

科哒大约 4 分钟

Bean的生命周期流程图

一、容器启动的基石：ApplicationContext.refresh()

源码入口：AbstractApplicationContext.refresh()
这是Spring容器初始化的核心方法，包含12个关键步骤：

// 核心代码路径：spring-context/src/main/java/org/springframework/context/support/AbstractApplicationContext.java

public void refresh() {
    // 1. 准备上下文环境
    prepareRefresh();
    
    // 2. 初始化BeanFactory（重要！）
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    // 3. 配置标准环境
    prepareBeanFactory(beanFactory);
    
    // 4. 后置处理BeanFactory（BeanFactoryPostProcessor执行处）
    postProcessBeanFactory(beanFactory);
    
    // 5. 执行BeanFactoryPostProcessor
    invokeBeanFactoryPostProcessors(beanFactory);
    
    // 6. 注册BeanPostProcessor
    registerBeanPostProcessors(beanFactory);
    
    // 7. 初始化MessageSource
    initMessageSource();
    
    // 8. 初始化事件广播器
    initApplicationEventMulticaster();
    
    // 9. 特殊Bean的初始化（如子类实现）
    onRefresh();
    
    // 10. 注册监听器
    registerListeners();
    
    // 11. 初始化所有单例Bean（核心阶段！）
    finishBeanFactoryInitialization(beanFactory);
    
    // 12. 完成刷新
    finishRefresh();
}

二、Bean生命周期的核心流程

源码主路径：DefaultListableBeanFactory.preInstantiateSingletons() → AbstractBeanFactory.getBean() → AbstractAutowireCapableBeanFactory.createBean()

阶段1：实例化前处理（Pre-Instantiation）

关键接口：InstantiationAwareBeanPostProcessor
源码入口：AbstractAutowireCapableBeanFactory.createBean()

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // 1. 实例化前处理（可能返回代理对象）
    Object bean = resolveBeforeInstantiation(beanName, mbd);
    if (bean != null) return bean;
    
    // 进入标准创建流程
    return doCreateBean(beanName, mbd, args);
}

// 实例化前处理逻辑
protected Object resolveBeforeInstantiation(...) {
    // 调用InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
    Object result = applyBeanPostProcessorsBeforeInstantiation(...);
    if (result != null) {
        result = applyBeanPostProcessorsAfterInitialization(result, beanName);
    }
    return result;
}
阶段2：实例化（Instantiation）

源码入口：AbstractAutowireCapableBeanFactory.doCreateBean()

protected Object doCreateBean(...) {
    // 1. 实例化对象（可能使用反射或CGLIB）
    Object instance = createBeanInstance(beanName, mbd, args);
    
    // 2. 提前暴露早期引用（解决循环依赖）
    if (earlySingletonExposure) {
        addSingletonFactory(beanName, () -> getEarlyBeanReference(...));
    }
    
    // 后续处理...
}

实例化策略：

  • 反射：SimpleInstantiationStrategy.instantiate()
  • CGLIB：CglibSubclassingInstantiationStrategy.instantiate()
阶段3：属性填充（Population）

关键接口：InstantiationAwareBeanPostProcessor.postProcessProperties()
源码入口：AbstractAutowireCapableBeanFactory.populateBean()

protected void populateBean(...) {
    // 1. 属性注入前处理
    if (hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                // 处理@Autowired/@Value等注解
                PropertyValues pvs = ((InstantiationAwareBeanPostProcessor) bp).postProcessProperties(pvs, bean, beanName);
            }
        }
    }
    
    // 2. 自动装配（按名称/类型）
    if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
        autowireByName(beanName, mbd, bw, newPvs);
        autowireByType(beanName, mbd, bw, newPvs);
    }
    
    // 3. 应用属性值
    applyPropertyValues(beanName, mbd, bw, pvs);
}
阶段4：初始化（Initialization）

源码入口：AbstractAutowireCapableBeanFactory.initializeBean()

protected Object initializeBean(...) {
    // 1. Aware接口处理
    invokeAwareMethods(beanName, bean);
    
    // 2. 初始化前处理（BeanPostProcessor.preProcessBeforeInitialization）
    Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
    
    // 3. 初始化方法执行
    invokeInitMethods(beanName, wrappedBean, mbd);
    
    // 4. 初始化后处理（BeanPostProcessor.postProcessAfterInitialization）
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    
    return wrappedBean;
}

详细步骤：

  1. Aware接口注入：
    • BeanNameAware.setBeanName()
    • BeanFactoryAware.setBeanFactory()
    • ApplicationContextAware.setApplicationContext()
  2. BeanPostProcessor前置处理：
    • 执行所有BeanPostProcessor.postProcessBeforeInitialization()
    • 典型应用：ApplicationContextAwareProcessor处理环境变量注入
  3. 初始化方法调用顺序：
    • @PostConstruct标注的方法
    • InitializingBean.afterPropertiesSet()
    • XML中配置的init-method
  4. BeanPostProcessor后置处理：
    • 执行所有BeanPostProcessor.postProcessAfterInitialization()
    • 典型应用：AOP代理生成（AbstractAutoProxyCreator）
阶段5：销毁（Destruction）

源码入口：DisposableBeanAdapter.destroy()

public void destroy() {
    // 1. 销毁前处理（@PreDestroy）
    if (!CollectionUtils.isEmpty(this.preDestroyMethods)) {
        invokeCustomDestroyMethod(this.preDestroyMethods);
    }
    
    // 2. DisposableBean接口实现
    if (this.destroyMethod != null) {
        this.destroyMethod.invoke();
    }
    
    // 3. 自定义销毁方法
    if (this.destroyMethodName != null) {
        Method methodToCall = determineDestroyMethod();
        methodToCall.invoke(this.bean);
    }
}

三、关键扩展点源码定位

  1. BeanFactoryPostProcessor
    • 执行入口：PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()
    • 典型实现：ConfigurationClassPostProcessor（处理@Configuration类）
  2. BeanPostProcessor
    • 注册入口：PostProcessorRegistrationDelegate.registerBeanPostProcessors()
    • 执行顺序：根据PriorityOrdered/Ordered接口排序
  3. InitializingBean
    • 调用位置：AbstractAutowireCapableBeanFactory.invokeInitMethods()
  4. Aware接口
    • 处理位置：AbstractAutowireCapableBeanFactory.invokeAwareMethods()

四、循环依赖解决机制

三级缓存结构：

// 源码位置：DefaultSingletonBeanRegistry
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);          // 一级缓存（完整Bean）
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);         // 二级缓存（对象工厂）
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);      // 三级缓存（早期引用）

解决流程：

  1. 创建Bean A时，实例化后通过addSingletonFactory()将ObjectFactory放入二级缓存
  2. 填充属性时发现需要Bean B，触发Bean B的创建
  3. 创建Bean B时同样将ObjectFactory放入二级缓存
  4. 当Bean B需要注入Bean A时，从二级缓存获取ObjectFactory创建早期引用
  5. Bean A完成初始化后，存入一级缓存并清除二、三级缓存

五、学习建议

  1. 调试技巧：
    • 在AbstractApplicationContext.refresh()设置断点
    • 跟踪DefaultListableBeanFactory.preInstantiateSingletons()执行过程
  2. 核心类重点阅读：
    • AbstractAutowireCapableBeanFactory（创建Bean的核心逻辑）
    • DefaultSingletonBeanRegistry（单例管理及三级缓存实现）
    • PostProcessorRegistrationDelegate（后置处理器执行协调）
  3. 可视化工具辅助：
    • 使用IDEA的Diagram功能查看Bean生命周期相关类的继承关系
    • 开启Spring的调试日志：logging.level.org.springframework=DEBUG

掌握Bean生命周期源码后，您将能够：
✅ 精准定位Bean创建过程中的各种异常
✅ 自定义高级扩展点实现特殊需求
✅ 优化Spring应用的启动速度和内存占用
✅ 深入理解Spring Boot自动配置原理

Copyright © 2025 科哒