Bean的生命周期

相比于我们自己创建的bean的生命周期（通过new关键字实例化，不再使用了就被回收），Spring容器中bean的生命周期是比较复杂的。先看看下面Bean生命周期的图。

图片来源于网络

bean生命周期(来源网络)

下面来看看一个经历上面全部生命周期阶段的bean如何实现。首先定义Bean对象同时实现下列接口BeanNameAware,BeanFactoryAware,ApplicationContextAware,InitializingBean,DisposableBean

@Component
public class Car implements BeanNameAware,BeanFactoryAware,ApplicationContextAware,
        InitializingBean,DisposableBean {
    //Seat也是一个简单的bean对象
    private Seat seat;

    public Car(){
        System.out.println("car instance...");
    }

    public Seat getSeat() {
        return seat;
    }

    @Autowired
    public void setSeat(Seat seat) {
        System.out.println("填充属性");
        this.seat = seat;
    }

    /**
     * 自定义的初始化方法
     */
    public void init(){
        System.out.println("car ... init...");
    }

    /**
     * 自定义的销毁方法
     */
    public void detory(){
        System.out.println("car ... detory...");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println(s);
        System.out.println("BeanNameAware...setBeanName()");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("DisposableBean...setBeanFactory()");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("ApplicationContextAware...setApplicationContext()");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean...afterPropertiesSet()");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("InitializingBean...destroy()");
    }
}

有了自定义初始化方法和销毁方法之后，还需要对其进行配置一下，可以在配置器类中通过@Bean(initMethod="init",destroyMethod="detory")来指定，或者直接在方法上添加@PostConstruct或者@PreDestroy注解。

    //对象创建并赋值之后调用
    @PostConstruct
    public void init(){
        System.out.println("car....@PostConstruct...");
    }
    
    //容器移除对象之前
    @PreDestroy
    public void detory(){
        System.out.println("car....@PreDestroy...");
    }

然后再定义一个Bean的后置处理器(BeanPostProcessor)。

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization..."+beanName+"..."+bean);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization..."+beanName+"..."+bean);
        return bean;
    }

}

最后写个测试类，观察运行结果

@Test
public void test(){
    //1、创建ioc容器
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
    System.out.println("容器创建完成...");
    applicationContext.getBean("car");
    //关闭容器
    applicationContext.close();
}

输出结果为：

car instance...
填充属性
BeanNameAware...setBeanName()
DisposableBean...setBeanFactory()
ApplicationContextAware...setApplicationContext()
postProcessBeforeInitialization...car...cn.zgc.spring.annotation.beans.Car@22b49166
InitializingBean...afterPropertiesSet()
car ... init...
postProcessAfterInitialization...car...cn.zgc.spring.annotation.beans.Car@22b49166
容器创建完成...
InitializingBean...destroy()
car ... detory...

查看输出结果可以看到，Car的生命周期和上面的图吻合。

生命周期构建原理

要探究原理就必须得看看Spring源码中是如何实现的，我们在自定义的Bean后置处理器MyBeanPostProcessor中打个断点，跟一下源码。先来看看方法调用栈

Bean构建方法调用栈

//对bean进行实例化
if (mbd.isSingleton()) {
    instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
    instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
......
try {
    // 对bean的属性进行填充
    this.populateBean(beanName, mbd, instanceWrapper);
    if (exposedObject != null) {
        exposedObject = this.initializeBean(beanName, exposedObject, mbd);
    }
}

继续看看initializeBean方法中都做了些什么

//回调实现了xxxAware接口中的方法
this.invokeAwareMethods(beanName, bean);
......    
//调用BeanPostProcessor的postProcessorsBeforeInitialization方法
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
......
try {
    //调用初始化方法(自定义的初始化方法或者实现InitialzingBean接口)
    invokeInitMethods(beanName, wrappedBean, mbd);
}catch (Throwable ex) {
    ....
}

if (mbd == null || !mbd.isSynthetic()) {
    //调用BeanPostProcessor的postProcessorsAfterInitialization方法
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}

下面我们再结合源码，用伪代码的形式给出Bean的生命周期过程(不包括两个销毁阶段)

 new Bean();
 populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
 initializeBean() {
    applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
     {
        if(bean instanceof InitializingBean){
            ((InitializingBean) bean).afterPropertiesSet();
        }
        if(mbd.getInitMethodName()!=null){ //自定义初始化方法执行
            invokeCustomInitMethod(beanName, bean, mbd);
        }
     }
    applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 }

参考

[1].Spring中Bean的生命周期及其扩展点