Spring Bean的生命周期 ---附详细流程图及测试代码
一、生命周期流程图：
Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点
假设一个Bean实现了所有的接口，大的概况一下Bean的生命周期：
1.实例化BeanFactoryPostProcessor：处理的对象是BeanFactory级别
2.实例化BeanPostProcessor实现类
3.实例化InstantiationAwareBeanPostProcessorAdapter实现类，注：该类是BeanPostProcessor的扩展
4.执行InstantiationAwareBeanPostProcessorAdapter类的postProcessBeforeInstantiation方法
5.Bean的构造方法
6.执行InstantiationAwareBeanPostProcessorAdapter类的postProcessPropertyValues
7.为Bean注入属性，即依赖注入
8.调用BeanNameAware的setBeanName方法
9.调用BeanNameAware的setBeanFactory方法
10.执行BeanPostProcessor的后置处理器，postProcessAfterInitialization方法
11.调用InitializingBean的afterPropertiesSet方法
12.调用bean的init-method初始化方法
13.执行BeanPostProcessor的postProcessAfterInitialization
14.执行InstantiationAwareBeanPostProcessorAdapter的后置方法，postProcessAfterInitialization
15.Bean的使用
16.调用DiposibleBean的destory方法
17.调用bean指定的destory-method方法
为了上述流程的正确性，我们可以用代码来测试一下：
测试Bean - StudentBean类：
/**
* 测试生命周期的Bean
* Created by kxm
*/
public class StudentBean implements InitializingBean, DisposableBean, BeanNameAware, BeanFactoryAware {
private String name;
private int age;
private String beanName; //实现了BeanNameAware接口，Spring可以将BeanName注入该属性中
private BeanFactory beanFactory; //实现了BeanFactory接口，Spring可将BeanFactory注入该属性中
public StudentBean(){
System.out.println("【Bean构造方法】学生类的无参构造方法");
}
@Override
public String toString() {
return "StudentBean{" +
"name='" + name + '\'' +
", age=" + age +
", beanName='" + beanName + '\'' +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("【set注入】注入学生的name属性");
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
System.out.println("【set注入】注入学生的age属性");
this.age = age;
}
/**
* 自己编写的初始化方法
*/
public void myInit(){
System.out.println("【init-method】调用init-method属性配置的初始化方法");
}
/**
* 自己编写的销毁方法
*/
public void myDestroy(){
System.out.println("【destroy-method】调用destroy-method属性配置的销毁方法");
}
/**
* BeanFactoryAware接口的方法
* @param beanFactory
* @throws BeansException
*/
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
System.out.println("【BeanFactoryAware接口】调用BeanFactoryAware的setBeanFactory方法得到beanFactory引用");
}
/**
* BeanNameAware接口的方法
* @param name
*/
public void setBeanName(String name) {
this.beanName = name;
System.out.println("【BeanNameAware接口】调用BeanNameAware的setBeanName方法得到Bean的名称");
}
/**
* InitializingBean接口的方法
* @throws Exception
*/
public void afterPropertiesSet() throws Exception {
System.out.println("【InitializingBean接口】调用InitializingBean接口的afterPropertiesSet方法");
}
/**
* DisposableBean接口的方法
* @throws Exception
*/
public void destroy() throws Exception {
System.out.println("【DisposableBean接口】调用DisposableBean接口的destroy方法");
}
}MyBeanFactoryPostProcessor工厂处理器类：
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public MyBeanFactoryPostProcessor() {
System.out.println("【BeanFactoryPostProcessor接口】调用BeanFactoryPostProcessor实现类构造方法");
}
/**
* 重写BeanFactoryPostProcessor接口的postProcessBeanFactory方法，可通过该方法对beanFactory进行设置
*/
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException {
System.out.println("【BeanFactoryPostProcessor接口】调用BeanFactoryPostProcessor接口的postProcessBeanFactory方法");
}
}MyInstantiationAwareBeanPostProcessor类：
/**
* 一般情况下，当我们需要实现InstantiationAwareBeanPostProcessor接口时，是通过继承Spring框架中InstantiationAwareBeanPostProcessor接口实现类
* InstantiationAwareBeanPostProcessorAdapter这个适配器类来简化我们实现接口的工作
*/
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
public MyInstantiationAwareBeanPostProcessor() {
System.out.println("【InstantiationAwareBeanPostProcessor接口】调用InstantiationAwareBeanPostProcessor构造方法");
}
/**
* 实例化Bean之前调用
*/
public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
System.out.println("【InstantiationAwareBeanPostProcessor接口】调用InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法");
return null;
}
/**
* 实例化Bean之后调用
*/
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("【InstantiationAwareBeanPostProcessor接口】调用InstantiationAwareBeanPostProcessor接口的postProcessAfterInitialization方法");
return bean;
}
/**
* 设置某个属性时调用
*/
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException {
System.out.println("【InstantiationAwareBeanPostProcessor接口】调用InstantiationAwareBeanPostProcessor接口的postProcessPropertyValues方法");
return pvs;
}
}MyBeanPostProcessor类：
/**
* Created by kxm
*/
public class MyBeanPostProcessor implements BeanPostProcessor {
public MyBeanPostProcessor(){
System.out.println("【BeanPostProcessor接口】调用BeanPostProcessor的构造方法");
}
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("【BeanPostProcessor接口】调用postProcessBeforeInitialization方法，这里可对"+beanName+"的属性进行更改。");
return bean;
}
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("【BeanPostProcessor接口】调用postProcessAfterInitialization方法，这里可对"+beanName+"的属性进行更改。");
return bean;
}
}XML配置：
测试类：
public class TestCyclelife {
/**
* Created by yanxiao on 2016/8/1.
*/
public static void main(String[] args){
System.out.println("--------------【初始化容器】---------------");
ApplicationContext context = new ClassPathXmlApplicationContext("Springlife.xml");
System.out.println("-------------------【容器初始化成功】------------------");
//得到studentBean，并显示其信息
StudentBean studentBean = context.getBean("studentBean",StudentBean.class);
System.out.println(studentBean);
System.out.println("--------------------【销毁容器】----------------------");
((ClassPathXmlApplicationContext)context).registerShutdownHook();
}
}测试结果如下：
符合上述的Bean的生命周期，至此，Bean的生命周期问题已基本解决，不过还等待着你继续去深入。