spring bean的生命周期

原创基础上修改，建议参考

Spring 作为当前 Java 最流行、最强大的轻量级框架，受到了程序员的热烈欢迎。准确的了解 Spring Bean 的生命周期是非常必要的。我们通常使用 ApplicationContext 作为 Spring 容器。这里，我们讲的也是 ApplicationContext 中 Bean 的生命周期。而实际上 BeanFactory 也是差不多的，只不过处理器需要手动注册。

转载请注明地址 http://www.cnblogs.com/zrtqsk/p/3735273.html，

一、生命周期流程图：

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

img img

若容器注册了以上各种接口，程序那么将会按照以上的流程进行。下面将仔细讲解各接口作用。

二、各种接口方法分类

Bean 的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类：

1、Bean 自身的方法　　：　　这个包括了 Bean 本身调用的方法和通过配置文件中 <bean> 的 init-method 和 destroy-method 指定的方法

2、Bean 级生命周期接口方法　　：　　这个包括了 BeanNameAware、BeanFactoryAware、InitializingBean 和 DiposableBean 这些接口的方法

3、容器级生命周期接口方法　　：　　这个包括了 InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为 “后处理器”。

4、工厂后处理器接口方法　　：　　这个包括了 AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer 等等非常有用的工厂后处理器　　接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。这些处理器一般处理beandifinition,因为此时bean还没有实例化.

三、演示

我们用一个简单的 Spring Bean 来演示一下 Spring Bean 的生命周期。

1、首先是一个简单的 Spring Bean，调用 Bean 自身的方法和 Bean 级生命周期接口方法，为了方便演示，它实现了 BeanNameAware、BeanFactoryAware、InitializingBean 和 DiposableBean 这 4 个接口，同时有 2 个方法，对应配置文件中@Bean的 init-method 和 destroy-method。如下：

package com.hisense.smartstation.beantest;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;

import java.io.Serializable;

/**
 * @ClassName: Student
 * @Description: TODO
 * @Create by: gaozhen
 * @Date: 2022/3/3 15:49
 */
@ConfigurationProperties(prefix = "stu")
public class Student implements Serializable, InitializingBean, DisposableBean, BeanFactoryAware, BeanNameAware {
    public Student() {
        System.out.println("Student.constructor");
    }
    @Autowired
    BirthDay birthDay;

    private String name;
    private String sex;
    private int age;
    public void init(){
        System.out.println("Student.init");
    }

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

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

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

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

    public String getName() {
        System.out.println("Student.getName");
        return name;
    }

    public void setName(String name) {
        System.out.println("Student.setName");
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

2、接下来是演示 BeanPostProcessor 接口的方法，如下：

package com.hisense.smartstation.beantest;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

/**
 * @ClassName: StudentBeanPostProcessor
 * @Description: 初始化前后
 * @Create by: gaozhen
 * @Date: 2022/3/2 9:24
 */
@Component
public class StudentBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof Student){
            System.out.println("BeanPostProcessor.postProcessBeforeInitialization");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof Student) {
            System.out.println("BeanPostProcessor.postProcessAfterInitialization");
        }
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

如上，BeanPostProcessor 接口包括 2 个方法 postProcessAfterInitialization 和 postProcessBeforeInitialization，这两个方法的第一个参数都是要处理的 Bean 对象，第二个参数都是 Bean 的 name。返回值也都是要处理的 Bean 对象。这里要注意。

3、InstantiationAwareBeanPostProcessor 接口本质是 BeanPostProcessor 的子接口，一般我们继承 Spring 为其提供的适配器类 InstantiationAwareBeanPostProcessor Adapter 来使用它，如下：

package com.hisense.smartstation.beantest;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
import org.springframework.stereotype.Component;

/**
 * @ClassName: StudentInstantiationBeanPostProcessor
 * @Description: InstantiationAwareBeanPostProcessorAdapter实现了InstantiationAwareBeanPostProcessor
 * 用来进行bean实例化前，后，属性注入等工作。
 * @Create by: gaozhen
 * @Date: 2022/3/3 10:37
 */
@Component
public class StudentInstantiationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
    /**
     * bean实例化之前调用
     * @param beanClass
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (beanClass.equals(Student.class)) {
            System.out.println("InstantiationBeanPostProcessor.BeforeInstantiation()");
        }
        return super.postProcessBeforeInstantiation(beanClass, beanName);
    }

    /**
     * bean实例化以后调用
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if (bean.getClass().equals(Student.class)) {
            System.out.println("InstantiationBeanPostProcessor.AfterInstantiation()");
        }
        return super.postProcessAfterInstantiation(bean, beanName);
    }

    /**
     * 此处可以进行依赖注入等，@autowired,@resource等注解，都是通过调用此方法进行的依赖注入
     * 相关参考：
     * @autowired使用AutowiredAnnotationBeanPostProcessor#postProcessProperties()方法
     * @resource使用CommonAnnotationBeanPostProcessor#postProcessProperties()方法
     * CommonAnnotationBeanPostProcessor进行注入，他们都是实现了InstantiationAwareBeanPostProcessor接口
     * @param pvs
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if (bean.getClass()== Student.class) {
            System.out.println("InstantiationBeanPostProcessor.processProperties()");
        }

        return super.postProcessProperties(pvs, bean, beanName);
    }

    /**
     * 初始化前
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean.getClass().equals(Student.class)) {
            System.out.println("InstantiationBeanPostProcessor.BeforeInitialization()");
        }
        return super.postProcessBeforeInitialization(bean, beanName);
    }

    /**
     * 初始化后
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean.getClass().equals(Student.class)) {
            System.out.println("InstantiationBeanPostProcessor.AfterInitialization()");
        }
        return super.postProcessAfterInitialization(bean, beanName);
    }
}

这个有 3 个方法，其中第二个方法 postProcessAfterInitialization 就是重写了 BeanPostProcessor 的方法。第三个方法 postProcessPropertyValues 用来操作属性，返回值也应该是 PropertyValues 对象。

4、注入对象BirthDay

package com.hisense.smartstation.beantest;

import org.springframework.stereotype.Component;

/**
 * @ClassName: BirthDay
 * @Description: TODO
 * @Create by: gaozhen
 * @Date: 2022/3/3 14:16
 */
@Component
public class BirthDay {
    String birth = "20220303";
}

这里添加一个被注入的对象给Student,主要是为了查看BirthDay这个bean是何时被注入的,参考AutowiredAnnotationBeanPostProcessor#postProcessProperties()方法,是在Student的bean实例化以后,通过AutowiredAnnotationBeanPostProcessor#postProcessProperties()注入的,此处可添加条件断点查看.

image-20220303162602676

5、工厂后处理器接口方法BeanFactoryPostProcessor，如下：

 1 package springBeanTest;
 2 
 3 import org.springframework.beans.BeansException;
 4 import org.springframework.beans.factory.config.BeanDefinition;
 5 import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
 6 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 7 
 8 public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
 9 
10     public MyBeanFactoryPostProcessor() {
11         super();
12         System.out.println("这是BeanFactoryPostProcessor实现类构造器！！");
13     }
14 
15     @Override
16     public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0)
17             throws BeansException {
18         System.out
19                 .println("BeanFactoryPostProcessor调用postProcessBeanFactory方法");
20         BeanDefinition bd = arg0.getBeanDefinition("person");
21         bd.getPropertyValues().addPropertyValue("phone", "110");
22     }
23 
24 }

5、配置文件如下 beans.xml，很简单，使用 ApplicationContext, 处理器不用手动注册：

package com.hisense.smartstation.beantest;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @ClassName: StudentConfiguration
 * @Description: TODO
 * @Create by: gaozhen
 * @Date: 2022/3/3 15:56
 */
@Configuration
public class StudentConfiguration {
    @Bean(initMethod = "init",destroyMethod = "destroy")
    public Student getStudent(){
        return new Student();
    }
}

6、yml配置：

stu:
  age: 20
  name: testuser

执行结果

bean factory post processor called
InstantiationBeanPostProcessor.BeforeInstantiation()
Student.constructor
InstantiationBeanPostProcessor.AfterInstantiation()
InstantiationBeanPostProcessor.processProperties()
BeanNameAware.setBeanName
BeanFactoryAware.setBeanFactory
Student.setName
BeanPostProcessor.postProcessBeforeInitialization
InstantiationBeanPostProcessor.BeforeInitialization()
InitializingBean.afterPropertiesSet
Student.init
BeanPostProcessor.postProcessAfterInitialization
InstantiationBeanPostProcessor.AfterInitialization()

image-20220303162528850 image.png