在Spring中,可以从两个层面定义Bean的生命周期。下面分别对BeanFactory和ApplicationContext中Bean的生命周期进行分析。
一、BeanFactory中Bean的生命周期
具体过程如下
1)当调用者调用getBean(beanName)向容器请求某一个Bean时,如果容器注册了InstantiationAwareBeanPostProcessor接口,则在实例化Bean之前,将调用接口的postProcessBeforeInstantiation()方法。
(2)根据配置情况调用Bean的构造函数或工厂方法实例化Bean。
(3)如果容器注册了InstantiationAwareBeanPostProcessor接口,在实例化Bean之后,调用该接口的postProcessBeforeInstantiation()方法,对实例化的对象进行一些初始化设置。
(4)如果Bean 配置了属性信息,那么容器在这一步将配置的属性设置到Bean对应的属性中,在设置属性之前将先调用InstantiationAwareBeanPostProcessor接口的postProcessPropertyValues()方法。
(5)调用Bean中的setXxx()方法设置属性。
(6)如果Bean实现了BeanNameAware接口,则会调用该接口的setBeanName()方法,将配置文件中该Bean对应的名称设置到Bean中。
(7)如果Bean实现了BeanFactoryAware接口,则会调用该接口的setBeanFactory()方法,将BeanFactory容器实例设置到Bean中。
(8)如果BeanFactory装配了BeanPostProcessor后处理器,则将调用BeanPostProcessor接口的Object postProcessBeforeInitialization方法对Bean进行加工操作。其中,传入的bean是当前正在处理的bean,而beanName是当前Bean在配置文件中的配置名,返回加工处理后的bean。用户可以使用该方法对某些Bean进行特殊的处理。Spring容器所提供的AOP、动态代理等功能都通过BeanPostProcessor实现。
(9)如果Bean实现了InitializingBean接口,则将调用该接口的afterPropertiesSet()方法。
(10)如果在配置文件的bean标签中通过init-method属性指定了初始化方法,则会执行这个方法。
(11)如果BeanFactory装配了BeanPostProcessor后处理器,在这里则会执行Object postProcessAfterInitialization()方法对Bean进行加工处理。
BeanPostProcessor后处理器定义了两个方法,分别是postProcessBeforeInitialization()和postProcessAfterInitialization(),分别在第8步和在此处调用。
(12)如果在配置文件中指定了bean的scope=”prototype”,意味着配置的这个bean是多例的,每次获取该bean都会返回一个新实例化的bean,所以在这一步之后Spring容器不再管理多例的Bean,直接将当前生成的实例返回给用户。
对于scope=”singleton”的Bean(默认情况),意味着这个Bean是单例的,就需要把这个Bean缓存到在Spring IOC容器中,用户每次获取时都从这个容器中获取,并且Spring会对这些Bean进行后续的生命周期管理。
(13)对于单例的Bean,容器关闭时,会触发Spring对Bean的后续生命周期的管理工作。如果Bean实现了DisposableBean接口,则会调用该接口的destroy()方法,在这里可以进行释放资源、记录日志等操作。
(14)对于单例的Bean,如果在配置文件中指定了destroy-method属性,Spring则会执行这个属性配置的方法,完成Bean资源释放等操作。
以上生命周期所经历的方法大致可以分为四类
a、Bean自身的方法
包括实例化Bean时Bean的构造方法,设置属性值时Bean的set方法,以及通过配置文件配置的init-method和destroy-method指定的方法。
b、Bean级生命周期接口方法
包括BeanNameAware、BeanFactoryAware、InitializingBean和DisposableBean,这些接口方法由Bean直接实现。
c、容器级生命周期接口方法
包括InstantiationAwareBeanPostProcessor和BeanPostProcessor两个接口。一般称他们的实现类为后处理器,后处理器接口一般不由Bean本身实现,他们独立于Bean,实现类以容器附加装置的形式注册到Spring容器中,并通过接口反射为Spring容器扫描识别。当Spring容器创建任何Bean时,这些后处理器都会起作用,这些后处理器的影响是全局性的。
d、工厂后处理器接口方法
包括AspectJWeavingEnabler、CustomAutowireConfigurer、ConfigurationClassPostProcessor等类,都实现了BeanFactoryPostProcessor接口。工厂后处理器也是容器级的,在应用上下文装配配置文件后立即调用。
Spring容器中还可以注册多个后处理器,只要他们都实现了Ordered接口,Spring容器就会按照特定的顺序依次调用这些后处理器。
Bean的生命周期实例如下:
首先是Bean类,让它实现所有bean生命周期接口。此外,还定义了初始化和销毁方法,这两个方法将通过的init-method和destroy-method属性指定。
package com.spring;
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 Car() {
System.out.println("调用Car构造函数");
}
public void setBrand(String brand) {
System.out.println("调用setBrand()设置属性");
this.brand = brand;
}
public void introduce() {
System.out.println("brand:" + brand + ";color:" + color + ";maxSpeed" + maxSpeed);
}
//调用BeanFactoryAware接口方法
@Override
public void setBeanFactory(BeanFactory beanFactory) {
System.out.println("调用BeanFactoryAware.setBeanFactory().");
this.beanFactory = beanFactory;
}
//调用BeanNameAware接口方法
@Override
public void setBeanName(String beanName) {
System.out.println("调用BeanNameAware.setBeanName().");
System.out.println("---------------" + beanName + "-------------------");
this.beanName = beanName;
}
//InitializingBean接口方法
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("调用InitializingBean.afterPropertiesSet().");
}
//DisposableBean接口方法
@Override
public void destroy() throws Exception {
System.out.println("调用DisposableBean.destroy().");
}
//通过的init-method属性指定初始化方法
public void myInit() {
System.out.println("调用init-method所指定的myInit(),将maxSpeed设置为240.");
this.maxSpeed = 240;
}
//通过的destroy-method实行指定销毁方法`
public void myDestroy() {
System.out.println("调用destroy-method所指定定的mDestroy().");
}
public String getBrand() {
return brand;
}
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 BeanFactory getBeanFactory() {
return beanFactory;
}
public String getBeanName() {
return beanName;
}
}
MyInstantiationAwareBeanPostProcessor通过扩展InstantiationAwareBeanPostProcessor适配器InstantiationAwareBeanPostProcessorAdapter提供实现。
package com.spring;
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("MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation");
}
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
if("car".equals(beanName)){
System.out.println("InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation");
}
return true;
}
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
if("car".equals(beanName)){
System.out.println("InstantiationAwareBeanPostProcessor.postProcessPropertyValues");
}
return pvs;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
}
最后提供一个BeanPostProcessor的实现类。
package com.spring;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if ("car".equals(beanName)) {
Car car = (Car) bean;
if (car.getColor() == null) {
System.out.println("调用BeanPostProcessor.postProcessBeforeInitialization(),color为空,设置为默认黑色");
car.setColor("黑色");
}
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if ("car".equals(beanName)) {
Car car = (Car) bean;
if (car.getMaxSpeed() >= 200) {
System.out.println("调用BeanPostProcessor.postProcessAfterInitialization(),将maxSpeed调整为200.");
car.setMaxSpeed(200);
}
}
return bean;
}
}
最后在xml文件中配置bean
最后查看bean的实例流程
package com.spring;
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;
import org.springframework.core.io.Resource;
public class BeanLifeCycle {
private static void LifeCycleInBeanFactory() {
Resource res = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((DefaultListableBeanFactory) bf);
reader.loadBeanDefinitions(res);
((ConfigurableBeanFactory) bf).addBeanPostProcessor(new MyBeanPostProcessor());
((ConfigurableBeanFactory) bf).addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());
Car car1 = (Car) bf.getBean("car");
car1.introduce();
car1.setColor("红色");
Car car2 = (Car) bf.getBean("car");
System.out.println("car1==car2:" + (car1 == car2));
((DefaultListableBeanFactory)bf).destroySingletons();
}
public static void main(String[] args) {
LifeCycleInBeanFactory();
}
}
最后可以看到会输出以下信息。
MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation
调用Car构造函数
InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation
InstantiationAwareBeanPostProcessor.postProcessPropertyValues
调用setBrand()设置属性
调用BeanNameAware.setBeanName().
---------------car-------------------
调用BeanFactoryAware.setBeanFactory().
调用BeanPostProcessor.postProcessBeforeInitialization(),color为空,设置为默认黑色
调用InitializingBean.afterPropertiesSet().
调用init-method所指定的myInit(),将maxSpeed设置为240.
调用BeanPostProcessor.postProcessAfterInitialization(),将maxSpeed调整为200.
brand:红旗CA72;color:黑色;maxSpeed200
car1==car2:true
调用DisposableBean.destroy().
调用destroy-method所指定定的mDestroy().
ApplicationContext中Bean的生命周期
具体过程与上述BeanFactory中Bean的生命周期类似,这里不再详解。
参考:https://blog.csdn.net/qq_32651225/article/details/78323527