文章目录
上一篇:(七)Bean的实例化方式
下一篇:(九)Spring之Bean的循环依赖问题
环境
spring6里程碑版本的仓库
依赖:spring context依赖、junit依赖、log4j2依赖
log4j2.xml文件放到类路径下。
什么是Bean的生命周期
Spring其实就是一个管理Bean对象的工厂。它负责对象的创建,对象的销毁等。
所谓的生命周期就是:对象从创建开始到最终销毁的整个过程。
Bean生命周期的管理,可以参考Spring的源码:AbstractAutowireCapableBeanFactory类的doCreateBean()方法。
为什么要知道Bean的生命周期
其实生命周期的本质是:在哪个时间节点上调用了哪个类的哪个方法。
我们需要充分的了解在这个生命线上,都有哪些特殊的时间节点。
只有我们知道了特殊的时间节点都在哪,到时我们才可以确定代码写到哪。
我们可能需要在某个特殊的时间点上执行一段特定的代码,这段代码就可以放到这个节点上。当生命线走到这里的时候,自然会被调用。
Bean生命周期之5步
Bean生命周期之五大步:
- 第一步:实例化Bean (调用无参数构造方法)
- 第二步:Bean属性赋值 (调用set)
- 第三步:初始化Bean (调用Bean的初始化方法)
- 第四步:使用Bean
- 第五步:销毁Bean (调用Bean的销毁方法)
定义一个Bean:SpringBean5类
初始化方法和销毁方法需要自己定义。
public class SpringBean5 {
private String name;
public void setName(String name) {
System.out.println("第二步:Bean属性赋值。");
this.name = name;
}
public SpringBean5() {
System.out.println("第一步:实例化Bean。");
}
public void init(){
//这个方法需要自己写自己配,不一定是这个方法名,方法名随意。
System.out.println("第三步:初始化Bean。");
}
public void destroy(){
//这个方法也需要自己写自己配,不一定是这个方法名,方法名随意。
System.out.println("第五步:销毁Bean。");
}
}
创建spring5.xml配置:
需要在配置文件配置通过init-method属性配置初始化方法,通过destroy-method属性配置销毁方法
<bean id="springBean5" class="com.bean.lifecycle.bean.SpringBean5" init-method="initBean" destroy-method="destroyBean">
<property name="name" value="张三"/>
</bean>
测试程序:
@Test
public void testBeanLifecycle5(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring5.xml");
SpringBean5 springBean5 = applicationContext.getBean("springBean5", SpringBean5.class);
System.out.println("第四步:使用Bean:" + springBean5);
//必须手动关闭Spring容器,注意Spring容器才会销毁Bean
//applicationContext没有close这个方法,这个方法在ClassPathXmlApplicationContext里面,需要进行转型
((ClassPathXmlApplicationContext) applicationContext).close();
}
Bean生命周期之7步
Bean生命周期之七大步:比五步在初始化Bean的前和后多两步
- 第一步:实例化Bean (调用无参数构造方法)
- 第二步:Bean属性赋值 (调用set)
- 第三步:执行“Bean后处理器”的before方法。
- 第四步:初始化Bean (调用Bean的初始化方法)
- 第五步:执行“Bean后处理器”的after方法。
- 第六步:使用Bean
- 第七步:销毁Bean (调用Bean的销毁方法)
定义一个Bean:SpringBean7类
public class SpringBean7 {
private String name;
public void setName(String name) {
System.out.println("第二步:Bean属性赋值。");
this.name = name;
}
public SpringBean7() {
System.out.println("第一步:实例化Bean。");
}
public void init(){
//这个方法需要自己写自己配,不一定是这个方法名,方法名随意。
System.out.println("第四步:初始化Bean。");
}
public void destroy(){
//这个方法也需要自己写自己配,不一定是这个方法名,方法名随意。
System.out.println("第七步:销毁Bean。");
}
}
要想实现“Bean后处理器”,需要实现BeanPostProcessor接口,并且重写before和after方法
接口如下:
这两个方法都是默认方法,都有两个参数,并且默认都返回bean
- bean参数:bean对象
- beanName参数:bean的名字
public interface BeanPostProcessor {
@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Nullable
default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
}
创建一个SpringBeanPostProcessor类实现该接口:
public class SpringBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("第三步:执行Bean后处理器的before方法。");
return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("第五步:执行Bean后处理器的after方法。");
return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
}
}
创建spring7.xml配置:
需要配置Bean后处理器,这个配置将作用于当前整个配置文件种所有的Bean。
<bean id="springBean7" class="com.bean.lifecycle.bean.SpringBean7" init-method="initBean" destroy-method="destroyBean">
<property name="name" value="张三"/>
</bean>
<bean class="com.bean.lifecycle.bean.SpringBeanPostProcessor"/>
测试程序:
@Test
public void testBeanLifecycle7(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring7.xml");
SpringBean7 springBean7 = applicationContext.getBean("springBean7", SpringBean7.class);
System.out.println("第六步:使用Bean:" + springBean7);
//必须手动关闭Spring容器,注意Spring容器才会销毁Bean
//applicationContext没有close这个方法,这个方法在ClassPathXmlApplicationContext里面,需要进行转型
((ClassPathXmlApplicationContext) applicationContext).close();
}
Bean生命周期之10步
Bean生命周期之十大步:多了三个点位
- 第一步:实例化Bean (调用无参数构造方法)
- 第二步:Bean属性赋值 (调用set)
- 点位1:检查Bean是否实现Aware相关接口,并调用接口中的方法。
- 第三步:执行“Bean后处理器”的before方法。
- 点位2:检查Bean是否实现InitializingBean接口,并调用接口中的方法
- 第四步:初始化Bean (调用Bean的初始化方法)
- 第五步:执行“Bean后处理器”的after方法。
- 第六步:使用Bean
- 点位3:检查Bean是否实现DisposableBean,并调用接口中的方法
- 第七步:销毁Bean (调用Bean的销毁方法)
三个点位详解:
这三个点位的特点:都是在检查你这个Bean是否实现了某些特定的接口,如果实现了这些接口,则Spring容器会调用这个接口中的方法。
点位1
点位1:在“Bean后处理器”before方法之前
检查Bean是否实现了Aware相关的接口,如果实现了接口则调用这些接口中的方法。
然后调用这些方法的目的是为了给你传递一些数据,让你更加方便使用。
Aware相关的接口包括:BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
- 当Bean实现了BeanNameAware,Spring会将Bean的名字传递给setBeanName方法,并调用。
public interface BeanNameAware extends Aware {
void setBeanName(String var1);
}
- 当Bean实现了BeanClassLoaderAware,Spring会将加载该Bean的类加载器传递给setBeanClassLoader方法,并调用。
public interface BeanClassLoaderAware extends Aware {
void setBeanClassLoader(ClassLoader var1);
}
- 当Bean实现了BeanFactoryAware,Spring会将Bean工厂对象传递给setBeanFactory方法,并调用。
public interface BeanFactoryAware extends Aware {
void setBeanFactory(BeanFactory var1) throws BeansException;
}
点位2
点位2:在“Bean后处理器”before方法之后
检查Bean是否实现了InitializingBean接口,如果实现了,则调用接口中的方法。
public interface InitializingBean {
void afterPropertiesSet() throws Exception;
}
点位3
点位3:使用Bean之后,或者说销毁Bean之前
检查Bean是否实现了DisposableBean接口,如果实现了,则调用接口中的方法。
public interface DisposableBean {
void destroy() throws Exception;
}
演示程序
定义一个Bean,分别实现这些接口:SpringBean10类
public class SpringBean10 implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware,InitializingBean,DisposableBean {
private String name;
public void setName(String name) {
System.out.println("第二步:Bean属性赋值。");
this.name = name;
}
public SpringBean10() {
System.out.println("第一步:实例化Bean。");
}
public void initBean(){
//这个方法需要自己写自己配,不一定是这个方法名,方法名随意。
System.out.println("第四步:初始化Bean。");
}
public void destroyBean(){
//这个方法也需要自己写自己配,不一定是这个方法名,方法名随意。
System.out.println("第七步:销毁Bean。");
}
/*
setBeanClassLoader对应:BeanClassLoaderAware接口
setBeanFactory对应:BeanFactoryAware
setBeanName对应:BeanNameAware
afterPropertiesSet对应:InitializingBean
我们自己写的方法destroy与DisposableBean接口的方法重了,所以我们把我们销毁方法改为destroyBean
*/
@Override
public void setBeanClassLoader(ClassLoader classLoader) {
System.out.println("点位1:Bean的类加载器是:" + classLoader);
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("点位1:生产Bean的工厂对象是:" + beanFactory);
}
@Override
public void setBeanName(String s) {
System.out.println("点位1:Bean的名字是:" + s);
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("点位2:InitializingBean接口的afterPropertiesSet方法执行");
}
@Override
public void destroy() throws Exception {
System.out.println("点位3:DisposableBean接口的destroy方法执行");
}
}
Bean后处理器还是使用之前的SpringBeanPostProcessor
创建spring10.xml配置:
<bean id="springBean10" class="com.bean.lifecycle.bean.SpringBean10"
init-method="initBean" destroy-method="destroyBean">
<property name="name" value="张三"/>
</bean>
<bean class="com.bean.lifecycle.bean.SpringBeanPostProcessor"/>
测试程序:
@Test
public void testBeanLifecycle10(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring10.xml");
SpringBean10 springBean10 = applicationContext.getBean("springBean10", SpringBean10.class);
System.out.println("第六步:使用Bean:" + springBean10);
//必须手动关闭Spring容器,注意Spring容器才会销毁Bean
//applicationContext没有close这个方法,这个方法在ClassPathXmlApplicationContext里面,需要进行转型
((ClassPathXmlApplicationContext) applicationContext).close();
}
Bean的作用域不同,管理方式不同
Spring 根据Bean的作用域来选择管理方式。
- 对于singleton作用域的Bean,Spring 能够精确地知道该Bean何时被创建,何时初始化完成,以及何时被销毁;
- 对于 prototype 作用域的 Bean,Spring 只负责创建,当容器创建了 Bean 的实例后,Bean的实例就交给客户端代码管理,Spring容器将不再跟踪其生命周期。
演示程序使用之前的Bean生命周期10步,只需要把Bean改成多例的即可,spring10配置:
<bean id="springBean10" class="com.bean.lifecycle.bean.SpringBean10"
init-method="initBean" destroy-method="destroyBean" scope="prototype">
<property name="name" value="张三"/>
</bean>
再次运行程序:
只管理到了使用Bean
自己new的对象如何让Spring管理
有些时候可能会遇到这样的需求,某个java对象是我们自己new的,然后我们希望这个对象被Spring容器管理,怎么实现?
两个步骤:
- 步骤一:创建默认可列表BeanFactory对象
- 步骤二:调用相关方法把自己new的对象注册进去
创建一个Bean:Student类
public class Student {
}
测试程序:
@Test
public void testRsgisterBean(){
//自己new的对象
Student student = new Student();
System.out.println(student);
//将自己new的对象纳入Spring容器进行管理
//首先创建默认可列表BeanFactory对象
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
//然后调用相关方法把对象注册进去
factory.registerSingleton("studentBean",student);
//从Spring容器中获取
Object studentBean = factory.getBean("studentBean");
System.out.println(studentBean);
}