【spring】bean的生命周期

已于 2024-10-28 22:56:16 修改
阅读量377 收藏
点赞数
分类专栏： spring 面试 文章标签： spring 面试
于 2023-03-16 21:53:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32088869/article/details/129579845
版权

目录

一、说明

  • 1.bean的生命周期指的是bean从创建到销毁的整个过程。
  • 2.spring对bean进行实例化。
  • 3. spring将值和bean的引用注入到bean对应的属性中。
  • 4.如果bean实现了BeanNameAware接口，spring将bean的ID传递给setBean-Name()方法。
  • 5.如果bean实现了BeanFactoryAware接口，spirng将调用setBeanFactory()方法，将BeanFactory容器实例传入。
  • 6.如果bean实现了ApplicationContextAware接口，spring将调用setApplicationContext()方法，将bean所在的应用上下文的引用传入。
  • 7.如果bean实现了BeanPostProcessor接口，spring将调用其postProcessBeforeInitialization()方法。
  • 8.如果bean实现了InitializingBean接口，spring将调用其afterPropertiesSet()方法。如果bean使用init-method声明了初始化方法，则调用初始化方法。
  • 7.如果bean实现了BeanPostProcessor接口，spring将调用其postProcessAfterInitialization()方法。
  • 8.bean已经准备就绪，可以被程序使用，将一直在应用上下文中，直到应用上下文被销毁。
  • 9.如果bean实现了DisposableBean接口，spring将调用其destroy()接口方法。如果bean使用destroy-method声明了销毁方法，则调用销毁方法。

二、四步

  • 1.实例化。
  • 2. 属性赋值。
  • 3.初始化。
  • 4.销毁。
2.1 实例化
  • 1. 通过反射去推断构造函数进行实例化。
  • 2. 通过实例工厂、静态工厂实例化。
2.2 属性赋值
  • 1. 解析自动装配（byname、bytype、constructor、none、@autowired）。
  • 2. 循环依赖。
2.3 初始化
  • 1. 调用xxxAware回调方法（BeanNameAware、BeanClassLoaderAware、BeanFactoryAware）。
  • 2. 调用初始化生命周期回调（三种：@PostConstruct、实现InitiallizingBean接口、@Bean(initMethod = “initMethod”)）。
  • 3. 如果bean实现aop，创建动态代理。
2.4 销毁
  • 1. 在spring容器关闭的时候进行调用。
  • 2. 调用销毁生命周期回调（三种：@PreDestroy、实现DisposableBean接口、@Bean(initMethod = “destroyMethod”)）。

三、最全生命周期

3.1 代码示例
package com.learning.bean_life_cycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class MyBeanPostProcessor implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor {

	/**
	 * 实例化执行之前，这里返回的对象会替换掉原本的Bean
	 * @param beanClass the class of the bean to be instantiated
	 * @param beanName the name of the bean
	 * @return
	 * @throws BeansException
	 */
	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		if(beanName.equals("lifeCycleBean")){
			System.out.println("spring接口->org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation: 实例化执行之前，这里返回的对象会替换掉原本的Bean");
		}
		// 返回null的话保持原有bean不变
		return null;
	}

	/**
	 * 实例化之后执行，如果返回false会跳过依赖注入阶段
	 * @param bean the bean instance created, with properties not having been set yet
	 * @param beanName the name of the bean
	 * @return
	 * @throws BeansException
	 */
	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		if(beanName.equals("lifeCycleBean")){
			System.out.println("spring接口->org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation: 实例化之后执行，如果返回false会跳过依赖注入阶段");
		}
		return true;
	}

	@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
		if(beanName.equals("lifeCycleBean")){
			System.out.println("spring接口->org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor.postProcessProperties: 依赖注入阶段执行，如@Autowired、@Value、@Resource");
		}
		return pvs;
	}

	@Override
	public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
		if(beanName.equals("lifeCycleBean")){
			System.out.println("spring接口->org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor.postProcessBeforeDestruction: 销毁之前执行，如@PreDestroy");
		}
	}

	@Override
	public boolean requiresDestruction(Object bean) {
		return DestructionAwareBeanPostProcessor.super.requiresDestruction(bean);
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if (beanName.equals("lifeCycleBean")) {
			System.out.println("spring接口->org.springframework.beans.factory.config.BeanPostProcessor.postProcessBeforeInitialization: 初始化之前执行，这里返回的对象会替换掉原本的 bean，如 @PostConstruct、@ConfigurationProperties");
		}
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if (beanName.equals("lifeCycleBean")) {
			System.out.println("spring接口->org.springframework.beans.factory.config.BeanPostProcessor.postProcessAfterInitialization: 初始化之后执行，这里返回的对象会替换掉原本的 bean，如代理增强");
		}
		return bean;
	}
}


package com.learning.bean_life_cycle;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
//import org.springframework.stereotype.Component;

//@Component
public class LifeCycleBean implements InitializingBean, DisposableBean {
	public LifeCycleBean(){
		System.out.println("construction method: LifeCycleBean的构造方法进行实例化");
	}

	@Autowired
	public void autowire(@Value("${JAVA_HOME}") String home){
		System.out.println("spring注解->@org.springframework.beans.factory.annotation.Autowired: 依赖注入->" + home);
	}

	@PostConstruct
	public void init(){
		System.out.println("jdk注解->@javax.annotation.PostConstruct: 初始化方法调用");
	}

	// 单例bean调用销毁方法
	@PreDestroy
	public void destory(){
		System.out.println("jdk注解->@javax.annotation.PreDestroy: 销毁之前调用");
	}


	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("spring接口->org.springframework.beans.factory.InitializingBean: 初始化之后调用");
	}

	@Override
	public void destroy() throws Exception {
		System.out.println("spring接口->org.springframework.beans.factory.DisposableBean: 销毁之前调用");
	}


	private void initMehtod() {
		System.out.println("spring注解->org.springframework.context.annotation.Bean.initMethod: 初始化方法");
	}

	private void destroyMethod() {
		System.out.println("spring注解->org.springframework.context.annotation.Bean.destroyMethod: 销毁方法");
	}
}

package com.learning.bean_life_cycle;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration//作为配置类，代替xml文件
@ComponentScan(basePackages = {"com.learning.bean_life_cycle"})
public class SpringConfig {
	@Bean(initMethod = "initMehtod", destroyMethod = "destroyMethod")
	public LifeCycleBean lifeCycleBean(){
		return new LifeCycleBean();
	}
}

package com.learning.bean_life_cycle;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author wangyouhui
 * @Description 应用类
 **/
public class Application {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
		LifeCycleBean lifeCycleBean = annotationConfigApplicationContext.getBean(LifeCycleBean.class);
		// 关闭容器
		System.out.println("bean可以被使用"+lifeCycleBean);
		annotationConfigApplicationContext.close();
	}
}
3.2 执行结果
spring接口->org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation: 实例化执行之前，这里返回的对象会替换掉原本的Bean
construction method: LifeCycleBean的构造方法进行实例化
spring接口->org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation: 实例化之后执行，如果返回false会跳过依赖注入阶段
spring接口->org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor.postProcessProperties: 依赖注入阶段执行，如@Autowired、@Value、@Resource
spring注解->@org.springframework.beans.factory.annotation.Autowired: 依赖注入->C:\Program Files\Java\jdk1.8.0_251
spring接口->org.springframework.beans.factory.config.BeanPostProcessor.postProcessBeforeInitialization: 初始化之前执行，这里返回的对象会替换掉原本的 bean，如 @PostConstruct、@ConfigurationProperties
jdk注解->@javax.annotation.PostConstruct: 初始化方法调用
spring接口->org.springframework.beans.factory.InitializingBean: 初始化之后调用
spring注解->org.springframework.context.annotation.Bean.initMethod: 初始化方法
spring接口->org.springframework.beans.factory.config.BeanPostProcessor.postProcessAfterInitialization: 初始化之后执行，这里返回的对象会替换掉原本的 bean，如代理增强
bean可以被使用com.learning.bean_life_cycle.LifeCycleBean@26e356f0
spring接口->org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor.postProcessBeforeDestruction: 销毁之前执行，如@PreDestroy
jdk注解->@javax.annotation.PreDestroy: 销毁之前调用
spring接口->org.springframework.beans.factory.DisposableBean: 销毁之前调用
spring注解->org.springframework.context.annotation.Bean.destroyMethod: 销毁方法
王佑辉
关注
专栏目录
Spring Bean生命周期详解
weixin_45723046的博客
04-10 1万+
站在设计者的角度考虑设计IOC容器 加载Bean的配置（比如xml配置） 比如不同类型资源的加载，解析成生成统一Bean的定义 根据Bean的定义加载生成Bean的实例，并放置在Bean容器中 比如Bean的依赖注入，Bean的嵌套，Bean存放（缓存）等 除了基础Bean外，还有常规针对企业级业务的特别Bean 比如国际化Message，事件Event等生成特殊的类结构去支撑 对容器中的Bean提供统一的管理和调用 比如用工厂模式管理，提供方法根据名字/类的类型等从容器中获取Bea
SpringBean生命周期详解
weixin_43244698的博客
10-28 9627
SpringBean生命周期详解 一、简述： Spring是我们每天都在使用的框架，Bean是被Spring管理的Java对象，是Spring框架最重要的部分之一，那么让我们一起了解一下Spring中Bean的生命周期是怎样的吧 二、流程图 我们先从宏观的角度看一下Spring的生命周期： ![在这里插入图片描述](https://img-blog.csdnimg.cn/20201028174058916.png?x-oss-process=image/watermark,t ype_ZmFuZ3poZW5
Spring bean 的生命周期的详解
u013305082的专栏
10-28 664
Spring bean 的生命周期的详解 2012-04-17 13:12 4595人阅读 评论(1) 收藏 举报 beanspringjava Spring bean生命周期 在传统的Java应用中，Bean的生命周期非常简单。 Java的关键词new用来实例化Bean（或许他是非序列化的）。这样就够用了。 相反，Bean的生命周期在Spring容器中更加细致。
Spring bean生命周期
izhuhf的专栏
02-22 144
在传统的Java应用中，Bean的生命周期非常简单。 Java的关键词new用来实例化Bean（或许他是非序列化的）。这样就够用了。 相反，Bean的生命周期在Spring容器中更加细致。 理解Spring Bean的生命周期非常重要，因为你或许要利用Spring提供的机会来订制Bean的创建过程。 1.容器寻找Bean的定义信息并且将其实例化。 2.受用依赖注入，Spring按...
Spring之Bean的生命周期详解
热门推荐
波波烤鸭的博客
03-05 3万+
Spring生命周期的讲解
谈谈我对Spring Bean 生命周期的理解
08-27
Spring Bean 生命周期是 Spring 框架中的一个核心概念，了解 Spring Bean 的生命周期对我们了解整个 Spring 框架会有很大的帮助。本文将详细介绍 Spring Bean 生命周期的概念、生命周期图、生命周期阶段、生命周期...
spring bean的生命周期
01-16
- **XML配置**：在传统的Spring应用中，Bean的定义通常写在XML配置文件中，如`springbean-xml`中的配置。 - **注解配置**：使用`@Component`，`@Service`，`@Repository`和`@Controller`注解标记类，配合`@...
详解Spring bean的生命周期
秦城诗雨的博客
07-26 850
Spring bean的生命周期 Spring容器管理着bean的从创建到销毁的整个生命周期，其中经历了一个复杂的处理过程。 现在将整体过程分为3个大步骤：分别是实例化bean、初始化bean、销毁bean 实例化bean 1、Spring 启动的过程中实例化bean (1)Spring的ApplicationContext初始化的时候，会初始化beanfactory。在beanfactory初始化时，会更据xml配置或者注解将bean的关键定义以<String, BeanDef.
详解Spring Bean的生命周期
Mr_VK的博客
08-03 1662
对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于ApplicationContext容器，当容器启动结束后，便实例化所有的bean。容器通过获取BeanDefinition对象中的信息进行实例化。并且这一步仅仅是简单的实例化，并未进行依赖注入。实例化对象被包装在BeanWrapper对象中，BeanWrapper提供了设置对象属性的接口，从而避免了使用反射机制设置属性。
spring bean的生命周期详解
qq_41571395的博客
05-06 1902
文章目录序言流程图**具体过程**1.创建BeanFactory2.扫描3.合并BeanDefinition4.加载类5.实例化前6. 实例化7. BeanDefinition的后置处理8. 实例化后9. 填充填充10. 执行Aware11. 初始化前12. 初始化13. 初始化后14.bean销毁 序言 Spring最重要的功能就是帮助程序员创建对象（也就是IOC），而启动Spring就是为创建Bean对象 做准备，所以我们先明白Spring到底是怎么去创建Bean的，也就是先弄明白Bean的生命周期。
Spring Bean 生命周期详解
最新发布
常备不懈
06-22 1615
在 Spring 框架中，Bean 的生命周期由 Spring 容器全权管理。了解和掌握 Bean 的生命周期对于使用 Spring 开发稳定且高效的应用程序至关重要。本文将详细介绍 Spring Bean 生命周期的五个主要阶段：实例化、属性注入、初始化、使用和销毁，并涵盖各个阶段的关键步骤和扩展点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王佑辉

老板，赏点吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值