前言:bean的生命周期:指 bean创建——初始化——销毁 的过程
下面先给出我的参考答案,具体分析请看下文详解:
Spring Bean生命周期为:
1、实例化BeanFactoryPostProcessor实现类
2、执行BeanFactoryPostProcessor的postProcessBeanFactory方法
3、实例化BeanPostProcessor实现类
4、实例化InstantiationAwareBeanPostProcessor实现类
5、执行InstantiationAwareBeanPostProcessor的postProcessorBeforeInstantiation方法
6、执行Bean的构造方法
7、执行InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法
8、为Bean注入属性
9、调用BeanNameAware的setBeanName方法
10、调用BeanFactoryAware的setBeanFactory方法
11、执行BeanFactoryProcessor的postProcessorBeforeInitlalization方法
12、执行InitializingBean的afterPropertiesSet方法
13、调用<bean>的init-method属性指定的初始化方法
14、执行BeanPostProcessor的postProcessAfterinitialization方法
15、执行InstantiationAwareBeanPostProcessor的postProcessAfterinitialization方法
16、容器初始化成功,执行业务代码后,下面开始销毁容器
17、调用DisposibleBean的Destory方法
18、调用<bean>的destroy-method属性指定的初始化方法
通过一段代码的运行结果阐述Spring Bean的Cyclelife的过程,最后结合源代码对SpringBean生命周期进行文字性总结。
本文代码github链接:GitHub - FumingcAI666/spring-demo: 实现Spring Bean生命周期,实现Spring AOP,实现Spring IOC,实现SpringMVC
首先配合此段代码先有个宏观性(创建、初始化、销毁)认识:
测试代码:
package cn.spring.cyclelife;
import cn.spring.bean.FmcBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @author macFmc
* @date 2019/10/9-17:50
*/
public class TestCyclelife {
public static void main(String[] args) {
System.out.println("--------------【初始化容器】---------------");
ApplicationContext context = new ClassPathXmlApplicationContext("META-INF/beandemo.xml");
System.out.println("-------------------【容器初始化成功】------------------");
//得到studentBean,并显示其信息
FmcBean fmcBean = context.getBean("fmcBean", FmcBean.class);
System.out.println(fmcBean);
System.out.println("--------------------【销毁容器】----------------------");
((ClassPathXmlApplicationContext) context).registerShutdownHook();
}
}
测试Bean例类:中的 myInit()
和 ·myDestroy()· 方法供我们在配置文件中通过init-method和destroy-method属性进行指定。
package cn.spring.bean;
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;
/**
* 测试生命周期的Bean
*
* @author macFmc
* @date 2019/10/9-17:45
*/
public class FmcBean implements InitializingBean, DisposableBean, BeanNameAware, BeanFactoryAware {
private String name;
private int age;
/**
* 实现了BeanNameAware接口,Spring可以将BeanName注入该属性中
*/
private String beanName;
/**
* 实现了BeanFactory接口,Spring可将BeanFactory注入该属性中
*/
private BeanFactory beanFactory;
public FmcBean() {
System.out.println("【Bean构造方法】学生类的无参构造方法");
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("FmcBean{");
sb.append("name='").append(name).append('\'');
sb.append(", age=").append(age);
sb.append(", beanName='").append(beanName).append('\'');
sb.append(", beanFactory=").append(beanFactory);
sb.append('}');
return sb.toString();
}
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("【set注入】注入学生的name属性");
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
System.out.println("【set注入】注入学生的age属性");
this.age = age;
}
/**
* 自己编写的初始化方法
*/
public void myInit() {
System.out.println("【init-method】调用init-method属性配置的初始化方法");
}
/**
* 自己编写的销毁方法
*/
public void myDestroy() {
System.out.println("【destroy-method】调用destroy-method属性配置的销毁方法");
}
/**
* BeanFactoryAware接口的方法
*
* @param beanFactory
* @throws BeansException
*/
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
System.out.println("【BeanFactoryAware接口】调用BeanFactoryAware的setBeanFactory方法得到beanFactory引用");
}
/**
* BeanNameAware接口的方法
*
* @param name
*/
@Override
public void setBeanName(String name) {
this.beanName = name;
System.out.println("【BeanNameAware接口】调用BeanNameAware的setBeanName方法得到Bean的名称");
}
/**
* InitializingBean接口的方法
*
* @throws Exception
*/
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("【InitializingBean接口】调用InitializingBean接口的afterPropertiesSet方法");
}
/**
* DisposableBean接口的方法
*
* @throws Exception
*/
@Override
public void destroy() throws Exception {
System.out.println("【DisposableBean接口】调用DisposableBean接口的destroy方法");
}
}
实现BeanPostProcessor接口:
package cn.spring.cyclelife;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
* Bean的后置处理器
*
* @author macFmc
* @date 2019/10/9-22:24
*/
public class MyBeanPostProcessor implements BeanPostProcessor {
public MyBeanPostProcessor() {
System.out.println("【BeanPostProcessor接口】调用BeanPostProcessor的构造方法");
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("【BeanPostProcessor接口】调用postProcessBeforeInitialization方法,这里可对" + beanName + "的属性进行更改。");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("【BeanPostProcessor接口】调用postProcessAfterInitialization方法,这里可对" + beanName + "的属性进行更改。");
return bean;
}
}
实现InstantiationAwareBeanPostProcessor接口:为了编程方便我们直接通过继承Spring中已经提供的一个实现了该接口的适配器类InstantiationAwareBeanPostProcessorAdapter来进行测试。
package cn.spring.cyclelife;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
import java.beans.PropertyDescriptor;
/**
* 实例化Bean后置处理器
* <p>
* 一般情况下,当我们需要实现InstantiationAwareBeanPostProcessor接口时,
* 是通过继承Spring框架中InstantiationAwareBeanPostProcessor接口实现类
* InstantiationAwareBeanPostProcessorAdapter这个适配器类来简化我们实现接口的工作
*
* @author macFmc
* @date 2019/10/9-22:26
*/
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
public MyInstantiationAwareBeanPostProcessor() {
System.out.println("【InstantiationAwareBeanPostProcessor接口】调用InstantiationAwareBeanPostProcessor构造方法");
}
/**
* 实例化Bean之前调用
*/
@Override
public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
System.out.println("【InstantiationAwareBeanPostProcessor接口】调用InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法");
return null;
}
/**
* 实例化Bean之后调用
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("【InstantiationAwareBeanPostProcessor接口】调用InstantiationAwareBeanPostProcessor接口的postProcessAfterInitialization方法");
return bean;
}
/**
* 设置某个属性时调用
*/
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException {
System.out.println("【InstantiationAwareBeanPostProcessor接口】调用InstantiationAwareBeanPostProcessor接口的postProcessPropertyValues方法");
return pvs;
}
}
BeanFactoryPostProcessor接口:
package cn.spring.cyclelife;
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;
/**
* BeanFactory的后置处理器
*
* @author macFmc
* @date 2019/10/9-22:28
*/
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public MyBeanFactoryPostProcessor() {
System.out.println("【BeanFactoryPostProcessor接口】调用BeanFactoryPostProcessor实现类构造方法");
}
/**
* 重写BeanFactoryPostProcessor接口的postProcessBeanFactory方法,可通过该方法对beanFactory进行设置
*/
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException {
System.out.println("【BeanFactoryPostProcessor接口】调用BeanFactoryPostProcessor接口的postProcessBeanFactory方法");
BeanDefinition beanDefinition = beanFactory.getBeanDefinition("fmcBean");
beanDefinition.getPropertyValues().addPropertyValue("age", "21");
}
}
Spring配置文件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"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<!--配置Bean的后置处理器-->
<bean id="beanPostProcessor" class="cn.spring.cyclelife.MyBeanPostProcessor">
</bean>
<!--配置instantiationAwareBeanPostProcessor-->
<bean id="instantiationAwareBeanPostProcessor" class="cn.spring.cyclelife.MyInstantiationAwareBeanPostProcessor">
</bean>
<!--配置BeanFactory的后置处理器-->
<bean id="beanFactoryPostProcessor" class="cn.spring.cyclelife.MyBeanFactoryPostProcessor">
</bean>
<bean id="fmcBean" class="cn.spring.bean.FmcBean" init-method="myInit"
destroy-method="myDestroy" scope="singleton">
<property name="name" value="FuMingCai"></property>
<property name="age" value="21"></property>
</bean>
</beans>
运行结果:
下面根据运行结果与资料进行总结:
Spring Bean生命周期为:
1、实例化BeanFactoryPostProcessor实现类
2、执行BeanFactoryPostProcessor的postProcessBeanFactory方法
3、实例化BeanPostProcessor实现类
4、实例化InstantiationAwareBeanPostProcessor实现类
5、执行InstantiationAwareBeanPostProcessor的postProcessorBeforeInstantiation方法
6、执行Bean的构造方法
7、执行InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法
8、为Bean注入属性
9、调用BeanNameAware的setBeanName方法
10、调用BeanFactoryAware的setBeanFactory方法
11、执行BeanFactoryProcessor的postProcessorBeforeInitlalization方法
12、执行InitializingBean的afterPropertiesSet方法
13、调用<bean>的init-method属性指定的初始化方法
14、执行BeanPostProcessor的postProcessAfterinitialization方法
15、执行InstantiationAwareBeanPostProcessor的postProcessAfterinitialization方法
16、容器初始化成功,执行业务代码后,下面开始销毁容器
17、调用DisposibleBean的Destory方法
18、调用<bean>的destroy-method属性指定的初始化方法