在这篇文章中我们简单的说一下Bean的生命周期有关的内容。在Spring中,我们可以从两个层面定义Bean的生命周期:第一个层面是Bean的作用范围(Singleton、Prototype以及Web中的Request、Session和global session),第二个层面是实例化Bean时所经历的一系列阶段。我们将会对BeanFactory和ApplicationContext中的生命周期分别进行分析(BeanFactory和ApplicationContex的一个大的区别是:BeanFactory在初始化容器时,并未实例化Bean,直到第一次访问某个Bean时才实例目标Bean;而ApplicationContext则在初始化应用上下文时就实例化所有单实例的Bean。)本篇文章先说BeanFactory的生命周期。
Bean的生命周期所经历的阶段比较多,所以先奉上一个图形化的生命周期的过程。
在上面这个图中我们需要注意这几个类:InstantiationAwareBeanPostProcessor (或InstantiationAwareBeanPostProcessorAdapter)、BeanNameAware、BeanFactoryAware 、BeanPostProcessor 、InitializingBean、DisposableBean。
下面我们详细的来说一下Bean生命周期的过程:
1、当调用者通过getBean(beanName)向容器请求某一个Bean时,如果容器注册了org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor接口,在实例化Bean之前,将调用接口的postProcessBeforeInstantiation()方法;
2、根据配置情况调用Bean构造函数或工厂方法实例化Bean;
3、如果容器注册了org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor接口,在实例化Bean之后,调用该接口的postProcessAfterInstantiation()方法,可在这里对已经实例化的对象进行一些操作;
4、如果Bean配置了属性信息,容器在这一步着手将配置值设置到Bean对于的属性中,不过在设置每个属性之前将先调用org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor接口的postProcessPropertyValues()方法(如果注册了这个接口的话);
5、调用Bean的属性设置方法设置属性值;
6、如果Bean实现了org.springframework.beans.factory.BeanNameAware接口,将调用setBeanName接口方法,将配置文件中该Bean对应的名称设置到Bean中;
7、如果Bean实现了org.springframework.beans.factory.BeanFactoryAware接口,将调用setBeanFactory()接口方法,将BeanFactory容器实例设置到Bean中;
8、如果BeanFactory装配了org.springframework.beans.factory.config.BeanPostProcessor后处理器,将调用BeanPostProcessor的postProcessBeforeInitialization(Object bean,String beanName)接口方法对Bean进行加工操作,其中入参bean是当前正在处理的Bean,而beanName是当前Bean的配置名,返回的对象为加工处理后的Bean。用户可以使用该方法对某些Bean进行特殊的处理,甚至改变Bean的行为,BeanPostProcessor在Spring框架中占有重要的地位,为容器提供对Bean进行后续加工处理的切入点,Spring容器所提供的各种“神奇功能”(如果AOP、动态代理等)都通过BeanPostProcessor实施;
9、如果Bean实现了org.springframework.beans.factory.InitializingBean接口,将调用afterPropertiesSet()方法;
10、如果在通过init-method属性定义了初始化方法,将执行这个方法;
11、BeanPostProcessor后处理器定义了两个方法:一个是postProcessBeforeInitialization()方法(在第8步调用);另一个是postProcessAfterInitialization(Object bean,String beanName)方法,这个方法在此时调用,容器再次获得对Bean进行加工处理的机会;
12、如果在中指定Bean的作用范围为scope=“prototype”,将Bean返回给调用者,调用者负责Bean后续生命周期的管理,Spring不再管理这个Bean的生命周期。如果作用范围设置为scope=“singleton”,则将Bean放入到Spring IoC容器的缓存池中,并将Bean的应用返回给调用者,Spring继续对这些Bean进行后续的生命管理。
13、对于scope=“singleton”的Bean,当容器关闭时,将触发Spring对Bean的后续生命周期的管理工作,首先如果Bean实现了DisposableBean接口,将调用接口的destroy()方法,可以在此编写释放资源、记录日志等操作;
14、对于scope=“singleton”的Bean,如果通过的destory-method属性指定了Bean的销毁方法,Spring将执行Bean的这个方法,完成Bean资源的释放等操作。
上面一系列的文字看的我们眼花缭乱,我们来总结一下Bean的生命周期。Bean的生命周期大概分为一下三类:
Bean自身的方法:如调用Bean构造函数实例化Bean,调用settter设置Bean的属性值以及通过<bean>的init-method和destory-method所指定的方法;
Bean级生命周期接口方法:像BeanNameAware、BeanFactoryAware、InitalizingBean和DisposableBean,这些接口方法由Bean类直接实现;
容器级生命周期接口方法:像InstantiationAwareBeanPostProcessor(或InstantiationAwareBeanPostProcessorAdapter)和BeanPostProcessor这两个接口,一般称他们的实现类为后处理器。后处理器接口一般不由Bean自身实现,它们独立于Bean,实现类似容器附加装置的形式注册到Spring容器中并通过接口反射为Spring容器预先识别。当Spring容器创建任何Bean的时候,这些后处理器都会发生作用,所以这些后处理的影响是全局性的。如果有多个容器级的接口的实现的话,可以通过org.springframework.core.annotation.Order注解或者org.springframework.core.Ordered接口来指定执行的顺序。
下面让我们写一个例子来测试一下Bean的生命周期的过程:
Bean的生命周期接口和自身的方法:
package com.zkn.newlearn.spring.lifecycle;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
/**
* Created by zkn
* BeanFactoryAware、BeanNameAware、InitializingBean、DisposableBean是Bean级的生命周期接口方法.
*/
public class BeanLifeCycleLearn01 implements BeanFactoryAware,BeanNameAware,InitializingBean,DisposableBean{
/**
* 姓名
*/
private String name;
/**
* BeanFactory
*/
private BeanFactory beanFactory;
private String beanName;
static {
System.out.println("BeanLifeCycleLearn01的静态方法块。。。。");
}
public BeanLifeCycleLearn01() {
System.out.println("---------调用BeanLifeCycleLearn01的构造器实例化---------");
}
/**
* 这是BeanFactoryAware接口方法
* @see BeanFactoryAware
* @param beanFactory
* @throws BeansException
*/
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()");
this.beanFactory = beanFactory;
}
/**
* 这是BeanNameAware接口方法
* @see BeanNameAware
* @param s
*/
@Override
public void setBeanName(String s) {
this.beanName = s;
System.out.println("【BeanNameAware接口】调用BeanNameAware.setBeanName()");
}
/**
* 这是DisposableBean接口方法
* @see DisposableBean
* @throws Exception
*/
@Override
public void destroy() throws Exception {
System.out.println("【DiposibleBean接口】调用DiposibleBean.destory()");
}
/**
* 这是InitializingBean接口方法
* @see InitializingBean
*/
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("【InitializingBean接口】调用InitializingBean.afterPropertiesSet()");
}
public void setName(String name) {
System.out.println("BeanLifeCycleLearn01调用set方法进行name属性值的设置!");
this.name = name;
}
public void initMethod(){
System.out.println("我是配置文件中的init-method。。。。");
}
public void destoryMethod(){
System.out.println("我是配置文件中的destory-method。。。。");
}
@Override
public String toString() {
return "BeanLifeCycleLearn01{" +
"name='" + name + '\'' +
", beanName='" + beanName + '\'' +
'}';
}
}
实现容器级的InstantiationAwareBeanPostProcessor接口:
InstantiationAwareBeanPostProcessor接口是BeanPostProcessor接口的子接口,在Spring1.2中定义的,在Spring2.0中为其提供了一个适配器类org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter,一般情况下,我们可以方便的扩展该适配器覆盖感兴趣的方法以定义实现类。所在我们在这里也是继承的InstantiationAwareBeanPostProcessorAdapter。
package com.zkn.newlearn.spring.lifecycle;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
import java.beans.PropertyDescriptor;
/**
* Created by zkn
* InstantiationAwareBeanPostProcessorAdapter:每个Bean在设置属性的时候都会调用者三个方法,在用的时候要慎重.
*/
public class InstantiationAwareBeanPostProcessor01 extends InstantiationAwareBeanPostProcessorAdapter {
public InstantiationAwareBeanPostProcessor01() {
super();
System.out.println("这是InstantiationAwareBeanPostProcessorAdapter实现类构造器!!");
}
/**
* 接口方法、实例化Bean之前调用
* @param beanClass
* @param beanName
* @return
* @throws BeansException
*/
@Override
public Object postProcessBeforeInstantiation(Class beanClass,
String beanName) throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法");
return null;
}
/**
* 接口方法、实例化Bean之后调用
* @param bean
* @param beanName
* @return
* @throws BeansException
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法");
if(bean instanceof BeanLifeCycleLearn01){
((BeanLifeCycleLearn01) bean).setName("我被该名为张四了");
}
return bean;
}
/**
* 接口方法、设置某个属性时调用
* @param pvs
* @param pds
* @param bean
* @param beanName
* @return
* @throws BeansException
*/
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs,
PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
return pvs;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor调用postProcessAfterInstantiation方法");
return true;
}
}
BeanPostProcessor后置处理器:
package com.zkn.newlearn.spring.lifecycle;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
* Created by zkn
* BeanPostProcessor:每个Bean都会调用,用的时候要慎重.
*/
public class BeanPostProcessor01 implements BeanPostProcessor {
public BeanPostProcessor01() {
System.out.println("这是BeanPostProcessor实现类构造器!!");
}
@Override
public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
System.out.println("BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改!");
return o;
}
@Override
public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
System.out.println("BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改!");
return o;
}
}
总结一下Bean的生命周期的执行顺序,先执行容器级的生命周期的接口:BeanFactoryPostProcessor的postProcessBeanFactory方法(这个容器只会执行一次),接着实例化BeanPostProcessor的实现类,实例化InstantiationAwareBeanPostProcessorAdapter的实现类;然后一个Bean被创建的顺序是这样的:执行容器级的生命周期接口:InstantiationAwareBeanPostProcessorAdapter的postProcessBeforeInstantiation方法,再执行Bean的实例化,再执行容器级的生命周期接口:InstantiationAwareBeanPostProcessorAdapter的postProcessAfterInstantiation,再执行容器级的生命周期接口:InstantiationAwareBeanPostProcessorAdapter的postProcessPropertyValues,再接着调用bean自身的setter方法进行属性值的设置,再接着调用Bean级的生命周期接口:BeanNameAware的setBeanName方法,再接着调用Bean级的生命周期接口:BeanFactoryAware的setBeanFactory方法,再接着调用Bean级的生命周期接口:ApplicationContextAware的setApplicationContext方法,再接着调用容器级的生命周期接口:BeanPostProcessor中的postProcessBeforeInitialization方法,再接着调用Bean级的生命周期接口:InitializingBean的afterPropertiesSet方法,再接着调用配置文件中的init-method指定的方法,再接着调用容器级的生命周期接口:BeanPostProcessor中的postProcessAfterInitialization方法,再接着调用容器级的生命周期接口:InstantiationAwareBeanPostProcessor的postProcessAfterInitialization方法,接着执行一些的业务操作,当容器关闭时,先调用Bean级的生命周期接口:DiposibleBean的destory方法,最后调用配置文件中destory-method指定的方法。