BeanFactory中Bean的生命周期:
package com.Spring.BeanLifeCycle;
...
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("调用Car的无参构造函数");
}
public void setBrand(String brand) {
System.out.println("调用setBrand()方法设置属性");
this.brand = brand;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void setMaxSpeed(int maxSpeed){
this.maxSpeed = maxSpeed;
}
public int getMaxSpeed(){
return maxSpeed;
}
public void introduce() {
System.out.println("brand:" + brand + ";color:" + color + ";maxSpeed:"
+ maxSpeed);
}
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("调用BeanFactoryAware.setBeanFactory()。");
this.beanFactory = beanFactory;
}
public void setBeanName(String beanName) {
System.out.println("调用BeanNameAware.setBeanName()。");
this.beanName = beanName;
}
public void afterPropertiesSet() throws Exception {
System.out.println("调用InitializingBean.afterPropertiesSet()。");
}
public void destroy() throws Exception {
System.out.println("调用DisposableBean.destory()。");
}
public void myInit(){
System.out.println("调用init-method所指定的myInit(),将maxSpeed设置为240");
this.maxSpeed = 240;
}
public void myDistroy(){
System.out.println("调用destory-method所指定的myDestroy()。");
}
}
package com.Spring.BeanLifeCycle;
...
public class MyInstantiationAwareBeanPostProcessor extends
InstantiationAwareBeanPostProcessorAdapter {
public boolean postProcessAfterInstantiation(Object bean, String beanName)
throws BeansException {
if ("car".equals(beanName)) {
System.out
.println("InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation");
}
return true;
}
public Object postProcessBeforeInstantiation(Class beanClass,
String beanName) throws BeansException {
if ("car".equals(beanName)) {
System.out
.println("InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation");
}
return null;
}
public PropertyValues postProcessPropertyValues(PropertyValues pvs,
PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException {
if ("car".equals(beanName)) {
System.out
.println("InstantiationAwareBeanPostProcessor.postProcessPropertyValues");
}
return pvs;
}
}
package com.Spring.BeanLifeCycle;
public class MyBeanPostProcessor implements BeanPostProcessor {
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.postProcess After Initialization(),将maxSpeed调整为200");
car.setMaxSpeed(200);
}
}
return bean;
}
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.postProcess Before Initialization(),将color设置为默认黑色");
car.setColor("黑色");
}
}
return bean;
}
}
package com.Spring.BeanLifeCycle;
public class BeanLifeCycle {
public static void main(String[] args) {
lifeClcleInBeanFactory();
}
private static void lifeClcleInBeanFactory() {
// 装载配置文件并启动容器
Resource res = new ClassPathResource("com/Spring/BeanLifeCycle/beans.xml");
BeanFactory bf = new XmlBeanFactory(res);
// 向容器中注册BeanPostProcessor后处理器
((ConfigurableBeanFactory) bf)
.addBeanPostProcessor(new MyBeanPostProcessor());
// 向容器中注册后处理器InstantiationAwareBeanPostProcessor后处理器
((ConfigurableBeanFactory) bf)
.addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());
Car car1 = (Car) bf.getBean("car");// 第一次从容器中获取car,将触发容器实例化该Bean
car1.introduce();
car1.setColor("红色");
Car car2 = (Car) bf.getBean("car");// 第二次从容器中获取car,直接从缓存池中获得
System.out.println("car1==car2:" + (car1 == car2));
((XmlBeanFactory)bf).destroySingletons();//关闭容器
}
}
Bean完整的生命周期从Spring容器的着手实例化Bean 开始,知道最终销毁Bean。这当中经过了许多的关键点,每个关键点都涉及特定的方法调用,可以将这些方法大致划分为三类:
·Bean自身的方法:如调用Bean构造函数实例化Bean,调用Setter设置Bean的属性以及通过<bean>的init-method 和 destroy-method所指定的方法;
·Bean级生命周期接口方法:如BeanNameAware,BeanFactoryAware,InitializingBean和DisposableBean,这些接口由Bean直接实现;
·容器级生命周期接口方法:上例用InstantiationAwareBeanPostProcessorAdapter和BeanPostProcessor这两个接口实现,一般称他们的实现类为后处理器。一般不由Bean直接实现,它们独立于Bean,实现类以容器附加装置的形式注册到Spring容器中。当Spring创建任何的Bean时,后处理器都会发生作用,所以这些后处理器是全局性的。
具体的生命周期即从着手实例化开始到销毁的具体步骤:
1.如果注册了InstantiationAwareBeanPostProcessor后处理器,执行InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()方法;
2.根据配置情况调用Bean构造函数或工厂方法实例化Bean;
3.如果注册了InstantiationAwareBeanPostProcessor后处理器,执行InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()方法;
4.如果<bean>配置了<property>属性,在设置每个属性前调用InstantiationAwareBeanPostProcessor.postProcessPropertyValues()方法;
5.调用Bean的属性设置方法setXxx()方法设置属性值;
6.如果Bean实现了BeanNameAware.setBeanName()方法,将配置文件中该Bean对应的名称设置到Bean中通过setBeanName()方法;
7.如果Bean实现了BeanFactoryAware.setBeanFactory()方法,将调用setBeanFactory()接口的方法,将BeanFactory容器实例设置到Bean中;
8.调用BeanPostProcessor.postProcessBeforeInitialization(),入参是当前正在处理的Bean,beanName是当前Bean的配置名,返回的对象为加工处理后的Bean,可以在此方法中对Bean进行修改;
9.如果Bean实现了调用InitializingBean,调用InitializingBean.afterPropertiesSet()方法;
10.执行在<bean>通过init-method属性定义的初始化方法;
11.调用BeanPostProcessor.postProcessAfterInitialization()方法;
12.如果在<bean>中指定Bean的作用范围为scope="prototype",将Bean返回给调用者,调用者负责Bean后续生命管理,Spring不再管理这些Bean的生命周期。如果为Scope="singleton",则将Bean放入Spring IoC容器的缓存池,并将Bean引用返回给调用者,Spring继续对这些Bean进行后续的生命管理。
13.对于scope="singleton"的Bean,当容器关闭时,调用DisposableBean.destory()方法;
14.调用<bean>中destory-method方法。
ApplicationContext中Bean的生命周期:
在应用上下文中,Bean 的生命周期和在BeanFactory类似,只是如果Bean实现了org.springframework.context.ApplicationContextAware接口,会在BeanFactoryAware的setBeanFactory()方法后调用ApplicationContextAware接口的setApplicationContext()方法。
他们另外一个最大不同在于Application会利用java反射机制自动判断出配置文件中定义的BeanPostProcessor,InstantiationAwareBeanPostProcessor和BeanFactoryPostProcessor,并将它们自动注册到应用上下文中;而BeanFactory需要在代码中手工调用addBeanPostProcessor()方法进行注册。所以在开发中使用ApplicationContext而很少使用BeanFactory的原因。
ApplicationContext在启动时,将首先为配置文件中每一个<bean>生成一个BeanDefinition对象,BeanDefinition是<bean>在Spring容器中的内部表示。当配置文件中所有的<bean>都被解析成BeanDefinition时,ApplicationContext将调用工厂后处理器的方法,从而有机会通过程序的方式调整Bean的配置信息。
分享到:
相关推荐
Spring bean生命周期demo
spring bean 的生命周期,把运行结果的日志,用sublime打开对比查看,你会有比较清晰的认识
Springbean生命周期
java Bean生命周期.jpg
Spring Bean 生命周期之“我从哪里来?”
浅尝Spring注解开发_Bean生命周期及执行过程.doc
介绍了Spring的Bean周期,容器周期,工厂周期,运行代码后可以看到运行结果
本篇文章主要介绍了浅谈Spring bean 生命周期验证,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
一般情况下,我们只是关心如何正确地将Bean装配到容器中,并不关心Ioc容器是如何装配和销毁Bean的过程。但是恰恰有时候,我们需要自定义初始化或销毁Bean的过程,以满足一些“特殊的”需求。比如,数据源在关闭的...
Spring IOC容器可以管理Bean的生命周期,允许在Bean生命周期的特定点执行定制的任务。 Spring IOC容器对Bean的生命周期进行管理的过程如下: 通过构造器或工厂方法创建Bean实例 为Bean的属性设置值和对其它Bean的...
Spring Bean 的生命周期在整个 Spring 中占有很重要的位置,掌握这些可以加深对 Spring 的理解。这篇文章主要介绍了Spring Bean 生命周期,需要的朋友可以参考下
* * * 上图中,Bean的生命周期的整个执行过程描述如下。 (1)根据配置情况调用Bean构造方法或工厂方法实例化Bean。 (2)利用依赖注入来完成Bean中所有属性值的配置注入。 (3)如果Bean实现了BeanNameAware接口,...
虽然可以随意配置 <bean> 的属性,但是建议不要过多地使 Bean 实现接,因为这样会导致代码和 Spring 的聚合过于紧密第 1 步:实例化Bean第
学习Spring过程中,使用Eclipse调试Spring源码的关键断点文件。
这个工程主要实现了: Spring中Bean的生命周期 applicationcontext的应用(实现国际化,事件的传递)
本文主要介绍 Spring IoC 容器如何管理 Bean 的生命周期。 在应用开发中,常常需要执行一些特定的初始化工作,这些工作都是相对比较固定的,比如建立数据库连接,打开网络连接等,同时,在结束服务时,也有一些相对...
SpringBean的生命周期.mdj
Spring Bean是Spring应用中最最重要的部分了。下面这篇文章主要给大家介绍了关于Spring学习笔记之bean生命周期的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考借鉴,下面来一起看看吧。
NULL 博文链接:https://cici9898-007.iteye.com/blog/1407695
主要介绍了Spring bean生命周期配置过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下