Spring源码之Bean的生命周期

前言

Spring IOC 中的Bean生命周期大致分为四个阶段：实例化、属性赋值、初始化、销毁，如下图所示：

其实核心的阶段就是这些了，但是每个核心的阶段里面又有很细致的划分。

基于BeanPostProcessor的生命周期

首先先给出一个更加详细的流程：

如上图所示，第一步就是实例化一个Bean对象。接下来就是属性赋值，为Bean设置相关属性和依赖。然后到了整个初始化模块，其中5、6是真正的初始化环节，第3、4步为在初始化前执行，第7步在初始化后执行，初始化完成后，Bean就可以被使用了。最后，第8步其实也可以算到销毁阶段，但不是真正意义上的销毁，而是先在使用前注册了销毁的相关调用接口，为了后面第9、10步真正销毁Bean时再执行相应的方法。

以一个实际的例子举例：

java 复制代码

public class PersonBean implements InitializingBean,
BeanFactoryAware, BeanNameAware, DisposableBean {
	/**
	* 身份证号
	*/
	private Integer no;
	/**
	* 姓名
	*/
	private String name;

	public PersonBean() {
		System.out.println("1.调用构造方法：我出生了！");
	}
	
	public Integer getNo() {
		return no;
	}
	
	public void setNo(Integer no) {
		this.no = no;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
		System.out.println("2.设置属性：我的名字叫"+name);
	}
	
	@Override
	public void setBeanName(String s) {
		System.out.println("3.调用BeanNameAware#setBeanName方法:我要上学了，起了个学名");
	}
	
	@Override
	public void setBeanFactory(BeanFactory beanFactory)throws BeansException {
		System.out.println("4.调用BeanFactoryAware#setBeanFactory方法：选好学校了");
	}
	
	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("6.InitializingBean#afterPropertiesSet方法：入学登记");
	}
	
	public void init() {
		System.out.println("7.自定义init方法：努力上学ing");
	}
	
	@Override
	public void destroy() throws Exception {
		System.out.println("9.DisposableBean#destroy方法：平淡的一生落幕了");
	}
	
	public void destroyMethod() {
		System.out.println("10.自定义destroy方法:睡了，别想叫醒我");
	}
	
	public void work(){
		System.out.println("Bean使用中：工作，只有对社会没有用的人才放假。。");
	}
}

定义一个MyBeanPostProcessor 实现 BeanPostProcessor 接口。（这个很关键）！！！

java 复制代码

public class MyBeanPostProcessor implements BeanPostProcessor
{
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws 		BeansException {
		System.out.println("5.BeanPostProcessor.postProcessBeforeInitialization方法：到学校报名啦");
	return bean;
	}
	
	@Override
	public Object postProcessAfterInitialization(Object bean,String beanName) throws 	BeansException {
		System.out.println("8.BeanPostProcessor#postProcessAfterInitialization方法：终于毕业，拿到毕业证啦！");
		return bean;
	}
}

配置文件，指定 init-method 和 destroy-method 属性

xml 复制代码

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/bea
ns http://www.springframework.org/schema/beans/spring.beans.xsd">

	<bean name="myBeanPostProcessor"
class="cn.fighter3.spring.life.MyBeanPostProcessor" />
	<bean name="personBean"
class="cn.fighter3.spring.life.PersonBean"
init-method="init" destroy-method="destroyMethod">
		<property name="idNo" value= "80669865"/>
		<property name="name" value="张铁钢" />
	</bean>
</beans>

测试

java 复制代码

public class Main {

	public static void main(String[] args) {
		ApplicationContext context = new
ClassPathXmlApplicationContext("spring-config.xml");
		PersonBean personBean = (PersonBean)context.getBean("personBean");
		personBean.work();
		((ClassPathXmlApplicationContext) context).destroy();
	}
}

运行结果

csharp 复制代码

1.调用构造方法：我出生了！
2.设置属性：我的名字叫张铁钢
3.调用BeanNameAware#setBeanName方法:我要上学了，起了个学名
4.调用BeanFactoryAware#setBeanFactory方法：选好学校了
5.BeanPostProcessor#postProcessBeforeInitialization方法：到学校
报名啦
6.InitializingBean#afterPropertiesSet方法：入学登记
7.自定义init方法：努力上学ing
8.BeanPostProcessor#postProcessAfterInitialization方法：终于毕
业，拿到毕业证啦！
Bean使用中：工作，只有对社会没有用的人才放假。。
9.DisposableBean#destroy方法：平淡的一生落幕了
10.自定义destroy方法:睡了，别想叫醒我

以上就是Bean的生命周期，但是其实并不完整。首先从头来分析：

PersonBean 实现了四个接口，分别是InitializingBean、BeanFactoryAware、BeanFactoryAware、BeanFactoryAware。这些接口中分别只有一个方法，分别是 afterPropertiesSet（）、setBeanName（）、setBeanFactory（）、destroy（）

其实这四个方法重写之后能够和生命周期映射起来，如下图所示：

而抛开图中所圈的三个以及 BeanPostProcesser前置处理、BeanPostProcesser后置处理外，剩下的其实就是生命周期的四大阶段了。

PersonBean 实现的四个接口就是基于四大阶段的一个扩展了。

再回到MyBeanPostProcessor，这个前面说了很关键，其实在图中并结合上面例子的输出也可以看到，实际上与BeanPostProcesser前置处理、BeanPostProcesser后置处理有关，MyBeanPostProcessor 实现了 BeanPostProcessor的两个方法，其实就是初始化的前置和后置了，结合起来其实就构成了完成的生命周期。

基于BeanPostProcessor实现类的生命周期

但是BeanPostProcessor是一个接口，有两个实现类扩展了它，分别是InstantiationAwareBeanPostProcessor、

DestructionAwareBeanPostProcessor，如下所示：

当进入查看发现InstantiationAwareBeanPostProcessor额外又实现了三个方法，而DestructionAwareBeanPostProcessor额外又实现了一个方法。

java 复制代码

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

    @Nullable
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return null;
    }

    /** @deprecated */
    @Deprecated
    @Nullable
    default PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        return pvs;
    }
}

InstantiationAwareBeanPostProcessor 对BeanPostProcessor进行了扩展，新增了三个方法。postProcessBeforeInstantiation 在实例化bean前调用，可以返回一个替代原始实例化的对象，如果返回非空对象，则会跳过正常的实例化过程。

postProcessAfterInstantiation在实例化 bean 后调用，可以对实例进行进一步的处理，常用于额外的初始化或修改实例属性等操作。

postProcessProperties在完成 bean 实例化和属性填充后调用，可以对属性进行进一步的修改或验证。

java 复制代码

public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {
    void postProcessBeforeDestruction(Object var1, String var2) throws BeansException;

    default boolean requiresDestruction(Object bean) {
        return true;
    }
}

DestructionAwareBeanPostProcessor对BeanPostProcessor进行了扩展，新增了一个方法。

postProcessBeforeDestruction在 bean 销毁前调用此方法，可以在销毁之前做一些清理工作，例如释放资源、断开连接等。

当使用 BeanPostProcessor 的实现类的时候，就是继续包装之前的生命周期：

java 复制代码

@Component
public class LifeCycleBean implements InitializingBean, BeanFactoryAware, BeanNameAware {
    private static final Logger log = LoggerFactory.getLogger(LifeCycleBean.class);

    public LifeCycleBean() {
        log.debug("构造");
    }


    @Autowired
    public void autowire(@Value("${JAVA_HOME}") String home) {
        log.debug("依赖注入: {}", home);
    }



    @PreDestroy
    public void destroy() {
        log.debug("销毁");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        log.debug("调用BeanFactoryAware");
    }

    @Override
    public void setBeanName(String s) {
        log.debug("调用BeanNameAware");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        log.debug("Bean 初始化执行的逻辑InitializingBean");
    }

    @PostConstruct
    public void init() {
        log.debug("初始化");
    }
}

java 复制代码

@Component
public class MyBeanPostProcessor implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor {

    // 两个典型的后置处理器的子接口

    private static final Logger log = LoggerFactory.getLogger(MyBeanPostProcessor.class);

    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean"))
            log.debug("<<<<<< 销毁之前执行, 如 @PreDestroy");
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean"))
            log.debug("<<<<<< 实例化之前执行, 这里返回的对象会替换掉原本的 bean");
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")) {
            log.debug("<<<<<< 实例化之后执行, 这里如果返回 false 会跳过依赖注入阶段");
//            return false;
        }
        return true;
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean"))
            log.debug("<<<<<< 依赖注入阶段执行, 如 @Autowired、@Value、@Resource");
        return pvs;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean"))
            log.debug("<<<<<< 初始化之前执行, 这里返回的对象会替换掉原本的 bean, 如 @PostConstruct、@ConfigurationProperties");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean"))
            log.debug("<<<<<< 初始化之后执行, 这里返回的对象会替换掉原本的 bean, 如代理增强");
        return bean;
    }
}

此时的运行结果如下所示：

java 复制代码

<<<<<< 实例化之前执行, 这里返回的对象会替换掉原本的 bean 
构造
<<<<<< 实例化之后执行, 这里如果返回 false 会跳过依赖注入阶段 
<<<<<< 依赖注入阶段执行, 如 @Autowired、@Value、@Resource 
依赖注入: C:\Program Files\Java\jdk1.8.0_231 
调用BeanNameAware
调用BeanFactoryAware 
<<<<<< 初始化之前执行, 这里返回的对象会替换掉原本的 bean, 如 @PostConstruct、@ConfigurationProperties 
初始化
Bean 初始化执行的逻辑InitializingBean
<<<<<< 初始化之后执行, 这里返回的对象会替换掉原本的 bean, 如代理增强
<<<<<< 销毁之前执行, 如 @PreDestroy
销毁

但是还是存在一些问题，相信细心的人会发现，在这里初始化竟然先于 "是否实现InitailizinBean"实现了，这并不符合生命周期的顺序呀，回顾代码其实可以发现，在代码中执行初始化方法实际上是：

java 复制代码

@PostConstruct
    public void init() {
        log.debug("初始化");
    }

通过阅读，发现原理是这样的：

java 复制代码

	对于Spring的Bean生命周期，@PostConstruct注解和InitializingBean接口的afterPropertiesSet()方法都用于在Bean初始化完成后执行一些逻辑，可以看作是等效的。它们的执行顺序并不是由注解或接口本身决定的，而是由Spring容器的实现决定的。

     当一个Bean被创建并完成属性注入后，Spring容器会调用@PostConstruct注解标记的方法或InitializingBean接口的afterPropertiesSet()方法来执行初始化逻辑。然而，具体的执行顺序是由Spring容器决定的，这取决于容器的实现和配置。

     通常情况下，如果一个Bean同时使用了@PostConstruct注解和实现了InitializingBean接口，那么@PostConstruct注解标记的方法会先于afterPropertiesSet()方法执行。这是因为Spring容器会首先检查Bean是否使用了@PostConstruct注解，并在属性注入完成后立即执行该方法。然后，容器会检查Bean是否实现了InitializingBean接口，并在同一个初始化阶段调用afterPropertiesSet()方法。

     需要注意的是，由于执行顺序是由Spring容器决定的，所以不能依赖于具体的执行顺序来编写代码逻辑。如果需要确保执行顺序，建议将相关逻辑放在一个方法中，并使用一个统一的方式（例如@PostConstruct注解）来标记该方法。

至此，一个更加完整的并且结合 BeanPostProcessor实现类的生命周期主题就已经实现完成了！！！