Spring 学习笔记---Bean的生命周期
生命周期图解
由于Bean的生命周期经历的阶段比较多，我们将通过一个图形化的方式进行描述。下图描述了BeanFactory中Bean生命周期的完整过程：
Bean 的生命周期从Spring容器着手实例化Bean开始，直到最终销毁Bean,这当中经过了许多关键点，每个关键点都涉及特定方法的调用，可以将这些方法大致划分为3类：
(1)Bean自身的方法:如调用Bean构造函数，实例化Bean,，调用Setter设置Bean的属性值以及通过<bean>的init-method和destroy-method所指定的方法；
(2)Bean级生命周期接口方法：如BeanNameAware、BeanFactoryAware、InitializationBean和DisposableBean,这些接口方法由Bean类直接实现；
(3)容器级生命周期接口方法：如上图中的红色部分所示，由InstantiationAwareBeanPostProcessor和BeanPostProcessor这连个接口实现，一般称他们的实现类为”后处理器“。后处理器接口，一般不由Bean本身实现，他们独立于Bean,实现类以容器附加装置的形式注册到Spring容器中，并通过接口反射为Spring容器预先识别。当Spring容器创建任何Bean的时候，这些后处理器都会发生作用，所以这些后处理器的影响是全局性的。当然，用户可以通过合理的编写后处理器，让其仅对感兴趣的Bean进行加工处理.
InstantiationAwareBeanPostProcessor其实是BeanPostProcessor接口的子接口，在Spring 1.2中定义，在Spring2.0中为其提供了一个适配器类InstantiationAwareBeanPostProcessorAdapter，一般情况下，可以方便的扩展改适配器覆盖感兴趣的方法以定义实现类。下面我们通过一个具体的实例以更好的理解Bean生命周期的各个步骤.
窥探Bean生命周期的实例
实现各种生命周期控制访问的Car
package com.spring.beanfactory; import org.springframework.beans.BeansException;
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 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 String getBrand() {
return brand;
} public BeanFactory getBeanFactory() {
return beanFactory;
} public String getBeanName() {
return beanName;
} //1、管理Bean生命周期的接口
public Car(){
System.out.println("调用Car构造函数");
} public void setBrand(String brand) {
System.out.println("调用setBrand()设置属性");
this.brand = brand;
} public void introduce(){
System.out.println("bradn:"+brand+";color"+color+"; maxSpeed:"+maxSpeed);
} //2、BeanFactoryAware接口方法
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("调用BeanFactoryAware.setBeanFactory()");
this.beanFactory=beanFactory;
} //3、BeanNameAware接口方法
public void setBeanName(String beanName) {
System.out.println("调用BeanNameAware.setBeanName()");
this.beanName=beanName;
} //4 nitializingBean接口方法
public void afterPropertiesSet() throws Exception {
System.out.println("调用InitializingBean.afterPropertiesSet()");
} // 5 DisposableBean接口方法
public void destroy() throws Exception {
System.out.println("调用DisposableBean.destroy()");
} // 6 通过<bean>的init-method属性指定的初始化方法
public void myInit(){
System.out.println("调用inti-method所指定的myInit(),将maxSpeed设置为240.");
this.maxSpeed=240;
} //7 通过<bean>的destory-method属性指定的销毁方法
public void myDestory(){
System.out.println("调用destory-method所指定的myDestory()方法。");
}
}
InstantiationAwareBeanPostProcessor实现类
package com.spring.beanfactory; import java.beans.PropertyDescriptor; import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter; @SuppressWarnings("unchecked")
public class MyInstantiationAwareBeanPostProcessor extends
InstantiationAwareBeanPostProcessorAdapter { //1 接口方法：实例化bean前进行调用
public Object postProcessBeforeInstantiation(Class beanClass,String beanName) throws BeansException {
//1-1仅对容器中的car-bean进行处理
if("car".equals(beanName)){
System.out.println("InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()");
} return null;
} //2 接口方法：在实例化bean后进行调用
public boolean postProcessAfterInstantiation(Object bean, String beanName )
throws BeansException{
if("car".equals(beanName)){
System.out.println("InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()");
}
return true;
} //3接口方法:在设置某个属性时调用
public PropertyValues postProcessPropertyValues(
PropertyValues propertyvalues,
PropertyDescriptor apropertydescriptor[], Object bean, String beanName)
throws BeansException{
//3-1仅对容器中car-bean进行处理，还可以通过post入参进行过滤，
//仅对car的某个特定属性进行处理
if("car".equals(beanName)){
System.out.println("InstantiationAwareBeanPostProcessor.postProcessPropertyValues");
}
return propertyvalues;
}
}
BeanPostProcessor实现类
package com.spring.beanfactory; import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor; public class MyBeanPostProcessor implements BeanPostProcessor { public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
if(beanName.equals("car")){
Car car=(Car)bean;
if(car.getColor()==null){
System.out.println("调用BeanPostProcessor.postProcessBeforeInitialization(),color为空，设置为默认黑色.");
car.setColor("黑色");
}
}
return bean;
} public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException { if(beanName.equals("car")){
Car car=(Car)bean;
if(car.getMaxSpeed()>=200){
System.out.println("调用BeanPostProcessor.postProcessAfterInitialization(),将maxSpedd调整为200.");
car.setMaxSpeed(200);
}
}
return bean;
} }
在Spring配置文件中定义Car的配置信息
<?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-3.0.xsd"> <bean id="car" class="com.spring.beanfactory.Car" init-method="myInit" destroy-method="myDestory"
p:brand="红旗CA72"
p:maxSpeed="300"
scope="singleton"
/> </beans>
下面我们让容器装载配置文件，然后再分别注册上面所提供的两个后处理器：
package com.spring.beanfactory; import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource; public class BeanLifeCycle { private static void LifiCycleInBeanFactory(){
// 1 下面两句装载配置文件，并启动容器
Resource res=new ClassPathResource("beans.xml");
BeanFactory bf=new XmlBeanFactory(res); // 2 向容器中注册MyBeanPostProcesser处理器
((ConfigurableBeanFactory)bf).addBeanPostProcessor(new MyBeanPostProcessor());
//3 向容器中注册MyInstantiationAwareBeanPostProcessor后处理器
((ConfigurableBeanFactory)bf).addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor()); //4 第一次从容器中获取car,将处罚容器实例化该Bean,这将引发Bean生命周期方法的调用
Car car1=(Car)bf.getBean("car");
car1.introduce();
car1.setColor("红色"); // 5第二次从容器中获取car，直接从缓存池中取(因为 scope="singleton")
Car car2=(Car)bf.getBean("car"); // 6 查看car1和car2是否指向同一引用
System.out.println("car1==car2"+(car1==car2)); // 7 关闭容器
((XmlBeanFactory)bf).destroySingletons(); } public static void main(String[] args) {
LifiCycleInBeanFactory();
} }
运行后，结果如下:
三月 27, 2014 11:16:39 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
调用Car构造函数
InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
InstantiationAwareBeanPostProcessor.postProcessPropertyValues
调用setBrand()设置属性
调用BeanNameAware.setBeanName()
调用BeanFactoryAware.setBeanFactory()
调用BeanPostProcessor.postProcessBeforeInitialization(),color为空，设置为默认黑色.
调用InitializingBean.afterPropertiesSet()
调用inti-method所指定的myInit(),将maxSpeed设置为240.
调用BeanPostProcessor.postProcessAfterInitialization(),将maxSpedd调整为200.
bradn:红旗CA72;color黑色; maxSpeed:200
car1==car2true
三月 27, 2014 11:16:39 上午 org.springframework.beans.factory.support.DefaultSingletonBeanRegistry destroySingletons
信息: Destroying singletons in org.springframework.beans.factory.xml.XmlBeanFactory@1ed7c33: defining beans [car]; root of factory hierarchy
调用DisposableBean.destroy()
调用destory-method所指定的myDestory()方法。
仔细观察输出的信息，将发现它验证了我们前面所介绍的生命周期的过程。在7处，我们通过destroySingletons()方法关闭容器，由于Car实现了销毁接口并指定了销毁方法，所以容器将触发调用这两个方法.
ApplicationContext中Bean的生命周期
Bean在应用上下文中的生命周期和在BeanFactory中生命周期类似，不同是，如果Bean实现了org.springframework.context.ApplicationContext接口，会增加一个调用该接口的方法setApplicationContext()步骤，该方法紧接着BeanFactoryAware之后，
此外，如果配置文件中声明了工厂后处理器接口BeanFactoryPostProcessor的实现类，则应用上下文在装载配置文件之后，初始化Bean实例之前将调用这些BeanFactoryPostProcessor对配置信息进行加工处理。
ApplicationContext和BeanFactory另一个最大的不同之处在于：前者会利用JAVA机制自动识别出配置文件中定义的BeanPostProcessor，InstantiationAwareBeanPostProcessor和BeanFactoryPostProcessor，并自动将他们注册到应用上下文中；而后者需要在代码中通过手工调用addBeanPostProcessor()方法进行注册。这也是为什么在应用开发时，我们普遍使用ApplicationContext而很少使用BeanFactory的原因之一。
在ApplicationContext中，我们只需要在配置文件中通过<bean>定义工厂后处理器和Bean后处理器，他们就会按预期的方式执行。
来看一个使用工厂后处理器的实例，假设我们希望对配置文件中car的brand配置属性进行调整，则可以编写一个如下的工厂后处理器：
来看一个使用工厂后处理器的实例，假设我们希望对配置文件中car的brand配置属性进行调整，则可以编写一个如下的工厂后处理器：
工厂后处理器器：MyBeanFactoyPostProcessor.java
package com.spring.context; import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.Bean; public class MyBeanFactoyPostProcessor implements BeanFactoryPostProcessor{
//1 对car<bean> 的brand属性配置信息进行“偷梁换柱”的加工操作
public void postProcessBeanFactory(
ConfigurableListableBeanFactory bf)
throws BeansException { BeanDefinition bd=bf.getBeanDefinition("car");
bd.getPropertyValues().addPropertyValue("brand", "奇瑞QQ");
System.out.println("调用BeanFactoryPostProcessor.postProcessBeanFactory()!");
}
}
ApplicationContext在启动时，将首先为配置文件中的每个<bean>生成一个BeanDefinition对象，BeanDefinition是<bean>在Spring容器中的内部表示。当配置文件中所有的<bean>都被解析成Definition时，ApplicationContext将调用工厂后处理器的方法，因此我们有机会通过程序的方式调整bean的配置信息。在这里，我们将car的BeanDefinition进行调整，将brand属性设置为"奇瑞QQ"，下面是具体的配置:
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-3.0.xsd">
<!-- 1 这个brand属性的值将被工厂后处理器更改掉-->
<bean id="car" class="com.spring.beanfactory.Car" init-method="myInit" destroy-method="myDestory"
p:brand="红旗CA72"
p:maxSpeed="300"
/> <!-- 2 Bean后处理器-->
<bean id="myBeanPostprocessor" class="com.spring.beanfactory.MyBeanPostProcessor"/> <!-- 3 Bean工厂后处理器 -->
<bean id="myBeanFactory" class="com.spring.context.MyBeanFactoyPostProcessor"/>
</beans>
2和3处定义的BeanPostProcessor和BeanFactoryPostProcessor会自动被ApplicationContext识别并注册到容器中。3处注册的工厂后处理器将会对1处配置的属性值进行调整。在2处，我们还定义了一个Bean后处理器，它也可以对1处配置的属性进行调整。启动容器并查看car Bean的信息，我们将发现car Bean的brand属性成功被工厂后处理器修改了.
package com.spring.test; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.spring.beanfactory.Car;
public class Test {
public static void main(String[] args) { ApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
Car car =(Car) ctx.getBean("car");
System.out.println(car.getBrand());
}
}
输出信息如下：
三月 27, 2014 1:55:54 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@17f1841: startup date [Thu Mar 27 13:55:54 CST 2014]; root of context hierarchy
三月 27, 2014 1:55:54 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
调用BeanFactoryPostProcessor.postProcessBeanFactory()!
三月 27, 2014 1:55:54 下午 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@16fb592: defining beans [car,myBeanPostprocessor,myBeanFactory]; root of factory hierarchy
调用Car构造函数
调用setBrand()设置属性
调用BeanNameAware.setBeanName()
调用BeanFactoryAware.setBeanFactory()
调用BeanPostProcessor.postProcessBeforeInitialization(),color为空，设置为默认黑色.
调用InitializingBean.afterPropertiesSet()
调用inti-method所指定的myInit(),将maxSpeed设置为240.
调用BeanPostProcessor.postProcessAfterInitialization(),将maxSpedd调整为200.
奇瑞QQ
Spring 学习笔记---Bean的生命周期的更多相关文章
- Spring4学习笔记 - Bean的生命周期
1 Spring IOC 容器对 Bean 的生命周期进行管理的过程: 1)通过构造器或工厂方法创建 Bean 实例 2)为 Bean 的属性设置值和对其他 Bean 的引用 3)调用 Bean 的初 ...
- （转）Spring管理的Bean的生命周期
http://blog.csdn.net/yerenyuan_pku/article/details/52834011 bean的初始化时机 前面讲解了Spring容器管理的bean的作用域.接着我们 ...
- MAVEN学习笔记之Maven生命周期和插件简介（3）
MAVEN学习笔记之Maven生命周期和插件简介(3) clean compile site三套生命周期相互独立. clean pre-clean 执行清理前的工作 clean 清理上一次构建生成的所 ...
- Spring 容器中 Bean 的生命周期
Spring 容器中 Bean 的生命周期 1. init-method 和 destory-method 方法 Spring 初始化 bean 或销毁 bean 时,有时需要作一些处理工作,因此 s ...
- spring深入学习(二)-----bean的生命周期、IOC容器bean装配
bean的生命周期 1.实例化Bean对于BeanFactory容器,当客户向容器请求一个尚未初始化的bean时,或初始化bean的时候需要注入另一个尚未初始化的依赖时,容器就会调用createBea ...
- （spring-第1回【IoC基础篇】）Spring容器中Bean的生命周期
日出日落,春去秋来,花随流水,北雁南飞,世间万物皆有生死轮回.从调用XML中的Bean配置信息,到应用到具体实例中,再到销毁,Bean也有属于它的生命周期. 人类大脑对图像的认知能力永远高于文字,因此 ...
- IoC基础篇（一）--- Spring容器中Bean的生命周期
日出日落,春去秋来,花随流水,北雁南飞,世间万物皆有生死轮回.从调用XML中的Bean配置信息,到应用到具体实例中,再到销毁,Bean也有属于它的生命周期. 人类大脑对图像的认知能力永远高于文字,因此 ...
- Spring 学习笔记 Bean的作用域
在配置文件中定义Bean时,用户不但可以配置Bean的属性值以及相互之间的依赖关系,还可以定义Bean的作用域.作用域将对Bean的生命周期和创建方式产生影响.在低版本的Spring中,仅有两个作用域 ...
- Spring容器中bean的生命周期以及关注spring bean对象的后置处理器：BeanPostProcessor（一个接口）
Spring IOC 容器对 Bean 的生命周期进行管理的过程: 1.通过构造器或工厂方法创建 Bean 实例 2.为 Bean 的属性设置值和对其他 Bean 的引用 3.将 Bean 实例传递给 ...
随机推荐
- UE4成批处理透明材质
项目中需要控制成批的物体的透明度,但是默认的时候他又不能是透明的,对,项目的要求就这么诡异. 然而却没有找到设置材质的BlendMode的功能,于是只有换了一种办法,物体需要透明时更换为透明材质,默认 ...
- 安卓自定义View实现图片上传进度显示（仿QQ）
首先看下我们想要实现的效果如下图(qq聊天中发送图片时的效果): 再看下图我们实现的效果: 实现原理很简单,首先我们上传图片时需要一个进度值progress,这个不管是自己写的上传的方法还是使用第三方 ...
- 1081. Rational Sum (20) -最大公约数
题目如下: Given N rational numbers in the form "numerator/denominator", you are supposed to ca ...
- java操作XML文件--读取内容
先把问题贴出来:编写一个可以解析xml及修改xml内容的工具类 由于我以前做过Android应用程序开发,之前也解析过xml文件,所以,这道题不是很难,这篇文章我先解决第一个问 ...
- Oracle启用scott用户
先查询一下目前数据库是否有scott用户 select username,account_status from dba_users where username like '%SCOTT%'; 如果 ...
- 深入理解MyBatis框架的的配置信息
面对一个框架,最重要的不是说回用其代码就可以了,我们需要了解其思想,这样才能更快更好的掌握这个框架.而对于一个框架,最重要的就是其配置文件的作用及功能了.下面,我就来谈一谈我今天遇到的这个MyBati ...
- 使用Hash函数和MAC产生伪随机数
基于Hash函数的PRNG 流程非常类似于对称密码的CTR工作模式 算法的伪码如下 m = ⌈n/outlen⌉ data = V W = the null String for i = 1 to m ...
- ubuntu文件管理常用命令
1.关闭防火墙:ufw disable 2.以.开头的表示隐藏文件 3..和..分别代表当前目录以及当前目录的父目录 4.显示当前用户所在目录pwd 5.touch创建空文件 6.mkdir创建新目录 ...
- 关于Class文件
什么是Class文件 Java人对class文件肯定很熟悉了,它是Java源码编译后的产物.JVM运行时负责加载class文件,并根据class定义的执行逻辑运行.java为了将硬件底层的差异屏蔽掉, ...
- hadoop队列管理（指定queue跑程序）
hadoop 升级到cdh5后,队列管理被取消,而是统一用资源池分配. hadoop2.0版本,Hadoop采用了平级队列组织方式,,管理员可将用户分到若干个扁平队列中,在每个队列中,可指定一个或几个 ...