目录
Bean的生命周期7步走系列:在实例化Bean的前和后加了两步。????
定义myInstantiationAwareBeanPostProcessor 类
实现InstantiationAwareBeanPostProcessor 接口
Bean的生命周期9步系列:在初始化Bean的前和后添加两步。
需要实现BeanPostProcessor接口并重写 Initialization 的两个方法
Bean的生命周期10步走系列:比9步多了在属性赋值之后感知
Bean的生命周期11步走系列:比10步多添加了初始化Bean之前处理的方法。
Bean的生命周期12步走系列:在销毁Bean之前添加了一步。
Bean的生命周期5步走系列：
分别是如下图：
BeanLifeCycle类
/**
* Bean的生命周期按照粗略的五步的话:
* 第一步:实例化Bean(调用无参数构造方法。)
* 第二步:给Bean属性赋值(调用set方法。)
* 第三步:初始化Bean (会调用Bean的init方法。注意:这个init方法需要自己写,自己配。)
* 第四步:使用Bean
* 第五步:销毁Bean (公调用Bean/destroy方法。注意:这个destroy方法需要自己写,自己配。)
* @Author darren
* @Date 2022/11/2 9:25
*/
public class BeanLifeCycle {
private String name;
public BeanLifeCycle() {
System.out.println("第一步:实例化Bean");
}
public String getName() {
return name;
}
public void setName(final String name) {
System.out.println("第二步:给Bean属性赋值");
this.name = name;
}
public void initMethod(){
System.out.println("第三步:初始化Bean");
}
public void destroyMethod(){
System.out.println("第五步:销毁Bean ");
}
@Override
public String toString() {
return "BeanLifeCycle{" +
"name='" + name + '\'' +
'}';
}
}Spring.xml 配置文件
<!--Bean 的生命周期-->
<bean id="beanLife" class="com.power.node.spring6.bean.BeanLifeCycle" init-method="initMethod"
destroy-method="destroyMethod">
<property name="name" value="bean_name"/>
</bean>BeanLifeTest测试方法
public class BeanLifeTest {
/**
* Bean的生命周期
*/
@Test
public void testBeanLifeCycle(){
ClassPathXmlApplicationContext classPathXmlApplicationContext =
new ClassPathXmlApplicationContext("beanLife.xml");
BeanLifeCycle beanLife = classPathXmlApplicationContext.getBean("beanLife", BeanLifeCycle.class);
System.out.println("第四步:使用Bean "+beanLife.toString());
System.out.println("");
classPathXmlApplicationContext.close();
}
}运行结果：
第一步:实例化Bean
第二步:给Bean属性赋值
第三步:初始化Bean
第四步:使用Bean BeanLifeCycle{name='bean_name'}
第五步:销毁Bean Bean的生命周期7步走系列:在实例化Bean的前和后加了两步。
????
如图：
?
定义myInstantiationAwareBeanPostProcessor 类
实现InstantiationAwareBeanPostProcessor 接口
/**
* 实例化前后处理器
* @Author darren
* @Date 2022/11/2 17:16
*/
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public Object postProcessBeforeInstantiation(final Class<?> beanClass, final String beanName)
throws BeansException {
System.out.println(" 第1.1步-实例化之前-后期处理器");
return InstantiationAwareBeanPostProcessor.super.postProcessBeforeInstantiation(beanClass,
beanName);
}
@Override
public boolean postProcessAfterInstantiation(final Object bean, final String beanName)
throws BeansException {
System.out.println(" 第1.1步-实例化之后-后期处理器");
System.out.println("");
return InstantiationAwareBeanPostProcessor.super.postProcessAfterInstantiation(bean,
beanName);
}
}并将这个类配置到Spring.xml中
<!--Bean 的生命周期-->
<bean id="beanLife" class="com.power.node.spring6.bean.BeanLifeCycle" init-method="initMethod"
destroy-method="destroyMethod">
<property name="name" value="bean_name"/>
</bean>
<!--实例化前后处理器-->
<bean id="myInstantiationAwareBeanPostProcessor"
class="com.power.node.spring6.bean.MyInstantiationAwareBeanPostProcessor"/>
</beans>复用5步走的测试方法
运行结果：
??????????第1.1步-实例化之前-后期处理器
??? 第一步:实例化Bean
??????? ? 第1.2步-实例化之后-后期处理器
??? 第二步:Bean属性赋值
??? 第三步:初始化Bean
??? 第四步:使用Bean
??? 第五步:销毁Bean
注意：
??? 需要实现InstantiationAwareBeanPostProcessor接口并重写Instantiation方法后并配置到xml,
??????? postProcessBeforeInstantiation:实例化之前-后期处理器
??????? postProcessAfterInstantiation :实例化之后-后期处理器Bean的生命周期9步系列:在初始化Bean的前和后添加两步。
?
需要实现BeanPostProcessor接口并重写 Initialization 的两个方法
postProcessBeforeInitialization:初始化之前-后期处理器
postProcessAfterInitialization :初始化之后-后期处理器/**
* 初始化前后置处理器
* @Author darren
* @Date 2022/11/2 9:56
*/
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(final Object bean, final String beanName)
throws BeansException {
System.out.println(" 第3.1步-初始化前的-后期处理器");
return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
}
@Override
public Object postProcessAfterInitialization(final Object bean, final String beanName)
throws BeansException {
System.out.println(" 第3.2步-初始化后的-后期处理器");
System.out.println("");
return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
}
}Spring.xml配置
<!--Bean 的生命周期-->
<bean id="beanLife" class="com.power.node.spring6.bean.BeanLifeCycle" init-method="initMethod"
destroy-method="destroyMethod">
<property name="name" value="bean_name"/>
</bean>
<!--实例化前后处理器-->
<bean id="myInstantiationAwareBeanPostProcessor"
class="com.power.node.spring6.bean.MyInstantiationAwareBeanPostProcessor"/>
<!--初始化前后置处理器-->
<bean id="myBeanPostProcessor" class="com.power.node.spring6.bean.MyBeanPostProcessor"/>复用5步走的测试方法
测试结果：
第1.1步-实例化之前-后期处理器
第一步:实例化Bean
第1.1步-实例化之后-后期处理器
第二步:给Bean属性赋值
第3.1步-初始化前的-后期处理器
第三步:初始化Bean
第3.2步-初始化后的-后期处理器
第四步:使用Bean BeanLifeCycle{name='bean_name'}
第五步:销毁Bean Bean的生命周期10步走系列:比9步多了在属性赋值之后感知
如图：
BeanLifeCycle类
需要这个类实现Aware(感知)接口，
如：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware、ApplicationContextAware
在属性赋值之后感知可以获取或设置下面信息
BeanName、BeanClassLoader、BeanFactory、ApplicationContext
public class BeanLifeCycle implements BeanNameAware, BeanFactoryAware, BeanClassLoaderAware,
ApplicationContextAware {
private String name;
public BeanLifeCycle() {
System.out.println("第一步:实例化Bean");
}
public String getName() {
return name;
}
public void setName(final String name) {
System.out.println("第二步:给Bean属性赋值");
this.name = name;
}
@Override
public void setBeanName(final String s) {
System.out.println(" 第2.2步-属性感知-设置属性名称:"+s);
}
@Override
public void setBeanClassLoader(final ClassLoader classLoader) {
System.out.println(" 第2.3步-属性感知-设置类加载器:"+classLoader);
}
@Override
public void setBeanFactory(final BeanFactory beanFactory) throws BeansException {
System.out.println(" 第2.4步-属性感知-设置bean工厂:"+beanFactory);
}
@Override
public void setApplicationContext(final ApplicationContext applicationContext)
throws BeansException {
System.out.println(" 第2.5步-属性感知-设置上下文:"+applicationContext);
System.out.println("");
}
public void initMethod(){
System.out.println("第三步:初始化Bean");
}
public void destroyMethod(){
System.out.println("第五步:销毁Bean ");
}
@Override
public String toString() {
return "BeanLifeCycle{" +
"name='" + name + '\'' +
'}';
}
}复用5步走的测试方法
测试结果：
第1.1步-实例化之前-后期处理器
第一步:实例化Bean
第1.1步-实例化之后-后期处理器
第二步:给Bean属性赋值
第2.2步-属性感知-设置属性名称:beanLife
第2.3步-属性感知-设置类加载器:jdk.internal.loader.ClassLoaders$AppClassLoader@78308db1
第2.4步-属性感知-设置bean工厂:org.springframework.beans.factory.support.DefaultListableBeanFactory@5812f68b: defining beans [beanLife,myInstantiationAwareBeanPostProcessor,myBeanPostProcessor]; root of factory hierarchy
第2.5步-属性感知-设置上下文:org.springframework.context.support.ClassPathXmlApplicationContext@29f7cefd, started on Wed Nov 02 21:11:42 CST 2022
第3.1步-初始化前的-后期处理器
第三步:初始化Bean
第3.2步-初始化后的-后期处理器
第四步:使用Bean BeanLifeCycle{name='bean_name'}
第五步:销毁Bean Bean的生命周期11步走系列:比10步多添加了初始化Bean之前处理的方法。
如图：
BeanLifeCycle类
需要这个类实现InitializingBean接口，重写afterPropertiesSet方法
public class BeanLifeCycle implements BeanNameAware, BeanFactoryAware, BeanClassLoaderAware,
ApplicationContextAware, InitializingBean {
private String name;
public BeanLifeCycle() {
System.out.println("第一步:实例化Bean");
}
public String getName() {
return name;
}
public void setName(final String name) {
System.out.println("第二步:给Bean属性赋值");
this.name = name;
}
@Override
public void setBeanName(final String s) {
System.out.println(" 第2.2步-属性感知-设置属性名称:"+s);
}
@Override
public void setBeanClassLoader(final ClassLoader classLoader) {
System.out.println(" 第2.3步-属性感知-设置类加载器:"+classLoader);
}
@Override
public void setBeanFactory(final BeanFactory beanFactory) throws BeansException {
System.out.println(" 第2.4步-属性感知-设置bean工厂:"+beanFactory);
}
@Override
public void setApplicationContext(final ApplicationContext applicationContext)
throws BeansException {
System.out.println(" 第2.5步-属性感知-设置上下文:"+applicationContext);
System.out.println("");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println(" 第3.1.1步-初始化之前调用");
}
public void initMethod(){
System.out.println("第三步:初始化Bean");
}
public void destroyMethod(){
System.out.println("第五步:销毁Bean ");
}
@Override
public String toString() {
return "BeanLifeCycle{" +
"name='" + name + '\'' +
'}';
}
}
复用5步走的测试方法
测试结果：
第1.1步-实例化之前-后期处理器
第一步:实例化Bean
第1.1步-实例化之后-后期处理器
第二步:给Bean属性赋值
第2.2步-属性感知-设置属性名称:beanLife
第2.3步-属性感知-设置类加载器:jdk.internal.loader.ClassLoaders$AppClassLoader@78308db1
第2.4步-属性感知-设置bean工厂:org.springframework.beans.factory.support.DefaultListableBeanFactory@5812f68b: defining beans [beanLife,myInstantiationAwareBeanPostProcessor,myBeanPostProcessor]; root of factory hierarchy
第2.5步-属性感知-设置上下文:org.springframework.context.support.ClassPathXmlApplicationContext@29f7cefd, started on Wed Nov 02 21:11:42 CST 2022
第3.1步-初始化前的-后期处理器
第3.1.1步-初始化之前调用
第三步:初始化Bean
第3.2步-初始化后的-后期处理器
第四步:使用Bean BeanLifeCycle{name='bean_name'}
第五步:销毁Bean Bean的生命周期12步走系列:在销毁Bean之前添加了一步。
如图：
?
BeanLifeCycle类
需要这个类实现DisposableBean接口，并重写destroy方法，调用时机是在指定destroy-method 之前调用
public class BeanLifeCycle implements BeanNameAware, BeanFactoryAware, BeanClassLoaderAware,
ApplicationContextAware, InitializingBean, DisposableBean {
private String name;
public BeanLifeCycle() {
System.out.println("第一步:实例化Bean");
}
public String getName() {
return name;
}
public void setName(final String name) {
System.out.println("第二步:给Bean属性赋值");
this.name = name;
}
@Override
public void setBeanName(final String s) {
System.out.println(" 第2.2步-属性感知-设置属性名称:"+s);
}
@Override
public void setBeanClassLoader(final ClassLoader classLoader) {
System.out.println(" 第2.3步-属性感知-设置类加载器:"+classLoader);
}
@Override
public void setBeanFactory(final BeanFactory beanFactory) throws BeansException {
System.out.println(" 第2.4步-属性感知-设置bean工厂:"+beanFactory);
}
@Override
public void setApplicationContext(final ApplicationContext applicationContext)
throws BeansException {
System.out.println(" 第2.5步-属性感知-设置上下文:"+applicationContext);
System.out.println("");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println(" 第3.1.1步-初始化之前调用");
}
public void initMethod(){
System.out.println("第三步:初始化Bean");
}
@Override
public void destroy() throws Exception {
System.out.println(" 第5.1步-销毁-在destroy-method 之前调用");
}
public void destroyMethod(){
System.out.println("第五步:销毁Bean ");
}
@Override
public String toString() {
return "BeanLifeCycle{" +
"name='" + name + '\'' +
'}';
}
}
复用5步走的测试方法
测试结果：
第1.1步-实例化之前-后期处理器
第一步:实例化Bean
第1.1步-实例化之后-后期处理器
第二步:给Bean属性赋值
第2.2步-属性感知-设置属性名称:beanLife
第2.3步-属性感知-设置类加载器:jdk.internal.loader.ClassLoaders$AppClassLoader@78308db1
第2.4步-属性感知-设置bean工厂:org.springframework.beans.factory.support.DefaultListableBeanFactory@5812f68b: defining beans [beanLife,myInstantiationAwareBeanPostProcessor,myBeanPostProcessor]; root of factory hierarchy
第2.5步-属性感知-设置上下文:org.springframework.context.support.ClassPathXmlApplicationContext@29f7cefd, started on Wed Nov 02 21:11:42 CST 2022
第3.1步-初始化前的-后期处理器
第3.1.1步-初始化之前调用
第三步:初始化Bean
第3.2步-初始化后的-后期处理器
第四步:使用Bean BeanLifeCycle{name='bean_name'}
第5.1步-销毁-在destroy-method 之前调用
第五步:销毁Bean