Bean 的生命周期
—— BeanFactory 中 Bean 的生命周期
1 生命周期图解
BeanFactory 中 Bean 的生命周期.png
在图中带“★”的步骤是由 InstantiationAwareBeanPostProcessor 和 BeanPostProcess 这两个接口实现的，一般称它们的实现为“后处理器”。实现类以容器附加装置的形式注册到 Spring 容器中，并通过接口反射为 Spring 容器扫描识别。这些后处理器的影响是全局性的，即当 Spring 容器创建任何 Bean 的时候，这些后处理器都会发生作用！
2 Bean 生命周期实例
2.1 实现各种生命周期控制访问的 Car
package org.sysu.SpringTest;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
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("2、调用 Car()，实例化");
}
public String getColor() {
return this.color;
}
public void setColor(String color) {
this.color = color;
}
public int getMaxSpeed() {
return this.maxSpeed;
}
public void setMaxSpeed(int maxSpeed) {
this.maxSpeed = maxSpeed;
}
public void setBrand(String brand) {
System.out.println("5、调用 setBrand()");
this.brand = brand;
}
public void introduce() {
System.out.println("brand: " + color + "; color: " + color + " maxSpeed: " + maxSpeed);
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("7、实现 BeanFactoryAware.setBeanFactory() 接口方法，将 BeanFactory 容器实例设置到 Bean 中");
this.beanFactory = beanFactory;
}
@Override
public void setBeanName(String s) {
System.out.println("6、实现 BeanNameAware.setBeanName() 接口方法，将配置文件中该 Bean 对应的名称设置到 Bean 中");
}
@Override
public void destroy() throws Exception {
System.out.println("12、实现 DisposableBean.destroy() 接口方法");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("9、实现 InitializingBean.afterPropertiesSet() 接口方法");
}
public void myInit() {
System.out.println("10、通过 init-method 属性配置的初始化方法");
this.maxSpeed = 240;
}
public void myDestroy() {
System.out.println("13、通过 destroy-method 属性配置的销毁方法");
}
}
2.2 InstantiationAwareBeanPostProcessor 实现类
package org.sysu.SpringTest;
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("1、调用 InstantiationAwareBeanPostProcessorAdapter.postProcessBeforeInitialization() 方法");
}
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
if ("car".equals(beanName)) {
System.out.println("3、调用 InstantiationAwareBeanPostProcessorAdapter.postProcessAfterInitialization() 方法");
}
return true;
}
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
if ("car".equals(beanName)) {
System.out.println("4、调用 InstantiationAwareBeanPostProcessorAdapter.postProcessPropertyValues() 方法");
}
return pvs;
}
}
2.3 BeanPostProcessor 实现类
package org.sysu.SpringTest;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPostProcessor implements BeanPostProcessor {
/**
* @param o 当前正在处理 Bean
* @param s 当前 Bean 的配置名
* @return java.lang.Object
*/
@Override
public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
if (s.equals("car")) {
Car car = (Car)o;
if (car.getColor() == null) {
System.out.println("8、调用 BeanPostProcessor.postProcessBeforeInitialization()，color为空，设置为黑");
car.setColor("黑色");
}
}
return o;
}
@Override
public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
if (s.equals("car")) {
Car car = (Car)o;
if (car.getMaxSpeed() >= 200) {
System.out.println("11、调用 BeanPostProcessor.postProcessAfterInitialization()，若速度大于200，则调整为200");
car.setMaxSpeed(200);
}
}
return o;
}
}
2.4 配置 Car： Beans.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" xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="car" class="org.sysu.SpringTest.Car"
init-method="myInit"
destroy-method="myDestroy"
p:brand="AE86"
p:maxSpeed="250" />
</beans>
2.5 容器装载配置文件，注册后处理器
package org.sysu.SpringTest;
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;
public class BeanLifeCycle {
public static void LifeCycleInBeanFactory() {
// 装载配置文件并启动容器
ClassPathResource res = new ClassPathResource("org/sysu/SpringTest/Beans.xml");
BeanFactory bf = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((DefaultListableBeanFactory)bf);
reader.loadBeanDefinitions(res);
// 向容器中注册 MyBeanPostProcessor 后处理器
((ConfigurableBeanFactory)bf).addBeanPostProcessor(new MyBeanPostProcessor());
// 向容器中注册 MyInstantiationAwareBeanPostProcessor 后处理器
((ConfigurableBeanFactory)bf).addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());
// 第一次从容器中获取 Car，将触发容器实例化该 Bean，这将引发 Bean 生命周期方法的调用
Car car1 = (Car)bf.getBean("car");
car1.introduce();
car1.setColor("红色");
// 第二次从容器中获取 Car，直接从缓存池中获取
Car car2 = (Car)bf.getBean("car");
// 查看 car1 和 car2 是否指向同一引用
System.out.println("car1 == car2: " + (car1 == car2));
// 关闭容器
((DefaultListableBeanFactory)bf).destroySingletons();
}
public static void main(String args[]) {
LifeCycleInBeanFactory();
}
}
注意在向容器中注册后处理器时，我们对 BeanFactory 类型的 bf 变量进行了强制类型转换，因为用于注册后处理器的 addBeanPostProcessor() 方法是在 ConfigurableBeanFactory 接口中定义的。
如果有多个后处理器，这可以按照相似的方式调用 addBeanPostProcessor() 方法进行注册。后处理器的实际调用顺序与注册顺序无关，在具有多个后处理器的情况下，必须通过实现 org.springframework.core.Ordered接口来确定调用顺序。详见文章《Spring点滴五：Spring中的后置处理器BeanPostProcessor讲解》
2.6 运行结果
BeanFactory 运行结果.png
2.7 将 Bean 的作用范围定义为 prototype
<bean id="car" class="org.sysu.SpringTest.Car"
init-method="myInit"
destroy-method="myDestroy"
scope="prototype"
p:brand="AE86"
p:maxSpeed="250" />
运行结果
BeanFactory prototype.png
由此可知，[singleton] 会将实例化 Car 放入缓存池中，然后再将这个 Bean 引用返回给调用者。当再次从容器获取 car Bean，Bean 将从容器缓存池中直接取出，不会引发生命周期相关方法的执行。
[prototype] 会将准备就绪的 Bean 交给调用者，则第二次 getBean() 时，生命周期方法会再次被调用，因为 prototype 范围的 Bean 每次都返回新的实例。
3 深入剖析
如果用户希望将业务完全 POJO 化，则可以只实现自己的业务接口，不需要和某个特定框架的接口关联（解耦）。可以通过 <bean> 的 init-method 和 destroy-method 属性配置方式为 Bean 指定初始化和销毁方法。而不是通过实现 InitializingBean 和 DisposableBean 接口方式，尽管二者效果完全相同。
一般情况下，用户不需要关心 BeanFactoryAware 和 BeanNameAware 接口。前者让 Bean 感知容器（BeanFactory 实例），而后者让 Bean 获得配置文件对应的配置名称。如果 Bean 希望获取容器中的其他 Bean，则可以通过属性注入的方式引用这些 Bean；如果 Bean 希望在运行期获知配置文件中的 Bean 名称，则可以简单地将名称作为属性注入。
因此，除非编写一个基于 Spring 之上的扩展插件或子项目之类的东西，否则不需要理会以上 4 个 Bean生命周期的接口类。
