Spring IoC容器与Bean生命周期源码解析

IoC 容器是 Spring 框架的核心，理解 Bean 生命周期是掌握 Spring 的关键。

IoC 容器体系结构

核心接口层次

BeanFactory (顶层接口)
    └── HierarchicalBeanFactory
            └── ConfigurableBeanFactory
                    └── AbstractBeanFactory
                            └── AbstractAutowireCapableBeanFactory
                                    └── DefaultListableBeanFactory

ApplicationContext (高级容器)
    └── ConfigurableApplicationContext
            └── AbstractApplicationContext
                    └── GenericApplicationContext
                            └── AnnotationConfigApplicationContext

BeanFactory vs ApplicationContext

容器启动流程

AnnotationConfigApplicationContext 初始化

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    // 1. 注册 Bean 后置处理器
    this();
    // 2. 注册配置类
    register(componentClasses);
    // 3. 刷新容器（核心）
    refresh();
}

refresh() 核心流程

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 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();

            // 10. 注册监听器
            registerListeners();

            // 11. 实例化所有非懒加载单例 Bean
            finishBeanFactoryInitialization(beanFactory);

            // 12. 完成刷新
            finishRefresh();
        } catch (BeansException ex) {
            destroyBeans();
            cancelRefresh(ex);
            throw ex;
        }
    }
}

Bean 生命周期完整流程

生命周期阶段

1. 实例化
   ↓
2. 属性赋值
   ↓
3. 初始化
   ├─ Aware 接口回调
   ├─ BeanPostProcessor.postProcessBeforeInitialization()
   ├─ @PostConstruct
   ├─ InitializingBean.afterPropertiesSet()
   ├─ @Bean(initMethod)
   └─ BeanPostProcessor.postProcessAfterInitialization()
   ↓
4. 使用
   ↓
5. 销毁
   ├─ @PreDestroy
   ├─ DisposableBean.destroy()
   └─ @Bean(destroyMethod)

源码核心方法：doCreateBean()

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 1. 实例化 Bean
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);

    // 2. 应用合并后的 BeanDefinition
    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

    // 3. 属性赋值
    populateBean(beanName, mbd, instanceWrapper);

    // 4. 初始化 Bean
    exposedObject = initializeBean(beanName, exposedObject, mbd);

    return exposedObject;
}

各阶段详解

1. 实例化阶段

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 1. 工厂方法创建
    if (mbd.getFactoryMethodName() != null) {
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }

    // 2. 构造函数推断
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }

    // 3. 默认构造函数
    return instantiateBean(beanName, mbd);
}

2. 属性赋值阶段

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    // 1. @Autowired 等注解处理
    if (hasInstAwareBpps) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                pvs = ((InstantiationAwareBeanPostProcessor) bp)
                    .postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
            }
        }
    }

    // 2. 属性注入
    applyPropertyValues(beanName, mbd, bw, pvs);
}

3. 初始化阶段

protected Object initializeBean(String beanName, Object bean, RootBeanDefinition mbd) {
    // 1. Aware 接口回调
    invokeAwareMethods(beanName, bean);

    Object wrappedBean = bean;

    // 2. BeanPostProcessor.postProcessBeforeInitialization()
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

    // 3. 初始化方法
    invokeInitMethods(beanName, wrappedBean, mbd);

    // 4. BeanPostProcessor.postProcessAfterInitialization()
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

    return wrappedBean;
}

Aware 接口回调

private void invokeAwareMethods(String beanName, Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanClassLoaderAware) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(this);
        }
    }
}

生命周期示例

完整生命周期演示

@Component
public class LifecycleBean implements
        BeanNameAware, BeanFactoryAware, ApplicationContextAware,
        InitializingBean, DisposableBean {

    private static final Logger log = LoggerFactory.getLogger(LifecycleBean.class);

    // 1. 构造函数
    public LifecycleBean() {
        log.info("1. 构造函数");
    }

    // 2. BeanNameAware
    @Override
    public void setBeanName(String name) {
        log.info("2. BeanNameAware: {}", name);
    }

    // 3. BeanFactoryAware
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        log.info("3. BeanFactoryAware");
    }

    // 4. ApplicationContextAware
    @Override
    public void setApplicationContext(ApplicationContext ctx) {
        log.info("4. ApplicationContextAware");
    }

    // 5. @PostConstruct
    @PostConstruct
    public void postConstruct() {
        log.info("5. @PostConstruct");
    }

    // 6. InitializingBean
    @Override
    public void afterPropertiesSet() {
        log.info("6. InitializingBean.afterPropertiesSet");
    }

    // 7. 自定义 init-method
    public void customInit() {
        log.info("7. customInit-method");
    }

    // 8. @PreDestroy
    @PreDestroy
    public void preDestroy() {
        log.info("8. @PreDestroy");
    }

    // 9. DisposableBean
    @Override
    public void destroy() {
        log.info("9. DisposableBean.destroy");
    }

    // 10. 自定义 destroy-method
    public void customDestroy() {
        log.info("10. customDestroy-method");
    }
}

BeanPostProcessor 扩展点

自定义 BeanPostProcessor

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if (bean instanceof LifecycleBean) {
            log.info("BeanPostProcessor.before: {}", beanName);
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof LifecycleBean) {
            log.info("BeanPostProcessor.after: {}", beanName);
        }
        return bean;
    }
}

常见 BeanPostProcessor

Bean 的作用域

Prototype Bean 生命周期

@Scope(scopeName = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Component
public class PrototypeBean {
    // Spring 不管理完整的销毁流程
    // 需要手动销毁或使用 ObjectProvider
}

要点总结