【好文转发】Spring注解开发_Bean生命周期及执行过程

最新推荐文章于 2023-09-26 12:53:11 发布
最新推荐文章于 2023-09-26 12:53:11 发布
阅读量313 收藏
点赞数
文章标签： java
原文链接：https://www.cnblogs.com/wei-ran/p/16207148.html
版权

Bean生命周期

了解Bean的生命周期，就可以在Bean声明周期的不同阶段进行自定义的操作，满足更复杂的需求。简单的将Bean生命周期分为三个阶段：Bean创建、初始化、销毁

  • 对象创建：单实例在容器启动的时候创建对象，多实例在每次获取的时候创建对象
    • 初始化之前：BeanPostProcessor.postProcessBeforeInitialization()
  • 初始化：对象创建完成，并赋值好，调用初始化方法
    • 初始化之后：BeanPostProcessor.postProcessAfterInitialization()
  • [容器创建完成]
  • 销毁：单实例在容器关闭的时候销毁，多实例容器不会管理这个bean，容器不会调用销毁方法

现在可以通过下面方法在初始化和销毁时自定义初始化方法来干涉Bean创建过程。

  1. @Bean()注解参数
  2. InitializingBean、DisposableBean接口
  3. @PostConstruct、@PreDestroy注解
  4. BeanPostProcessor接口

1.@Bean生命周期

通过@Bean指定init-method和destroy-method的初始化方法

  • 先自定义Bean初始化和销毁方法

    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#bbb529">@Component</span>
<span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">Car</span> {
	
	<span style="color:#cc7832">public</span> <span style="color:#ffc66d">Car</span>(){
		System.out.println(<span style="color:#6a8759">"car constructor..."</span>);
	}
	<span style="color:grey">//现在只是普通方法</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">init</span>(){
		System.out.println(<span style="color:#6a8759">"car ... init..."</span>);
	}
	<span style="color:grey">//现在只是普通方法</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">detory</span>(){
		System.out.println(<span style="color:#6a8759">"car ... destory..."</span>);
	}

}</span></span>

  • 配置进容器

    • 通过@Bean注解，在@Bean注册进容器时指定自定义方法
    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#bbb529">@Configuration</span>
<span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">MainConfigOfLifeCycle</span> {
	
	<span style="color:grey">//@Scope("prototype")多实例，不管销毁</span>
	<span style="color:grey">//指定用于初始化和销毁的方法</span>
	<span style="color:#bbb529">@Bean(initMethod="init",destroyMethod="destory")</span>
	<span style="color:#cc7832">public</span> Car <span style="color:#ffc66d">car</span>(){
		<span style="color:#cc7832">return</span> <span style="color:#cc7832">new</span> Car();
	}

}</span></span>

  • 测试

    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">IOCTest_LifeCycle</span> {
	
	<span style="color:#bbb529">@Test</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">test01</span>(){
		<span style="color:grey">//1、创建ioc容器</span>
		AnnotationConfigApplicationContext applicationContext = <span style="color:#cc7832">new</span> AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
		System.out.println(<span style="color:#6a8759">"容器创建完成..."</span>);
		
		<span style="color:grey">//applicationContext.getBean("car");</span>
		<span style="color:grey">//关闭容器</span>
		applicationContext.close();
	}

}</span></span>

    输出

    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:grey">//先创建对象</span>
car constructor...
<span style="color:grey">//再自定义初始化方法</span>
car ... init...
<span style="color:grey">//创建完成</span>
容器创建完成...
<span style="color:grey">//关闭时自定义销毁方法</span>
car ... destory...</span></span>

2.InitializingBean，DisposableBean生命周期

接口，需实现，通过让Bean实现InitializingBean（定义初始化逻辑），DisposableBean（定义销毁逻辑）;

  • 实现接口，自定义初始化Bean

    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">Cat</span> <span style="color:#cc7832">implements</span> <span style="color:#ffc66d">InitializingBean</span>,<span style="color:#ffc66d">DisposableBean</span> {
	
	<span style="color:#cc7832">public</span> <span style="color:#ffc66d">Cat</span>(){
		System.out.println(<span style="color:#6a8759">"cat constructor..."</span>);
	}

	<span style="color:grey">//定义销毁逻辑</span>
	<span style="color:#bbb529">@Override</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">destroy</span>() <span style="color:#cc7832">throws</span> Exception {
		<span style="color:grey">// TODO Auto-generated method stub</span>
		System.out.println(<span style="color:#6a8759">"cat...destroy..."</span>);
	}

	<span style="color:grey">//定义初始化逻辑</span>
	<span style="color:#bbb529">@Override</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">afterPropertiesSet</span>() <span style="color:#cc7832">throws</span> Exception {
		<span style="color:grey">// TODO Auto-generated method stub</span>
		System.out.println(<span style="color:#6a8759">"cat...afterPropertiesSet..."</span>);
	}

}</span></span>

  • 配置进容器

    • 在@Configuration配置类中使用@Bean
    • 或在Bean类上使用@Component然后再配置类上使用@ComponentScan
    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:grey">//配置组件</span>
<span style="color:#bbb529">@Component</span>
<span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">Cat</span> <span style="color:#cc7832">implements</span> <span style="color:#ffc66d">InitializingBean</span>,<span style="color:#ffc66d">DisposableBean</span> {
	<span style="color:grey">//...</span>
}</span></span>
    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:grey">//扫描进容器</span>
<span style="color:#bbb529">@ComponentScan("com.xxx.bean")</span>
<span style="color:#bbb529">@Configuration</span>
<span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">MainConfigOfLifeCycle</span> {
	<span style="color:grey">//...</span>
}</span></span>

  • 测试

    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">IOCTest_LifeCycle</span> {
	
	<span style="color:#bbb529">@Test</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">test01</span>(){
		<span style="color:grey">//1、创建ioc容器</span>
		AnnotationConfigApplicationContext applicationContext = <span style="color:#cc7832">new</span> AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
		System.out.println(<span style="color:#6a8759">"容器创建完成..."</span>);
		
		<span style="color:grey">//applicationContext.getBean("car");</span>
		<span style="color:grey">//关闭容器</span>
		applicationContext.close();
	}
}</span></span>

    输出

    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:grey">//注意顺序，每个Bean先构造并初始化，然后才进行下一个Bean，关闭时从内向外</span>
（猫）cat constructor...
（猫）cat...afterPropertiesSet...
（车）car constructor...
（车）car ... init...
<span style="color:grey">//创建完成</span>
 容器创建完成...
<span style="color:grey">//关闭时销毁</span>
（车）car ... destory...
（猫）cat...destroy...</span></span>

3.@PostConstruct生命周期

可以使用JSR250；

  • @PostConstruct：在bean创建完成并且属性赋值完成之后，来执行初始化方法

  • @PreDestroy：在容器销毁bean之前通知我们进行清理工作

  • 标注注解，自定义初始化Bean

    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">Dog</span> {

	<span style="color:#cc7832">public</span> <span style="color:#ffc66d">Dog</span>(){
		System.out.println(<span style="color:#6a8759">"dog constructor..."</span>);
	}
	
	<span style="color:grey">//对象创建并赋值之后调用</span>
	<span style="color:#bbb529">@PostConstruct</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">init</span>(){
		System.out.println(<span style="color:#6a8759">"Dog....@PostConstruct..."</span>);
	}
	
	<span style="color:grey">//容器移除对象之前</span>
	<span style="color:#bbb529">@PreDestroy</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">detory</span>(){
		System.out.println(<span style="color:#6a8759">"Dog....@PreDestroy..."</span>);
	}
}</span></span>

  • 配置进容器

    • 在@Configuration配置类中使用@Bean
    • 或在Bean类上使用@Component然后再配置类上使用@ComponentScan
    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#bbb529">@Component</span>
<span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">Dog</span> {
	<span style="color:grey">//...</span>
}</span></span>
    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:grey">//扫描进容器</span>
<span style="color:#bbb529">@ComponentScan("com.xxx.bean")</span>
<span style="color:#bbb529">@Configuration</span>
<span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">MainConfigOfLifeCycle</span> {
	<span style="color:grey">//...</span>
}</span></span>

  • 测试

    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">IOCTest_LifeCycle</span> {
	
	<span style="color:#bbb529">@Test</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">test01</span>(){
		<span style="color:grey">//1、创建ioc容器</span>
		AnnotationConfigApplicationContext applicationContext = <span style="color:#cc7832">new</span> AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
		System.out.println(<span style="color:#6a8759">"容器创建完成..."</span>);
		
		<span style="color:grey">//applicationContext.getBean("car");</span>
		<span style="color:grey">//关闭容器</span>
		applicationContext.close();
	}

}</span></span>

    输出

    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:grey">//注意顺序，每个Bean先构造并初始化，然后才进行下一个Bean，关闭时从内向外</span>
（猫）cat constructor...
（猫）cat...afterPropertiesSet...
（狗）dog constructor...
（狗）Dog....<span style="color:#bbb529">@PostConstruct</span>...
（车）car constructor...
（车）car ... init...
<span style="color:grey">//创建完成</span>
容器创建完成...
<span style="color:grey">//关闭时销毁</span>
（车）car ... destory...
（狗）Dog....<span style="color:#bbb529">@PreDestroy</span>...
（猫）cat...destroy...</span></span>

4.BeanPostProcessor

postProcessBeforeInitialization：在创建Bean实例之后，在自定义初始化之前进行调用

postProcessAfterInitialization：在自定义初始化之后进行调用

BeanPostProcessor接口：bean的后置处理器，需实现，在bean初始化前后进行一些处理工作

  • postProcessBeforeInitialization：在（自定义初始化，如InitializingBean[afterPropertiesSet]、init-method等，就是上面那些自定义初始化方法）初始化之前工作（创建Bean实例之后，在自定义初始化之前）

  • postProcessAfterInitialization：在（自定义）初始化之后工作

  • 实现后置处理器接口

    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">MyBeanPostProcessor</span> <span style="color:#cc7832">implements</span> <span style="color:#ffc66d">BeanPostProcessor</span> {

	<span style="color:grey">//初始化前置方法</span>
	<span style="color:grey">//bean：新创建的实例，还未初始化</span>
	<span style="color:grey">//beanName：未初始化的Bean名字</span>
	<span style="color:#bbb529">@Override</span>
	<span style="color:#cc7832">public</span> Object <span style="color:#ffc66d">postProcessBeforeInitialization</span>(Object bean, String beanName) <span style="color:#cc7832">throws</span> BeansException {
		<span style="color:grey">// TODO Auto-generated method stub</span>
		System.out.println(<span style="color:#6a8759">"postProcessBeforeInitialization..."</span>+beanName+<span style="color:#6a8759">"=>"</span>+bean);
		<span style="color:#cc7832">return</span> bean;
	}
	<span style="color:grey">//初始化后置方法</span>
	<span style="color:#bbb529">@Override</span>
	<span style="color:#cc7832">public</span> Object <span style="color:#ffc66d">postProcessAfterInitialization</span>(Object bean, String beanName) <span style="color:#cc7832">throws</span> BeansException {
		<span style="color:grey">// TODO Auto-generated method stub</span>
		System.out.println(<span style="color:#6a8759">"postProcessAfterInitialization..."</span>+beanName+<span style="color:#6a8759">"=>"</span>+bean);
		<span style="color:#cc7832">return</span> bean;
	}
    
}</span></span>

  • 配置进容器

    • 在@Configuration配置类中使用@Bean
    • 或在Bean类上使用@Component然后再配置类上使用@ComponentScan
    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#bbb529">@Component</span>
<span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">MyBeanPostProcessor</span> <span style="color:#cc7832">implements</span> <span style="color:#ffc66d">BeanPostProcessor</span> {

    <span style="color:grey">//...</span>
}</span></span>
    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:grey">//扫描进容器</span>
<span style="color:#bbb529">@ComponentScan("com.xxx.bean")</span>
<span style="color:#bbb529">@Configuration</span>
<span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">MainConfigOfLifeCycle</span> {
	<span style="color:grey">//...</span>
}</span></span>

  • 测试

    • 这次没有新增的Bean，只配置了一个后置处理器，
    • 这个后置处理器会对容器中的Bean起作用，包括上面三种自定义初始化Bean
    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">IOCTest_LifeCycle</span> {
	
	<span style="color:#bbb529">@Test</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">test01</span>(){
		<span style="color:grey">//1、创建ioc容器</span>
		AnnotationConfigApplicationContext applicationContext = <span style="color:#cc7832">new</span> AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
		System.out.println(<span style="color:#6a8759">"容器创建完成..."</span>);
		
		<span style="color:grey">//applicationContext.getBean("car");</span>
		<span style="color:grey">//关闭容器</span>
		applicationContext.close();
	}

}</span></span>

    输出

    java 
    <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:grey">//对于每一个Bean都要执行一遍</span>
<span style="color:grey">//1.创建</span>
<span style="color:grey">//2.BeanPostProcessor.postProcessBeforeInitialization()</span>
<span style="color:grey">//3.初始化：对象创建完成，并赋值好，调用初始化方法...</span>
<span style="color:grey">//4.BeanPostProcessor.postProcessAfterInitialization()</span>
<span style="color:grey">//5.销毁</span>


<span style="color:grey">//以其中一个Bean为例：</span>
<span style="color:grey">//构造对象</span>
cat constructor...
<span style="color:grey">//初始化之前</span>
postProcessBeforeInitialization...cat=>com.xxx.bean.Cat@7d68ef40
<span style="color:grey">//使用InitializingBean自定义初始化逻辑</span>
cat...afterPropertiesSet...
<span style="color:grey">//初始化之后</span>
postProcessAfterInitialization...cat=>com.xxx.bean.Cat@7d68ef40
<span style="color:grey">//创建完成</span>
容器创建完成...
<span style="color:grey">//关闭时销毁</span>
cat ... destroy...</span></span>

⭐BeanPostProcessor原理

bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async，xxxBeanPostProcessor都通过BeanPostProcessor实现

详细视频 尚硅谷Spring注解驱动教程(雷丰阳源码级讲解)_哔哩哔哩_bilibili

主要方法

java 
<span style="background-color:#282b2e"><span style="color:#a9b7c6">populateBean(beanName, mbd, instanceWrapper)：给bean进行属性赋值
initializeBean：初始化Bean
{
    applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);初始化前应用后置处理器
    invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
    applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);初始化后应用后置处理器
}
遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
一但返回<span style="color:#cc7832">null</span>，跳出<span style="color:#cc7832">for</span>循环</span></span>

执行过程

了解BeanPostProcessor的执行过程，从AnnotationConfigApplicationContext开始Debug

java 
<span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">IOCTest_LifeCycle</span> {
	
	<span style="color:#bbb529">@Test</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">test01</span>(){
		<span style="color:grey">//1、创建ioc容器</span>
		AnnotationConfigApplicationContext applicationContext = <span style="color:#cc7832">new</span> AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
		System.out.println(<span style="color:#6a8759">"容器创建完成..."</span>);
		
		<span style="color:grey">//applicationContext.getBean("car");</span>
		<span style="color:grey">//关闭容器</span>
		applicationContext.close();
	}
}</span></span>
  1. 先从创建ioc容器开始，进入AnnotationConfigApplicationContext()构造方法，执行里面的refresh()方法刷新容器
    1. refresh()方法里面有一个finishBeanFactoryInitialization(beanFactory)初始化所有剩余的单实例对象，进入这个方法
  2. 这个方法最后一步有一个beanFactory.preInstantiateSingletons()初始化所有单实例Bean，进入这个方法
    1. 触发所有非惰性单例bean的初始化
    2. 里面调用getBean(beanName)，
    3. 进入getBean(beanName)里面再调用doGetBean(name,null,null,false)
    4. 进入doGetBean(name,null,null,false)里面有getSingleton(beanName,new ObjectFactory(){singletonFactory.getObject()})通过匿名内部类调用getObject()
  3. 此时通过匿名类getObject()进入下一个调用栈AbstractBeanFactory$1.getObject()，如果是单例，调用createBean(beanName,mbd,args)
  4. 进入createBean(beanName,mbd,args)调用doCreateBean(beanName,mbd,args)创建一个实例，过程如下
    1. 进入doCreateBean(beanName,mbd,args)，里面调用一个initializeBean(beanName,exposedObject,mbd)初始化方法，这个方法里面就是调用的后置处理器
    2. 在这个方法上面有populateBean(beanName，mbd,instanceWrapper)方法，这个方法为Bean属性赋值
    3. 进入initializeBean(beanName,exposedObject,mbd)，下面有一个invokeInitMethods(beanName,wrappedBean,mbd)执行初始化方法（就是上面的自定义初始化InitializingBean[afterPropertiesSet]、init-method）
    4. 在invokeInitMethods(beanName,wrappedBean,mbd)[在初始化之前应用 BeanPost 处理器]上面有一个applyBeanPostProcessorsBeforeInitialization(wrappedBean,beanName)下面有一个applyBeanPostProcessorsAfterInitialization(wrappedBean,beanName)[在初始化之后应用 BeanPost 处理器]，作用是在初始化之前应用所有的BeanPostProcessors在初始化之后应用所有的BeanPostProcessors
  5. 进入applyBeanPostProcessorsBeforeInitialization(wrappedBean,beanName)
    1. 里面有getBeanPostProcessors()找到所有BeanPostProcessors遍历，包括Spring系统的BeanPostProcessor如ApplicationContextAwareProcessor、ConfigurationClassPostProcessor等，然后才是自定义的MyBeanPostProcessor，依次执行beanProcessor.postProcessBeforeInitialization()
    2. 如果有执行返回null，就结束遍历，返回null，后面的处理器就不执行了（不应用后续的BeanPostProcessors了）

调用栈

  • 获取单例

  • 创建实例Bean

  • 给Bean属性赋值和初始化Bean

完整流程

Spring底层对 BeanPostProcessor 的使用；

  1. 由上图可以看到，Spring中的BeanPostProcessor在实例化过程处于的位置，BeanPostProcessor接口有两个方法需要实现：postProcessBeforeInitialization和postProcessAfterInitialization
  2. 前者在实例化及依赖注入完成后、在任何初始化代码（比如配置文件中的init-method）调用之前调用；后者在初始化代码调用之后调用。

⭐BeanPostProcessor在Spring底层的使用

许多注解底层都是基于BeanPostProcessor

BeanPostProcessor接口实现类

向组件中注入IoC容器

在Bean创建过程中，初始化之前，判断是否实现了某Aware接口，如果实现了，就向Bean中注入ApplicationContext容器

  • 向Bean中注入IoC容器

    • 实现ApplicationContextAware接口，声明属性，赋值，就可以在组件中使用Ioc容器

      java 
      <span style="background-color:#282b2e"><span style="color:#a9b7c6"><span style="color:#bbb529">@Component</span>
<span style="color:#cc7832">public</span> <span style="color:#cc7832">class</span> <span style="color:#ffc66d">Dog</span> <span style="color:#cc7832">implements</span> <span style="color:#ffc66d">ApplicationContextAware</span> {
	
	<span style="color:grey">//声明IoC容器</span>
	<span style="color:#cc7832">private</span> ApplicationContext applicationContext;
	
	<span style="color:#cc7832">public</span> <span style="color:#ffc66d">Dog</span>(){
		System.out.println(<span style="color:#6a8759">"dog constructor..."</span>);
	}
	
	<span style="color:grey">//对象创建并赋值之后调用</span>
	<span style="color:#bbb529">@PostConstruct</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">init</span>(){
		System.out.println(<span style="color:#6a8759">"Dog....@PostConstruct..."</span>);
	}
	
	<span style="color:grey">//容器移除对象之前</span>
	<span style="color:#bbb529">@PreDestroy</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">detory</span>(){
		System.out.println(<span style="color:#6a8759">"Dog....@PreDestroy..."</span>);
	}

	<span style="color:grey">//把applicationContext IoC容器赋值给属性</span>
	<span style="color:#bbb529">@Override</span>
	<span style="color:#cc7832">public</span> <span style="color:#cc7832">void</span> <span style="color:#ffc66d">setApplicationContext</span>(ApplicationContext applicationContext) <span style="color:#cc7832">throws</span> BeansException {
		<span style="color:grey">// TODO Auto-generated method stub</span>
		<span style="color:#cc7832">this</span>.applicationContext = applicationContext;
	}
}</span></span>

  • 原理是通过ApplicationContextAwareProcessor实现

    • ApplicationContextAwareProcessor实现了BeanPostProcessor接口

    • 在postProcessBeforeInitialization()方法中

      1. 在Bean初始化之前，判断Bean是否实现了ApplicationContextAware接口，或其他Aware接口
      2. 如果实现了，就调用invokeAwareInterfaces(bean)给Bean注入值
      3. 判断Bean是什么类型Aware，将Bean转成对应类型调用((ApplicationContextAware)bean).setApplicationContext(this.applicationContext)注入IoC容器
      4. 于是就到了上面实现的接口的未实现方法中

数据校验

  • BeanValidationPostProcessor也实现了BeanPostProcessor接口
  • 在Bean创建完赋值后，同样调用postProcessBeforeInitialization()方法，进行数据校验
    • postProcessBeforeInitialization(){doValidate(bean)}
    • postProcessAfterInitialization(){doValidate(bean)}

自定义初始化注解

  • Bean初始化有一种方法是使用@PostConstruct注解，也是通过BeanPostProcessor实现
  • InitDestroyAnnotationBeanPostProcessor处理@PostConstruct和@PreDestroy注解
    • 在postProcessBeforeInitialization()中找到Bean的生命周期注解所标注的方法，如initMethods、destroyMethods
    • 找到之后就执行注解标注的初始化方法metatata.invokeInitMethods(bean,beanName)和element.invoke(target)，利用反射执行。

自动注入注解@Autowired

  • 为什么@Autowired能够自动注入值，是通过这个AutowiredAnnotationBeanPostProcessor实现BeanPostProcessors接口
  • 在对象创建完之后，处理标注@Autowired标注的所有属性进行注入值

转自：浅尝Spring注解开发_Bean生命周期及执行过程 - 蔚然丶丶 - 博客园

DIY_lOVER
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
浅尝Spring注解开发_Bean生命周期及执行过程.doc
07-08
ingBean 和 DisposableBean 接口 当不使用注解而是通过实现接口的方式来控制 Bean 的生命周期时，可以实现 ...了解并熟练掌握 Bean 生命周期及其控制方法，对于开发高效、健壮的 Spring 应用程序至关重要。
一文带你深入理解SpringBean生命周期之PostConstruct、PreDestroy详解
Moonxiyue的博客
06-20 1177
想必大家在项目中都用过这个注解把，知道它会在应用启动的时候执行被这个注解标注的方法。其实它还有另外一个注解，实在Bean销毁前执行，它们都是Bean生命周期的一环，那他们具体在什么阶段执行呢？我们从源码的角度带大家分析下。和是规范中定义的类两个类，表示Bean初始化后和销毁前指定的注解，位于包下，而不是spring jar中的类。JSR-250, Java Specification Requests的缩写，意思是Java 规范提案。它是Java界共同制定的一个重要标准。它定义了一组通用的注解，比如@Pos
Spring生命周期注解之@PostConstruct，@PreDestroy
luojinbai的专栏
01-17 4277
目录 1. 注解说明 2. 调用过程 3. 调用分析 1. 注解说明 @PostConstruct，@PreDestroy是Java规范JSR-250引入的注解，定义了对象的创建和销毁工作，同一期规范中还有注解@Resource，Spring也支持了这些注解； 在Spring中，@PostConstruct，@PreDestroy注解的解析是通过BeanPostProcessor实现的...
spring Bean的生命周期 @PostConstruct和@PreDestroy以及InitializingBean，DisposableBean
鸭鸭的博客
05-12 2913
bean的生命周期：bean创建---初始化----销毁的过程； 在spring容器中，我们在注入bena的时候，可以指定bean的初始化方法和销毁方法，bean在容器的创建过程中，有三种形式，可以指定初始化和销毁方法 1：通过@Bean指定init-method和destroy-method；相当于xml配置中的 <bean id ="car" class="com.badger....
关于Spring Bean的生命周期中几个常用方法（@PostConstruct、@PreDestroy 等）的执行顺序
小单的博客专栏
08-10 2585
按如下顺序执行： 1、初始化顺序 构造方法() BeanPostProcessor.postProcessBeforeInitialization() @PostConstruct InitialingBean.afterPropertiesSet() BeanPostProcessor.postProcessAfterInitialization() 2、关闭服务容器后 @PreDestroy DisposableBean.destroy() （END） ...
Java开发之@PostConstruct和@PreConstruct注解
weixin_30732825的博客
03-01 215
从Java EE5规范开始，Servlet增加了两个影响Servlet生命周期的注解（Annotation）：@PostConstruct和@PreConstruct。这两个注解被用来修饰一个非静态的void()方法.而且这个方法不能有抛出异常声明。 使用方式，例如： //方式1 @PostConstruct public void someMethod(){ ...
Spring bean生命周期配置过程解析
08-24
在Spring框架中，Bean的生命周期管理是其核心功能之一，它允许开发者控制Bean从创建到销毁的整个过程。本文将详细解析Spring Bean的生命周期配置过程。 首先，Bean的生命周期始于实例化。当Spring容器...
Spring学习笔记之bean生命周期
08-28
《Spring学习笔记之bean生命周期》 在Spring框架中，Bean是核心组件，它们构成了应用程序的主要结构。理解Spring Bean的生命周期对于有效地管理和优化Spring应用程序至关重要。本文将深入探讨Spring Bean的生命周期...
spring bean的生命周期
01-16
Spring Bean的生命周期是Spring框架中的核心概念，它涵盖了Bean从创建到销毁的全过程。了解这一过程对于优化应用程序的性能和管理资源至关重要。在Spring中，Bean的生命周期主要分为以下几个阶段： 1. **初始化阶段...
Spring Bean的生命周期详细介绍
09-01
下面以一个简单的Person类为例，展示Spring Bean生命周期的各个阶段： ```java public class Person implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean { // 省略属性和构造器 @...
spring @PostConstruct以及循环依赖的bean
weixin_45594127的博客
12-09 1641
@PostConstruct /** * The <code>PostConstruct</code> annotation is used on a method that * needs to be executed after dependency injection is done to perform * any initialization. This method must be invoked before the class * is put int
spring中bean的生命周期，及生命周期中的作用 和 作用域(单例 多例)
进化的深山猿
11-23 9237
最近在看spring源码，所以总结下spring的生命周期和各个阶段的作用。 spring的生命周期概括起来主要如下： 实例化 属性注入 ioc注入 实现了BeanNameAware 则执行setBeanName方法 实现了BeanFactoryAware 则执行 setBeanFactory方法，p125 实现了ApplicationContextAware 执行setApplic...
spring @Postconstruct执行时机
csdn问鼎
03-14 4120
文章目录背景AbstractAutowireCapableBeanFactoryInitDestroyAnnotationBeanPostProcessor总结 背景 @Postconstruct 主要是用来初始化函数注解 AbstractAutowireCapableBeanFactory 这里有一个beanpostprocessor @Override public Object applyBeanPostProcessorsBeforeInitialization(Object existingBe
Spring执行流程&Bean生命周期
moteandsunlight的博客
05-09 578
PostConstruct 注释用于在依赖关系注入完成之后需要执行的方法上，以执行任何初始化。如果当前类使用的Bean还没有，任务停止，开始去做那个Bean的实例和初始化。其中前置方法和后置方法用的是比较少的，但是初始化方法用的是比较多的。因为可能在调用方法的时候可能用到依赖的对象，必须要先进行属性注入。说明：这里只是说的大概流程，不是严格按照源码上一步一步说的。实例化：在堆上开辟内存，将非静态的变量和方法放到里边。因为现在使用注解比较多，相应的注解的优先级也更高。在此过程中，会完成Bean的注入和装配。
Bean（Spring）的执行流程和生命周期
GoodManS的CSDN
02-13 2493
Spring 和 Bean 的重点，也是常见的面试问答
Spring中Bean的生命周期(包含Spring执行流程)
热门推荐
哒哒的博客
02-10 1万+
Spring中Bean的生命周期(包含Spring执行流程)
Spring bean 基本流程
shonging的博客
09-21 58
将BeanDefinition存储到一个名为BeanDefinitionMap的Map<String,BeanDefinition>中。加载XML配置文件，解析获取配置文件中的每一个<bean>信息（Reader），封装成一个个BeanDefinition对象。创建好的Bean实例对象，会被储存到一个名为singletonObjects的Map<String，Object>中。ApplicationContext底层遍历beanDefinitionMap，创建Bean实例对象。Bean实例化的基本流程。
Spring执行流程及Bean的作用域与生命周期
最新发布
only_strive的博客
09-26 85
1.在启动类中遇到 ApplicationContext对象会启动Spring容器2.找到Spring容器设置的配置文件3.如果设置了base-package，就会循环base-package中所有的类，看是否加了五大类注解4.如果加了五大类注解，那么就进行初始化和属性依赖的赋值。
Spring Bean 生命周期的执行流程
qq_43276879的博客
08-08 460
Spring 生命周期全过程大致分为五个阶段：1、创建前准备阶段2、创建实例阶段3、依赖注入阶段4、 容器缓存阶段5、销毁实例阶段。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值