Spring Bean的生命周期 ---附详细流程图及测试代码

系统管理员 2022-05-10 02:03 208阅读 0赞

**一、生命周期流程图：**

Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点

![70][]

假设一个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();
        }
    }

测试结果如下：

![70 1][]

符合上述的Bean的生命周期，至此，Bean的生命周期问题已基本解决，不过还等待着你继续去深入。

[70]: /images/20220510/d635c0405f5743528e18079b055d646a.png
[70 1]: /images/20220510/b35e3dc3bcda43aa8403d045e8a2d555.png