Spring Bean 的生命周期

在Spring中，可以从两个层面定义Bean的生命周期。下面分别对BeanFactory和ApplicationContext中Bean的生命周期进行分析。
一、BeanFactory中Bean的生命周期

具体过程如下
1）当调用者调用getBean(beanName)向容器请求某一个Bean时，如果容器注册了InstantiationAwareBeanPostProcessor接口，则在实例化Bean之前，将调用接口的postProcessBeforeInstantiation()方法。

（2）根据配置情况调用Bean的构造函数或工厂方法实例化Bean。

（3）如果容器注册了InstantiationAwareBeanPostProcessor接口，在实例化Bean之后，调用该接口的postProcessBeforeInstantiation()方法，对实例化的对象进行一些初始化设置。

（4）如果Bean 配置了属性信息，那么容器在这一步将配置的属性设置到Bean对应的属性中，在设置属性之前将先调用InstantiationAwareBeanPostProcessor接口的postProcessPropertyValues()方法。

（5）调用Bean中的setXxx()方法设置属性。

（6）如果Bean实现了BeanNameAware接口，则会调用该接口的setBeanName()方法，将配置文件中该Bean对应的名称设置到Bean中。

（7）如果Bean实现了BeanFactoryAware接口，则会调用该接口的setBeanFactory()方法，将BeanFactory容器实例设置到Bean中。

（8）如果BeanFactory装配了BeanPostProcessor后处理器，则将调用BeanPostProcessor接口的Object postProcessBeforeInitialization方法对Bean进行加工操作。其中，传入的bean是当前正在处理的bean，而beanName是当前Bean在配置文件中的配置名，返回加工处理后的bean。用户可以使用该方法对某些Bean进行特殊的处理。Spring容器所提供的AOP、动态代理等功能都通过BeanPostProcessor实现。

（9）如果Bean实现了InitializingBean接口，则将调用该接口的afterPropertiesSet()方法。

（10）如果在配置文件的bean标签中通过init-method属性指定了初始化方法，则会执行这个方法。

（11）如果BeanFactory装配了BeanPostProcessor后处理器，在这里则会执行Object postProcessAfterInitialization()方法对Bean进行加工处理。

BeanPostProcessor后处理器定义了两个方法，分别是postProcessBeforeInitialization()和postProcessAfterInitialization()，分别在第8步和在此处调用。

（12）如果在配置文件中指定了bean的scope=”prototype”，意味着配置的这个bean是多例的，每次获取该bean都会返回一个新实例化的bean，所以在这一步之后Spring容器不再管理多例的Bean，直接将当前生成的实例返回给用户。

对于scope=”singleton”的Bean（默认情况），意味着这个Bean是单例的，就需要把这个Bean缓存到在Spring IOC容器中，用户每次获取时都从这个容器中获取，并且Spring会对这些Bean进行后续的生命周期管理。

（13）对于单例的Bean，容器关闭时，会触发Spring对Bean的后续生命周期的管理工作。如果Bean实现了DisposableBean接口，则会调用该接口的destroy()方法，在这里可以进行释放资源、记录日志等操作。

（14）对于单例的Bean，如果在配置文件中指定了destroy-method属性，Spring则会执行这个属性配置的方法，完成Bean资源释放等操作。

以上生命周期所经历的方法大致可以分为四类

a、Bean自身的方法

包括实例化Bean时Bean的构造方法，设置属性值时Bean的set方法，以及通过配置文件配置的init-method和destroy-method指定的方法。

b、Bean级生命周期接口方法

包括BeanNameAware、BeanFactoryAware、InitializingBean和DisposableBean，这些接口方法由Bean直接实现。

c、容器级生命周期接口方法

包括InstantiationAwareBeanPostProcessor和BeanPostProcessor两个接口。一般称他们的实现类为后处理器，后处理器接口一般不由Bean本身实现，他们独立于Bean，实现类以容器附加装置的形式注册到Spring容器中，并通过接口反射为Spring容器扫描识别。当Spring容器创建任何Bean时，这些后处理器都会起作用，这些后处理器的影响是全局性的。

d、工厂后处理器接口方法

包括AspectJWeavingEnabler、CustomAutowireConfigurer、ConfigurationClassPostProcessor等类，都实现了BeanFactoryPostProcessor接口。工厂后处理器也是容器级的，在应用上下文装配配置文件后立即调用。

Spring容器中还可以注册多个后处理器，只要他们都实现了Ordered接口，Spring容器就会按照特定的顺序依次调用这些后处理器。

Bean的生命周期实例如下：
首先是Bean类，让它实现所有bean生命周期接口。此外，还定义了初始化和销毁方法，这两个方法将通过的init-method和destroy-method属性指定。

package com.spring;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class Car implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {
    private String brand;
    private String color;
    private int maxSpeed;

    private BeanFactory beanFactory;
    private String beanName;

    public Car() {
        System.out.println("调用Car构造函数");
    }

    public void setBrand(String brand) {
        System.out.println("调用setBrand()设置属性");
        this.brand = brand;
    }

    public void introduce() {
        System.out.println("brand:" + brand + ";color:" + color + ";maxSpeed" + maxSpeed);
    }

    //调用BeanFactoryAware接口方法
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        System.out.println("调用BeanFactoryAware.setBeanFactory().");
        this.beanFactory = beanFactory;
    }

    //调用BeanNameAware接口方法
    @Override
    public void setBeanName(String beanName) {
        System.out.println("调用BeanNameAware.setBeanName().");
        System.out.println("---------------" + beanName + "-------------------");
        this.beanName = beanName;
    }

    //InitializingBean接口方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("调用InitializingBean.afterPropertiesSet().");
    }

    //DisposableBean接口方法
    @Override
    public void destroy() throws Exception {
        System.out.println("调用DisposableBean.destroy().");
    }

    //通过的init-method属性指定初始化方法
    public void myInit() {
        System.out.println("调用init-method所指定的myInit(),将maxSpeed设置为240.");
        this.maxSpeed = 240;
    }

    //通过的destroy-method实行指定销毁方法`
    public void myDestroy() {
        System.out.println("调用destroy-method所指定定的mDestroy().");
    }

    public String getBrand() {
        return brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getMaxSpeed() {
        return maxSpeed;
    }

    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }

    public BeanFactory getBeanFactory() {
        return beanFactory;
    }

    public String getBeanName() {
        return beanName;
    }
}

MyInstantiationAwareBeanPostProcessor通过扩展InstantiationAwareBeanPostProcessor适配器InstantiationAwareBeanPostProcessorAdapter提供实现。

package com.spring;

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

import java.beans.PropertyDescriptor;

public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {

    @Override
    public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        if("car".equals(beanName)){
            System.out.println("MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation");
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if("car".equals(beanName)){
            System.out.println("InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation");
        }
        return true;
    }

    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        if("car".equals(beanName)){
            System.out.println("InstantiationAwareBeanPostProcessor.postProcessPropertyValues");
        }
        return pvs;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

最后提供一个BeanPostProcessor的实现类。

package com.spring;

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

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("car".equals(beanName)) {
            Car car = (Car) bean;
            if (car.getColor() == null) {
                System.out.println("调用BeanPostProcessor.postProcessBeforeInitialization(),color为空,设置为默认黑色");
                car.setColor("黑色");
            }
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("car".equals(beanName)) {
            Car car = (Car) bean;
            if (car.getMaxSpeed() >= 200) {
                System.out.println("调用BeanPostProcessor.postProcessAfterInitialization(),将maxSpeed调整为200.");
                car.setMaxSpeed(200);
            }
        }
        return bean;
    }
}

最后在xml文件中配置bean

最后查看bean的实例流程

package com.spring;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class BeanLifeCycle {
    private static void LifeCycleInBeanFactory() {
        Resource res = new ClassPathResource("applicationContext.xml");
        BeanFactory bf = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((DefaultListableBeanFactory) bf);
        reader.loadBeanDefinitions(res);
        ((ConfigurableBeanFactory) bf).addBeanPostProcessor(new MyBeanPostProcessor());
        ((ConfigurableBeanFactory) bf).addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());
        Car car1 = (Car) bf.getBean("car");
        car1.introduce();
        car1.setColor("红色");

        Car car2 = (Car) bf.getBean("car");
        System.out.println("car1==car2:" + (car1 == car2));

        ((DefaultListableBeanFactory)bf).destroySingletons();
    }

    public static void main(String[] args) {
        LifeCycleInBeanFactory();
    }
}

最后可以看到会输出以下信息。

MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation
调用Car构造函数
InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation
InstantiationAwareBeanPostProcessor.postProcessPropertyValues
调用setBrand()设置属性
调用BeanNameAware.setBeanName().
---------------car-------------------
调用BeanFactoryAware.setBeanFactory().
调用BeanPostProcessor.postProcessBeforeInitialization(),color为空,设置为默认黑色
调用InitializingBean.afterPropertiesSet().
调用init-method所指定的myInit(),将maxSpeed设置为240.
调用BeanPostProcessor.postProcessAfterInitialization(),将maxSpeed调整为200.
brand:红旗CA72;color:黑色;maxSpeed200
car1==car2:true
调用DisposableBean.destroy().
调用destroy-method所指定定的mDestroy().

ApplicationContext中Bean的生命周期

具体过程与上述BeanFactory中Bean的生命周期类似，这里不再详解。

参考：https://blog.csdn.net/qq_32651225/article/details/78323527