- 作者简介:大家好,我是五度鱼,一个普通的Java领域博主,不停输出Java技术博客和干货。
- 座右铭:锲而不舍,金石可镂。
- 个人主页:五度鱼学Java的主页
文章目录
在Java
中,Bean
是一个重要的概念,它代表了应用程序中的一个对象。在开发中,我们经常使用Bean
来管理对象的生命周期。本文将介绍Bean
的生命周期,并详细讲解如何在Spring
框架中管理Bean
的生命周期。
Spring
其实就是一个管理Bean
对象的工厂。它负责对象的创建,对象的销毁等。
所谓的生命周期就是:对象从创建开始到最终销毁的整个过程。Spring
为每个Bean
定义了若干个回调方法,使得开发人员可以在某个特定的时间点对Bean进行特定的操作。
其实生命周期的本质是:在哪个时间节点上调用了哪个类的哪个方法。
我们需要充分的了解在这个生命线上,都有哪些特殊的时间节点。
只有我们知道了特殊的时间节点都在哪,到时我们才可以确定代码写到哪。
我们可能需要在某个特殊的时间点上执行一段特定的代码,这段代码就可以放到这个节点上。当生命线走到这里的时候,自然会被调用。
Bean
生命周期的管理,可以参考Spring
的源码:AbstractAutowireCapableBeanFactory
类的doCreateBean()
方法。`
Bean生命周期可以粗略的划分为五大步:
- 第一步:实例化
Bean
- 第二步:Bean属性赋值
- 第三步:初始化
Bean
- 第四步:使用
Bean
- 第五步:销毁
Bean
编写测试程序:
定义一个Bean
package com.powernode.spring6.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"); }} package com.powernode.spring6.test;import com.powernode.spring6.bean.User;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class BeanLifecycleTest { @Test public void testLifecycle(){ ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml"); User userBean = applicationContext.getBean("userBean", User.class); System.out.println("4.使用Bean"); // 只有正常关闭spring容器才会执行销毁方法 ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext; context.close(); }}
执行结果:
需要注意的:
- 第一:只有正常关闭spring容器,bean的销毁方法才会被调用。
- 第二:
ClassPathXmlApplicationContext
类才有close()方法。 - 第三:配置文件中的init-method指定初始化方法。
destroy-method
指定销毁方法。
在以上的5步中,第3步是初始化Bean,如果你还想在初始化前和初始化后添加代码,可以加入“Bean后处理器”。
编写一个类实现BeanPostProcessor
类,并且重写before和after方法:
package com.powernode.spring6.bean;import org.springframework.beans.BeansException;import org.springframework.beans.factory.config.BeanPostProcessor;public class LogBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("Bean后处理器的before方法执行,即将开始初始化"); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("Bean后处理器的after方法执行,已完成初始化"); return bean; }}
在spring.xml
文件中配置“Bean后处理器”:
一定要注意:在spring.xml
文件中配置的Bean
后处理器将作用于当前配置文件中所有的Bean
。
执行测试程序:
如果加上Bean后处理器
的话,Bean
的生命周期就是7步了:
如果根据源码跟踪,可以划分更细粒度的步骤,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
代码如下:
package com.powernode.spring6.bean;import org.springframework.beans.BeansException;import org.springframework.beans.factory.*;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执行"); }}package com.powernode.spring6.bean;import org.springframework.beans.BeansException;import org.springframework.beans.factory.config.BeanPostProcessor;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
的执行。
对于SpringBean
的生命周期,掌握之前的7步即可。够用。
Spring
根据Bean
的作用域来选择管理方式。
- 对于
singleton
作用域的Bean
,Spring
能够精确地知道该Bean
何时被创建,何时初始化完成,以及何时被销毁; - 而对于
prototype
作用域的Bean
,Spring
只负责创建,当容器创建了Bean
的实例后,Bean
的实例就交给客户端代码管理,Spring
容器将不再跟踪其生命周期。
把之前User
类的spring.xml
文件中的配置scope
设置为prototype
:
执行测试程序:
通过测试一目了然。只执行了前8步,第9和10都没有执行。
有些时候可能会遇到这样的需求,某个java对象是我们自己new的,然后我们希望这个对象被Spring容器管理,怎么实现?
package com.powernode.spring6.bean;public class User {}package com.powernode.spring6.test;import com.powernode.spring6.bean.User;import org.junit.Test;import org.springframework.beans.factory.support.DefaultListableBeanFactory;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); }}
最后求个关注,点赞,收藏,谢谢!
来源地址:https://blog.csdn.net/qq_46096136/article/details/128780958