目录
BeanDefinition存储到一个名为beanDefinitionMap
一、什么是Bean的生命周期
Spring其实就是一个管理Bean对象的工厂。它负责对象的创建,对象的销毁等。所谓的生命周期就是:对象从创建开始到最终销毁的整个过程。什么时候创建Bean对象?创建Bean对象的前后会调用什么方法?Bean对象什么时候销毁?Bean对象的销毁前后调用什么方法?
其实生命周期的本质是:在哪个时间节点上调用了哪个类的哪个方法。我们需要充分的了解在这个生命线上,都有哪些特殊的时间节点。只有我们知道了特殊的时间节点都在哪,到时我们才可以确定代码写到哪。我们可能需要在某个特殊的时间点上执行一段特定的代码,这段代码就可以放到这个节点上。当生命线走到这里的时候,自然会被调用。
二、Bean的生命周期之5步
Bean生命周期的管理,可以参考Spring的源码:AbstractAutowireCapableBeanFactory类的doCreateBean()方法。
Bean生命周期可以粗略的划分为五大步:
- 第一步:实例化Bean
- 第二步:Bean属性赋值
- 第三步:初始化Bean
- 第四步:使用Bean
- 第五步:销毁Bean
编写测试程序:定义一个Bean
public class User { private String name; public User() { System.out.println("1.实例化Bean"); } public void setName(String name) { this.name = name; System.out.println("2.Bean属性赋值"); } public void initBean(){ System.out.println("3.初始化Bean"); } public void destroyBean(){ System.out.println("5.销毁Bean"); } }
applicationContext.xml配置
需要在<bean>标签中调用init-method和destroy-method属性,手动指定初始化方法和销毁方法!
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- init-method属性指定初始化方法。 destroy-method属性指定销毁方法。 --> <bean id="userBean" class="com.zkt.bean.User" init-method="initBean" destroy-method="destroyBean"> <property name="name" value="zhangsan"/> </bean> </beans>
测试程序
- ①需要手动关闭Spring容器(调用close方法),这样Spring容器才会销毁Bean,才会去调用我们定义的destroyBean方法!
- ② 注意:只有ApplicationContext的实现类ClassPathXmlApplicationContext有close方法,ApplicationContext没有,所以需要强制类型转换;然后调用close方法!
public class BeanLifecycleTest { @Test public void testBeanLifeCycleFive(){ ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); User user = applicationContext.getBean("user", User.class); System.out.println("第四步:使用Bean"+user); // 需要手动关闭Spring容器 ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext; context.close(); } }
执行结果:
需要注意的:
- 第一:只有正常关闭spring容器,bean的销毁方法才会被调用。
- 第二:ClassPathXmlApplicationContext类才有close()方法。
- 第三:配置文件中的init-method指定初始化方法。destroy-method指定销毁方法。
三、Bean生命周期之7步
在以上的5步中,第3步是初始化Bean,如果你还想在初始化前和初始化后添加代码,可以加入“Bean后处理器”。编写一个类实现BeanPostProcessor类,并且重写before和after方法:
Bean生命周期可以细化为七大步:
- 第一步:实例化Bean
- 第二步:Bean属性赋值
- 第三步:执行“Bean后处理器”的before方法
- 第四步:初始化Bean
- 第五步:执行“Bean后处理器”的after方法
- 第六步:使用Bean
- 第七步:销毁Bean
编写一个类实现BeanPostProcessor类,并且重写before和after方法
注意:方法中有两个参数:
- ①第一个参数是创建的Bean对象!
- ②第二个参数是Bean的名字!
public class LogBeanPostProcessor 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); } }
在applicationContext.xml文件中配置“Bean后处理器”:
<!--配置Bean后处理器。这个后处理器将作用于当前配置文件中所有的bean。--> <bean class="com.zkt.bean.LogBeanPostProcessor"/>
一定要注意:在spring.xml文件中配置的Bean后处理器将作用于当前配置文件中所有的Bean。
执行测试程序:
如果加上Bean后处理器的话,Bean的生命周期就是7步了:
四、Bean生命周期之10步
(1)在“Bean后处理器”before方法之前干了什么事儿?
检查Bean是否实现了Aware相关的接口,如果实现了接口则调用这些接口中的方法;调用这些方法的目的是为了给你传递一些数据,让你更加方便使用。(2)在“Bean后处理器”before方法之后干了什么事儿?
检查Bean是否实现了InitializingBean接口,如果实现了,则调用接口中的方法。(3)使用Bean之后,或者说销毁Bean之前干了什么事儿?
检查Bean是否实现了DisposableBean接口,如果实现了,则调用接口中的方法。总结:添加的这三个点位的特点,都是在检查你这个Bean是否实现了某些特定的接口,如果实现了这些接口,则Spring容器会调用这个接口中的方法!
如果根据源码跟踪,可以划分更细粒度的步骤,10步:
上图中检查Bean是否实现了Aware的相关接口是什么意思?
Aware相关的接口包括:BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
- 当Bean实现了BeanNameAware,Spring会将Bean的名字传递给Bean。
- 当Bean实现了BeanClassLoaderAware,Spring会将加载该Bean的类加载器传递给Bean。
- 当Bean实现了BeanFactoryAware,Spring会将Bean工厂对象传递给Bean。
测试以上10步,可以让User类实现5个接口,并实现所有方法:
- BeanNameAware
- BeanClassLoaderAware
- BeanFactoryAware
- InitializingBean
- DisposableBean
代码如下:
public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean { private String name; public User() { System.out.println("1.实例化Bean"); } public void setName(String name) { this.name = name; System.out.println("2.Bean属性赋值"); } public void initBean(){ System.out.println("6.初始化Bean"); } public void destroyBean(){ System.out.println("10.销毁Bean"); } @Override public void setBeanClassLoader(ClassLoader classLoader) { System.out.println("3.类加载器:" + classLoader); } @Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { System.out.println("3.Bean工厂:" + beanFactory); } @Override public void setBeanName(String name) { System.out.println("3.bean名字:" + name); } @Override public void destroy() throws Exception { System.out.println("9.DisposableBean destroy"); } @Override public void afterPropertiesSet() throws Exception { System.out.println("5.afterPropertiesSet执行"); } }
public class LogBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("4.Bean后处理器的before方法执行,即将开始初始化"); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("7.Bean后处理器的after方法执行,已完成初始化"); return bean; } }
执行结果:
通过测试可以看出来:
- InitializingBean的方法早于init-method的执行。
- DisposableBean的方法早于destroy-method的执行。
五、Bean的作用域不同,管理方式不同
Spring 根据Bean的作用域来选择管理方式。
- 对于singleton作用域的Bean,Spring 能够精确地知道该Bean何时被创建,何时初始化完成,以及何时被销毁;
- 而对于 prototype 作用域的 Bean,Spring 只负责创建,当容器创建了 Bean 的实例后,Bean 的实例就交给客户端代码管理,Spring 容器将不再跟踪其生命周期。
我们把之前User类的applicationContext.xml文件中的配置scope设置为prototype:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- init-method属性指定初始化方法。 destroy-method属性指定销毁方法。 --> <bean id="userBean" class="com.zkt.bean.User" init-method="initBean" destroy-method="destroyBean" scope="prototype"> <property name="name" value="zhangsan"/> </bean> <!--配置Bean后处理器。这个后处理器将作用于当前配置文件中所有的bean。--> <bean class="com.zkt.bean.LogBeanPostProcessor"/> </beans>
执行测试程序:
通过测试一目了然。只执行了前8步,第9和10都没有执行。
六、自己new的对象如何让Spring管理
有些时候可能会遇到这样的需求,某个java对象是我们自己new的,然后我们希望这个对象被Spring容器管理,怎么实现?
public class User { }
public class RegisterBeanTest { @Test public void testBeanRegister(){ // 自己new的对象 User user = new User(); System.out.println(user); // 创建 默认可列表BeanFactory 对象 DefaultListableBeanFactory factory = new DefaultListableBeanFactory(); // 注册Bean factory.registerSingleton("userBean", user); // 从spring容器中获取bean User userBean = factory.getBean("userBean", User.class); System.out.println(userBean); } }
执行结果:
七、总结
实例化(Instantiation):
在这一阶段,Spring容器通过调用无参构造方法来创建bean实例。
1.项目启动后,spring委派给bean的信息读取器读取xml或注解,将每个bean
标签转化为beandefinition信息对象并打包存在map集合
2.从map集合中提取出每个bean的信息对象执行工厂后处理器
3.创建出1个半成品javabean对象属性注入(Dependency Injection):
Spring通过依赖注入(setter注入或构造函数注入)将配置文件中指定的属性值或依赖对象注入到bean实例中。初始化(Initialization):
在属性注入完成后,如果bean实现了InitializingBean
接口,Spring将调用afterPropertiesSet()
方法。另外,如果在bean配置中指定了自定义的初始化方法,Spring也会调用该方法。
半成品javabean对象依次执行属性赋值
aware接口
后处理器before
接口初始化
属性初始化
后处理器after
并创建出完整javabean对象存在singletonObjectsmap集合中使用(Usage):
在初始化完成后,bean就可以被应用程序使用了。在这个阶段,bean通常会执行它的业务逻辑。
用户调用getbean方法,从singletonObjectsmap集合中 提取到想要的对象内容销毁(Destruction):
当Spring容器关闭时,如果bean实现了DisposableBean
接口,Spring将调用destroy()
方法。同样,如果在bean配置中指定了自定义的销毁方法,Spring也会调用该方法。
伴随容器的关闭,自动回收一部分javabean对象, 回收时会自动调用接口的销毁以及属性的销毁
八、一些细节
1. Bean 实例化的基本流程
Spring容器在进行初始化时,会将xml配置的的信息封装成一个BeanDefinition对象,所有的 BeanDefinition存储到一个名为beanDefinitionMap的Map集合中去,Spring框架在对该Map进行遍 历,使用反 射创建Bean实例对象,创建好的Bean对象存储在一个名为singletonObjects的Map集合中,当调用 getBean方法 时则最终从该Map集合中取出Bean实例对象返回
Bean信息定义对象-BeanDefinition
BeanDefinition存储到一个名为beanDefinitionMap
对象存储在一个名为singletonObjects的Map
Bean 实例化的基本流程
- 加载xml配置文件,解析获取配置中的每个的信息,封装成一个个的BeanDefinition对象;
- 将BeanDefinition存储在一个名为beanDefinitionMap的Map中;
- ApplicationContext底层遍历beanDefinitionMap,创建Bean实例对象;
- 创建好的Bean实例对象,被存储到一个名为singletonObjects的Map中;
- 当执行applicationContext.getBean(beanName)时,从singletonObjects去匹配Bean实例返回
2. Spring的后处理器
Spring的后处理器是Spring对外开发的重要扩展点,允许我们介入到Bean的整个实例化流程中来,以达到动态注册BeanDefinition,动态修改BeanDefinition,以及动态修改Bean的作用。Spring主要有两种后处理 器:
- BeanFactoryPostProcessor:Bean工厂后处理器,在BeanDefinitionMap填充完毕,Bean实例 化之前执行;
- BeanPostProcessor:Bean后处理器,一般在Bean实例化之后,填充到单例池singletonObjects 之前执行。
2.1 BeanFactoryPostProcessor
Bean 工厂后处理器 – BeanFactoryPostProcessorBeanFactoryPostProcessor是一个接口规范,实现了该接口的类只要交由Spring 容器管理的话,那么Spring就会回调该接口的方法,用于对BeanDefinition 注册 和 修改 的功能。演示修改:1. 创建 BeanFactoryPostProcessor 实现类并重写方法2. 注入实现类演示注册:1. 创建 BeanFactoryPostProcessor 实现类并重写方法2. 注入实现类Bean 工厂后处理器 – BeanDefinitionRegistryPostProcessorSpring 提供了一个 BeanFactoryPostProcessor 的子接口 BeanDefinitionRegistryPostProcessor 专门用于注册BeanDefinition 操作public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor { @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException { // Implementation goes here } @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException { BeanDefinition beanDefinition = new RootBeanDefinition(); beanDefinition.setBeanClassName("com.apesource.pojo.Student"); beanDefinitionRegistry.registerBeanDefinition("stu", beanDefinition); } }
2.2 BeanPostProcessor
Bean 后处理器 – BeanPostProcessorBean被实例化后,到最终缓存到名为 singletonObjects 单例池之前,中间会经过 Bean 的初始化过程, 例如:属性的填充、初始方法init 的执行等,其中有一个对外进行扩展的点 BeanPostProcessor ,我们称为 Bean后处理。跟上 面的 Bean 工厂后处理器相似,它也是一个接口,实现了该接口并被容器管理的 BeanPostProcessor ,会在流程节点上被 Spring 自动调用。自定义演示:1. 自定义
MyBeanPostProcessor
类:1public class MyBeanPostProcessor implements BeanPostProcessor { 2 3 /* 4 * 参数:bean是当前被实例化的Bean,beanName是当前Bean实例在容器中的名称 5 * 返回值:当前Bean实例对象 6 */ 7 @Override 8 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 9 System.out.println("BeanPostProcessor的before方法..."); 10 return bean; 11 } 12 13 /* 14 * 参数:bean是当前被实例化的Bean,beanName是当前Bean实例在容器中的名称 15 * 返回值:当前Bean实例对象 16 */ 17 @Override 18 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 19 System.out.println("BeanPostProcessor的after方法..."); 20 return bean; 21 } 22}
2. 注入配置
MyBeanPostProcessor
:1<!-- 假设这是Spring配置文件的一部分 --> 2<bean id="myBeanPostProcessor" class="com.apesource.processors.MyBeanPostProcessor" /> 3 4<!-- 假设有另一个bean定义用于User --> 5<bean id="user" class="com.apesource.pojo.User" />
3. 测试控制台打印结果如下:
1User创建了... 2BeanPostProcessor的before方法... 3User属性填充... 4User初始化方法执行... 5BeanPostProcessor的after方法... 6com.apesource.pojo.User@56ac3a89
3. 常用的Aware接口
Aware接口是一种框架辅助属性注入的一种思想,其他框架中也可以看到类似的接口。框架具备高度封装性,我们接 触到的一般都是业务代码,一个底层功能API 不能轻易的获取到,但是这不意味着永远用不到这些对象,如果用到了 ,就可以使用框架提供的类似Aware 的接口,让框架给我们注入该对象总结:处理器的作用,为Bean 生命周期各个阶段提供扩展
Aware接口 回调方法 作用 ServletContextAware setServletContext(ServletContext context) Spring框架回调方法注入ServletContext对象,web环境下才生效 BeanFactoryAware setBean(BeanFactory factory) Spring框架回调方法注入beanFactory对象 BeanNameAware setBeanName(String beanName) Spring框架回调方法注入当前Bean在容器中的beanName ApplicationContextAware setApplicationContext(ApplicationContext applicationContext) Spring框架回调方法注入applicationContext对象
生命周期总结: