【Spring】Bean的生命周期，部分源码解释

Bean 的生命周期

生命周期指的是一个对象从诞生到销毁的整个生命过程，我们把这个过程就叫做一个对象的声明周期

Bean 的声明周期分为以下 5 个部分：

1. 实例化（为 Bean 分配空间）
2. 属性赋值（Bean 注入和装配，比如 @Autowired）
3. 初始化
   1. 执行各种通知，如 BeanNameAware，BeanFactoryAware，ApplicationContextAware 的接口方法
   2. 执行初始化方法
      • xml 定义 init-method
      • 使用注解的方式 @PostConstruct
      • 执行初始化后置方法（BeanPostProcessor）
4. 使用 Bean
5. 销毁 Bean
   • 销毁容器的各种方法，如 @PreDestory，DisposableBean 接口方法，destory-method

执行流程

• 实例化和属性赋值对应构造方法和 setter 方法的注入。
• 初始化和销毁是用户能自定义扩展的两个阶段
• 可以在实例化之后，类加载完成之前进行自定义“事件”处理

比如我们现在需要买一栋房子，那么我们的流程是这样的

1. 先买房（实例化，从无到有）
2. 装修（设置属性）
3. 买家电，如洗衣机，冰箱，电视，空调等（[各种]初始化，可以注入）
4. 入住（使用 Bean）
5. 卖房（Bean 销毁）

执行流程如下图所示：

代码演示

@Component  
public class BeanLifeComponent implements BeanNameAware {  
  
    private UserComponent userComponent;  
  
    public BeanLifeComponent() {  
        System.out.println("执行构造函数");  
    }  
  
    public void setUserComponent(UserComponent userComponent) {  
        System.out.println("设置属性 userComponent");  
        this.userComponent = userComponent;  
    }  
  
    @Override  
    public void setBeanName(String s) {  
        System.out.println("执行了 setBeanName 方法：" + s);  
    }  
  
    /**  
     * 初始化  
     */  
    @PostConstruct  
    public void postConstruct() {  
        System.out.println("执行 postConstruct()");  
    }  
  
    public void use() {  
        System.out.println("执行了 use 方法");  
    }  
  
    /**  
     * 销毁前执行方法  
     */  
    public void preDestroy() {  
        System.out.println("执行：preDestroy()");  
    }  
}

执行结果

通过运行结果观察：

1. 先执行构造函数
2. 设置属性
3. Bean 初始化
4. 使用 Bean
5. 销毁 Bean

源码阅读

以上步骤在源码中皆有体现

AbstractAutowireCapableBeanFactory

创建 Bean 的代码入口在 AbstractAutowireCapableBeanFactory#createBean

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
    implements AutowireCapableBeanFactory {

    protected Object createBean(String beanName, RootBeanDefinition mbd,
        @Nullable Object[] args) throws BeanCreationException {
        
        //...代码省略
        try {
            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            // 在实例化之前，是否有快捷创建的Bean，也就是通过 PostProcessorsBeforeInstantiation返回的Bean
            // 如果存在，则会替代原来正常通过target bean生成的bean的流程
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(),
                beanName,
                "BeanPostProcessor before instantiation of bean failed", ex);
        }

        try {
            // 创建Bean
            // 方法中包含了实例化、属性赋值、初始化过程
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isTraceEnabled()) {
                logger.trace("Finished creating instance of bean '" + beanName + "'!");
            }
            return beanInstance;
        }
        //...代码省略
    }
}

doCreateBean

点进去继续看源码：doCreateBean#createBean

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {

    // Instantiate the bean.
    if (instanceWrapper == null) {
        // 1. 实例化阶段：通过反射调用构造函数/工厂方法
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // 2. 属性填充阶段：依赖注入（@Autowired/@Value等）
        populateBean(beanName, mbd, instanceWrapper);
        
        // 3. 初始化阶段：Aware接口回调、init-method、PostProcessor处理
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
        // 4. 异常处理：区分是否已标记为BeanCreationException
        if (ex instanceof BeanCreationException && 
            beanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        }
        else {
            throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }

    return exposedObject;
}

这三个方法与三个生命周期阶段一一对应

1. createBeanInstance() ->实例化
2. populateBean() ->属性赋值
3. initializeBean() ->初始化

initializeBean

继续点进去：initializeBean

// 初始化 Bean
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {  
    this.invokeAwareMethods(beanName, bean);  
    Object wrappedBean = bean;  
    if (mbd == null || !mbd.isSynthetic()) {  
        wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);  
    }  
  
    try {  
        this.invokeInitMethods(beanName, wrappedBean, mbd);  
    } catch (Throwable ex) {  
        throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, ex.getMessage(), ex);  
    }  
  
    if (mbd == null || !mbd.isSynthetic()) {  
        wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);  
    }  
  
    return wrappedBean;  
}  
// 调用的三个 Bean 开头的 Aware 方法
private void invokeAwareMethods(String beanName, Object bean) {  
    if (bean instanceof Aware) {  
        if (bean instanceof BeanNameAware) {  
            BeanNameAware beanNameAware = (BeanNameAware)bean;  
            beanNameAware.setBeanName(beanName);  
        }  
  
        if (bean instanceof BeanClassLoaderAware) {  
            BeanClassLoaderAware beanClassLoaderAware = (BeanClassLoaderAware)bean;  
            ClassLoader bcl = this.getBeanClassLoader();  
            if (bcl != null) {  
                beanClassLoaderAware.setBeanClassLoader(bcl);  
            }  
        }  
  
        if (bean instanceof BeanFactoryAware) {  
            BeanFactoryAware beanFactoryAware = (BeanFactoryAware)bean;  
            beanFactoryAware.setBeanFactory(this);  
        }  
    }  
  
}