BeanFacotry中Bean的生命周期
借用一张图来描述BeanFactory中Bean的生命周期
1.当调用者通过getBean()方法获取某一个bean时,如果容器注册了InstantiationAwareBeanPostProcessor后处理器,则会在bean实例化之前调用该接口的postProcessBeforeInstantiation(Class<?> beanClass, StribeanName)方法
2.实例化bean(一般是根据构造函数实例化,也可以根据工厂方式实例化,可自行选择)
3.如果容器实现了InstantiationAwareBeanPostProcessor接口,则会在bean实例化完成后调用该接口的postProcessAfterINstantiation()方法,然后在设置属性值之前调用该接口的postPorcessPropertyValues()方法
4.为bean实例设置默认的属性值后,如果该bean实现了BeanNameAware接口,则会在设置完属性值后,调用setBeanName()方法,将该bean的名称配置到bean中
5.如果bean实现了BeanFactoryAware接口,则会调用setBeanFacory()方法,将BeanFactory实例设置到bean中
6.如果容器装配了BeanPostProcessor后处理器,会调用该处理器的postProcessBeforeInitialization(Object bean, String beanName)方法
7.如果该bean实现了InitializingBean接口,则会调用该接口的afterPropertiesSet()方法
8.如果在<bean>里使用了init-method属性定义了初始化的方法,则此时会执行这个方法
9.如果容器装配了BeanPostProcessor后处理器,会调用该处理器的postProcessAfterInitialization(Object bean, String beanName)方法
10.如果在<bean>里指定了作用范围为scope=”prototype”,则将bean返回给调用者,由调用者负责bean后续的生命管理,Spring容器不在管理这个bean的生命周期;如果在<bean>里指定了作用范围为scope=”singleton”,则将bean放入到容器的缓存池里,并将bean返回给调用者,Spring容器继续管理这个bean的生命周期
11.对于在<bean>里指定了作用范围为scope=”singleton”的bean,当容器关闭时,会出发Spring容器对bean后续的生命的管理,如果该bean实现了DisposableBean接口,则会调用该接口的destory()方法,如果在<bean>里使用了destory-method属性定义了bean的销毁方法,则会执行这个方法,完成bean的资源释放等操作
简单的例子描述BeanFactory中Bean的生命周期
一个简单的Bean,实现了BeanFactoryAware,BeanNameAware,InitalizingBean,DisposableBean接口
public class NewCar implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {
private String brand;
private String color;
private String maxSpeed;
private BeanFactory beanFactory;
private String beanName;
public NewCar() {
System.out.println("调用NewCar的默认构造函数");
}
public void setBrand(String brand) {
System.out.println("调用setBrand()设置属性");
this.brand = brand;
}
public void setColor(String color) {
this.color = color;
}
public void setMaxSpeed(String maxSpeed) {
this.maxSpeed = maxSpeed;
}
public void introduce() {
System.out.println("brand:" + this.brand + ";color:" + this.color + ";maxSpeed:" + this.maxSpeed);
}
@Override
public void destroy() throws Exception {
System.out.println("调用DisposableBean.destory()方法");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("调用InitialzingBean.afterPropertiesSet()方法");
}
@Override
public void setBeanName(String name) {
System.out.println("调用BeanFactoryAware.setBeanName()方法");
this.beanName = name;
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("调用BeanFactoryAware.setBeanFactory()方法");
this.beanFactory = beanFactory;
}
public void myInit() {
System.out.println("调用init-method所指定的myInit(),将maxSpeed设置为240");
this.maxSpeed = "240";
}
public void myDestory() {
System.out.println("调用destroy-method所指定的myDestory()");
}
}
InstantiationAwareBeanPostProcessor的实现类,Spring提供了一个适配类InstantiationAwareBeanPostProcessorAdapter,可以通过集成这个类来实现InstantiationAwareBeanPostProcessor后处理器
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter{
//在实例化bean之前调用
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
if("newCar".equals(beanName)) {
System.out.println("InstantiationAware BeanPostProcessor.postProcessBeforeInitialization()");
}
return null;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if("newCar".equals(beanName)) {
System.out.println("222InstantiationAware BeanPostProcessor.postProcessBeforeInitialization()");
}
return bean;
}
//在实例化bean后调用
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
if("newCar".equals(beanName)) {
System.out.println("InstantiationAware BeanPostProcessor.postProcessAfterInitialization()");
}
return true;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if("newCar".equals(beanName)) {
System.out.println("222InstantiationAware BeanPostProcessor.postProcessAfterInitialization()");
}
return bean;
}
//在设置某个属性时调用
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean,
String beanName) throws BeansException {
if("newCar".equals(beanName)) {
System.out.println("InstantiationAware BeanPostProcessor.postProcessPropertyValues()");
}
return pvs;
}
}
这里需要注意的是,InstantiationAwareBeanPostProcessor是BeanPostProcessor的子接口,所以上面的实现类中会有两个postProcessBeforeInstantiation和postProcessAfterInstantiation方法
//在实例化bean之前调用
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
if("newCar".equals(beanName)) {
System.out.println("InstantiationAware BeanPostProcessor.postProcessBeforeInitialization()");
}
return null;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if("newCar".equals(beanName)) {
System.out.println("222InstantiationAware BeanPostProcessor.postProcessBeforeInitialization()");
}
return bean;
}
//在实例化bean后调用
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
if("newCar".equals(beanName)) {
System.out.println("InstantiationAware BeanPostProcessor.postProcessAfterInitialization()");
}
return true;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if("newCar".equals(beanName)) {
System.out.println("222InstantiationAware BeanPostProcessor.postProcessAfterInitialization()");
}
return bean;
}
可以根据参数的不同区分,前者会在bean实例化之前和之后执行,后者会在上面描述的第6步和第9步执行
BeanPostProcessor的实现类
public class MyBeanPostPorcessor implements BeanPostProcessor{
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if("newCar".equals(beanName)) {
NewCar newCar = (NewCar) bean;
System.out.println("调用BeanPostProcessor.postProcessBeforeInitialization,把newCar的颜色改为绿色");
newCar.setColor("绿色");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if("newCar".equals(beanName)) {
NewCar newCar = (NewCar) bean;
System.out.println("调用BeanPostProcessor.postProcessAfterInitialization,把newCar的速度改为300");
newCar.setMaxSpeed("300");
}
return bean;
}
}
配置文件bean.xml
<!-- init-method指定初始化时调用的方法,destory-method指定销毁时调用的方法 -->
<bean id="newCar" class="com.spring4.chpter4.NewCar" init-method="myInit" destroy-method="myDestory" scope="singleton">
<property name="brand" value="NEW棉花糖黄金版"></property>
<property name="color" value="黄色"></property>
<property name="maxSpeed" value="150"></property>
</bean>
Bean生命周期的测试类
public class BeanLifeCycle {
private static void LifeCycleInBeanFactory() {
ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
Resource resource = resolver.getResource("classpath:com/spring4/chpter4/bean.xml");
BeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((BeanDefinitionRegistry) factory);
reader.loadBeanDefinitions(resource);
//向容器中注入MyInstantiationAwareBeanPostProcessor后处理器
((ConfigurableBeanFactory)factory).addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());
//向容器中注入MyBeanPostProcessor后处理器
((ConfigurableBeanFactory)factory).addBeanPostProcessor(new MyBeanPostPorcessor());
//第一次从容器中获取bean,容器会实例化该bean,引发bean级的生命周期方法的调用
NewCar newCar = factory.getBean("newCar",NewCar.class);
newCar.introduce();
newCar.setColor("红色");
//第二次获取bean,直接从缓存池中获取
NewCar newCar2 = factory.getBean("newCar",NewCar.class);
//查看newCar和newCar2是否指向同一引用
System.out.println(newCar == newCar2);
//关闭容器
((DefaultListableBeanFactory)factory).destroySingletons();
}
public static void main(String[] args) {
LifeCycleInBeanFactory();
}
}
执行结果如下:
ApplicationContext中Bean的生命周期
Bean在AppliationContext中的生命周期和在BeanFactory中类似,不同的是如果该Bean实现了ApplicationContextAware接口,则会增加一个调用该接口setApplicationContext()方法的步骤,具体流程如下图
可参考上面BeanFactory中Bean的生命周期
描述ApplicationContext中Bean的生命周期的实例
BeanFactoryPostProcessor实现类
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor{
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("调用BeanFactoryPostProcessor.postProcessBeanFactory方法");
}
}
bean.xml配置文件
<!-- init-method指定初始化时调用的方法,destory-method指定销毁时调用的方法 -->
<bean id="newCar" class="com.spring4.chpter4.NewCar" init-method="myInit" destroy-method="myDestory" scope="singleton">
<property name="brand" value="NEW棉花糖黄金版"></property>
<property name="color" value="黄色"></property>
<property name="maxSpeed" value="150"></property>
</bean>
<!-- 下面3个Bean会在ApplicationContext启动时自动被识别,并注册到容器中 -->
<bean id="myBeanFactoryPostProcessor" class="com.spring4.chpter4.MyBeanFactoryPostProcessor"></bean>
<bean id="myBeanPostPorcessor" class="com.spring4.chpter4.MyBeanPostPorcessor"></bean>
<bean id="myInstantiationAwareBeanPostProcessor" class="com.spring4.chpter4.MyInstantiationAwareBeanPostProcessor"></bean>
Bean生命周期的测试类
public class ApplicationLifeCycle {
private static void LifeCycleInApplicationContext() {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*:com/spring4/chpter4/bean.xml");
//实例化bean
NewCar newCar = context.getBean("newCar",NewCar.class);
newCar.introduce();
//关闭容器
context.close();
}
public static void main(String[] args) {
LifeCycleInApplicationContext();
}
}
执行结果如下:
最后有个问题
使用下面这种方式无法为ApplicationContext容器注册后处理器,求知道的大神指导
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*:com/spring4/chpter4/bean.xml");
//向容器中注入MyBeanFactoryPostProcessor后处理器
context.addBeanFactoryPostProcessor(new MyBeanFactoryPostProcessor());
//向容器中注入MyInstantiationAwareBeanPostProcessor后处理器
context.getBeanFactory().addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());
//向容器中注入MyBeanPostProcessor后处理器
context.getBeanFactory().addBeanPostProcessor(new MyBeanPostPorcessor());