1. 概述
一个普通对象的生命周期有：
Spring对象的周期肯定也会遵守这个过程，但是Spring这个功能强大的轻量级框架提供了很多对外的接口，允许我们程序员对这三个过程（实例化，初始化，销毁）的前后增加一些操作。
在Spring Bean中，实例化其实是在为bean对象在容器里开辟空间，初始化则是对属性的注入。
2. 具体生命周期
-
先实例化 BeanFactoryPostProcessor(Bean工厂后处理器)
Bean创建之前，读取Bean的元属性，并根据自己的需求对元属性进行改变，比如将Bean的scope从singleton改变为prototype。
-
调用 BeanFactoryPostProcessor 的 postProcessBeanFactory 方法
此方法只会执行一次,并且携带了每个bean的基本信息。
-
实例化 BeanPostProcessor（Bean后处理器）
即调用setter方法。
-
实例化 InstantiationAwareBeanPostProcessorAdapter（后处理器适配器 ）
-
调用 InstantiationAwareBeanPostProcessorAdapter 的 postProcessBeforeInitialization 方法
这个方法能有效地抑制目标bean的默认实例化，返回的是要公开的bean对象而不是目标bean的默认实例，或要处理默认实例化的null。 -
执行Bean构造器，开始实例化Bean
-
调用 InstantiationAwareBeanPostProcessorAdapter 的 postProcessAfterInitialization 方法
这是在给定bean实例上执行字段注入的理想回调，如果应该在bean上设置属性，则为true;如果应该跳过属性填充，则为false。正常的实现应该返回true。返回false还将防止在此bean实例上调用任何后续的InstantiationAwareBeanPostProcessor实例。 -
调用 InstantiationAwareBeanPostProcessorAdapter 的 postProcessPropertyValues方法
扫描带有注解的字段和方法，并注入到Bean中。
-
给已经实例化的bean注入属性值
-
调用 BeanFactoryAware 的 setBeanName 方法
让Bean对象获取自己在BeanFactory配置中的name或者id，但是这个时候还不能被getBean
-
调用 BeanFactoryAware 的 setBeanFactory方法
可以在该Bean被加载的过程中获取加载该Bean的BeanFactory，同时也可以获取这个BeanFactory中加载的其它Bean
-
调用 BeanPostProcessor 的 postProcessBeforeInitialization 方法在bean初始化前对bean对象属性，bean对象的name等进行自定义处理。
-
调用 InitializingBean 的 afterPropertiesSet 方法
在Bean的属性都设置值后被调用，用于完成初始化工作。
-
调用的init-method属性指定的初始化方法。
-
调用 BeanPostProcessor 的 postProcessAfterInitialization方法在bean初始化后对bean对象属性，bean对象的name等进行自定义处理。
-
正常调用方法
-
调用 DisposableBean 的 destroy 方法
用于做一些销毁的收尾工作
-
调用的 destroy-method 属性指定的销毁方法
3. 大致流程图
4. 代码实现
BeanFactoryPostProcessor
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public MyBeanFactoryPostProcessor() {
super();
System.out.println("实例化 BeanFactoryPostProcessor 实现类");
}
@Override
public void postProcessBeanFactory
(ConfigurableListableBeanFactory configurableListableBeanFactory)
throws BeansException {
System.out.println("执行 BeanFactoryPostProcessor 的 postProcessBeanFactory方法");
}
}
BeanPostProcessor
public class MyBeanPostProcessor implements BeanPostProcessor {
public MyBeanPostProcessor() {
super();
System.out.println("实例化 BeanPostProcessor 实现类");
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("执行 BeanPostProcessor 的 postProcessBeforeInitialization 方法");
return null;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("执行 BeanPostProcessor 的 postProcessAfterInitialization 方法");
return null;
}
}
InstantiationAwareBeanPostProcessorAdapter
public class MyInstantiationAwareBeanPostProcessorAdapter extends
InstantiationAwareBeanPostProcessorAdapter {
public MyInstantiationAwareBeanPostProcessorAdapter() {
super();
System.out.println("实例化 InstantiationAwareBeanPostProcessorAdapter 实现类");
}
@Override
public Object postProcessBeforeInstantiation
(Class<?> beanClass, String beanName)
throws BeansException {
System.out.println("执行 InstantiationAwareBeanPostProcessorAdapter 的 postProcessBeforeInitialization 方法");
return super.postProcessBeforeInstantiation(beanClass, beanName);
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName)
throws BeansException {
System.out.println("执行 InstantiationAwareBeanPostProcessorAdapter 的 postProcessAfterInitialization 方法");
return super.postProcessAfterInstantiation(bean, beanName);
}
@Override
public PropertyValues postProcessPropertyValues
(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException {
System.out.println("执行 InstantiationAwareBeanPostProcessorAdapter 的 postProcessPropertyValues 方法");
return super.postProcessPropertyValues(pvs, pds, bean, beanName);
}
}
Person
public class Person implements BeanFactoryAware, BeanNameAware,
InitializingBean, DisposableBean {
public Person() {
System.out.println("执行 Bean 的构造器");
}
private String name;
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("为Bean注入属性");
this.name = name;
}
public void user(){
System.out.println("正常调用");
}
@Override
public void setBeanFactory(BeanFactory beanFactory)
throws BeansException {
System.out.println("调用 BeanFactoryAware 的 setBeanFactory 方法");
}
@Override
public void setBeanName(String s) {
System.out.println("调用 BeanFactoryAware 的 setBeanName 方法");
}
@Override
public void destroy() throws Exception {
System.out.println("调用 DisposableBean 的 destroy 方法");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("调用 InitializingBean 的 afterPropertiesSet 方法");
}
public void myInit(){
System.out.println("调用<bean>的 init-method 属性指定的初始化方法");
}
public void myDestroy(){
System.out.println("调用<bean>的 destroy-method 属性指定的销毁方法");
}
}
applicationContext.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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="com.MyBeanPostProcessor"></bean>
<bean class="com.MyInstantiationAwareBeanPostProcessorAdapter"></bean>
<bean class="com.MyBeanFactoryPostProcessor"></bean>
<bean class="com.Person" id="person" init-method="myInit" destroy-method="myDestroy">
<property name="name" value="name"></property>
</bean>
</beans>
测试
public class Main {
public static void main(String[] args) {
ApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = application.getBean("person", Person.class);
person.user();
System.out.println("开始销毁容器");
((ClassPathXmlApplicationContext) application).close();
}
}
运行结果
实例化 BeanFactoryPostProcessor 实现类
执行 BeanFactoryPostProcessor 的 postProcessBeanFactory方法
实例化 BeanPostProcessor 实现类
实例化 InstantiationAwareBeanPostProcessorAdapter 实现类
执行 InstantiationAwareBeanPostProcessorAdapter 的 postProcessBeforeInitialization 方法
执行 Bean 的构造器
执行 InstantiationAwareBeanPostProcessorAdapter 的 postProcessAfterInitialization 方法
执行 InstantiationAwareBeanPostProcessorAdapter 的 postProcessPropertyValues 方法
为Bean注入属性
调用 BeanFactoryAware 的 setBeanName 方法
调用 BeanFactoryAware 的 setBeanFactory 方法
执行 BeanPostProcessor 的 postProcessBeforeInitialization 方法
调用 InitializingBean 的 afterPropertiesSet 方法
调用<bean>的 init-method 属性指定的初始化方法
执行 BeanPostProcessor 的 postProcessAfterInitialization 方法
正常调用
开始销毁容器
调用 DisposableBean 的 destroy 方法
调用<bean>的 destroy-method 属性指定的销毁方法
Process finished with exit code 0
5. 依赖
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.1.RELEASE</version>
</dependency>
</dependencies>
6. 项目结构
