Bean的生命周期

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

对于上面的图补充一点，在BeaFactoryAware's setBeanFactory()和Pre-initialization BeanPostProcessor之间还应该有一步：调用ApplicationContextAware的setApplicationContext()方法。

从上图中可以看到Bean生命周期要经历很多阶段，但这些阶段大部分都是可选的。例如，某个Bean如果实现了BeanFactoryAware接口的setBeanFactory方法，那么该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中打个断点，来看看方法调用栈

这里需要提醒一下，看Spring的源码是很繁琐的，很容易让人陷入细节中出不来，因此要抓住重点代码，梳理出整体脉络，而不应该也不要过分扣细节

这里主要来看看AbstractAutowireCapableBeanFactory的doCreateBean方法，在该方法中有这么一段代码

//对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的生命周期过程，但不包括两个销毁阶段

 // 创建Bean 
 new Bean();
 // 给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);
 }

小结

在Spring中，Bean的生命周期是很长的一个过程，中间有好多步骤，每一个步骤都能对bean进行控制。了解这个过程对我们阅读Spring源码、对扩展Spring都有很好的帮助。