Spring中Bean的生命周期及源码详解

于 2024-08-06 12:09:40 发布
阅读量1k 收藏 30
点赞数 24
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ludkjava/article/details/140936035
版权

Spring Bean 实例化步骤

  • 推断构造方法
  • 通过构造方法创建对象
  • 填充属性，即依赖注入
  • 处理ApplicationContextAware接口的回调，即处理ApplicationContextAware接口的setApplicationContext方法
  • 初始化前，即处理@PostConstruct注解的方法
  • 初始化，即处理InitializingBean接口的afterPropertiesSet方法
  • 初始化后，AOP。

代码验证

BeanInitTest实现了ApplicationContextAware、InitializingBean 接口，且用 @PostConstruct注解声明了初始化前方法，声明了一个切面AopAspectTest，使得BeanInitTest是AOP代理对象。

如果在afterPropertiesSet、setApplicationContext、beforeInit方法上打断点，调试启动，会发现依次顺序进入setApplicationContext、beforeInit、afterPropertiesSet方法。

@Service
public class BeanInitTest implements ApplicationContextAware, InitializingBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("初始化");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("ApplicationContextAware 回调方法");
    }
    @PostConstruct
    private void beforeInit(){
        System.out.println("初始化前");
    }
}

@Component
@Aspect
public class AopAspectTest {
    @Pointcut(" execution (* com.ludk.weixin.service.BeanInitTest.*(..))")
    public void pointCut(){}

    @Before("pointCut()")
    public void cutBefore(){
        System.out.println("切面方法前");
    }

}

代码调试验证

断点选择

在如图所示处打断点，并加上条件beanName.equals(“beanInitTest”)，只观察该bean对象实例化，然后调试启动SpringBoot项目在这里插入图片描述

调试观察

进入断点后，如下图所示，左下角是代码调用的堆栈信息，可以看到代码的来源，beanName确实是想监控的bean名称beanInitTest
在这里插入图片描述

创建bean的代码分析并验证

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		//创建Bean的时候，会将Bean包装成一个BeanWrapper
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			//创建Bean实例，里面包含推断构造方法，并根据构造方法利用反射实例化Bean对象
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			//将对象工厂放入到Spring的三级缓存中
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			//填充属性，也就是依赖注入
			populateBean(beanName, mbd, instanceWrapper);
			//这里会处理ApplicationContextAware接口的回调、执行初始化前（@PostConstruct注解标注的方法）、初始化（InitializingBean接口方法）、初始化后的操作(AOP代理对象生成)
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}

		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name '" + beanName + "' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

对象创建

doCreateBean的方法中对象创建的代码如下：

if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)方法参数

  • String beanName：bean名称
  • RootBeanDefinition mbd：bean的定义
  • @Nullable Object[] args：构造方法的参数

根据上面的三个参数推断出构造方法，利用java反射创建对象，相当于new了一个对象。

依赖注入

doCreateBean方法中依赖注入的代码如下：

populateBean(beanName, mbd, instanceWrapper);

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw)方法参数

  • String beanName：bean名称
  • RootBeanDefinition mbd：bean的定义
  • @Nullable BeanWrapper bw：bean实例的包装类

依赖注入就是属性填充。上一步只是实例化了对象，对象中属性是null需要调用populateBean方法填充属性。

处理回调、初始化前、初始化、初始化后

doCreateBean方法中Bean初始化前、初始化、初始化后的代码如下：

exposedObject = initializeBean(beanName, exposedObject, mbd);

三个方法均打上断点，监控方法的调用链
在这里插入图片描述
方法依次进入ApplicationContextAware接口的setApplicationContext方法、InitializingBean接口的afterPropertiesSet方法、@PostConstruct注解注释的beforeInit方法，进入断点后同时观察左下角的方法调用链，分析代码。
在这里插入图片描述
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)是初始化bean的方法，里面主要包含初始化前、初始化、初始化后三个步骤。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			//处理Aware接口的回调，其中包括ApplicationContextAware接口的setApplicationContext方法的执行
			//初始化前
			//都是用BeanProcess的前置处理方法实现的
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			//初始化 ，InitializingBean接口的afterPropertiesSet方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			//初始化后，包括AOP
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

处理Aware回调

wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

getBeanPostProcessors()获取Bean处理器时，有个
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

@Override
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			//通过Bean的处理器，调用前置方法实现
			Object current = processor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

BeanPostProcessor 是Bean的处理器，是、在容器初始化时对 bean 的创建过程进行扩展和自定义的接口。getBeanPostProcessors()方法获取各种Bean处理器，遍历调用前置方法，执行Bean初始化前的操作。

调试代码中是通过ApplicationContextAwareProcessor处理器，调用postProcessBeforeInitialization前置方法，就会执行到Bean对象ApplicationContextAware接口的setApplicationContext方法。

初始化前

wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

getBeanPostProcessors()获取Bean处理器时，有个CommonAnnotationBeanPostProcessor处理器，该处理器继承了InitDestroyAnnotationBeanPostProcessor处理器。

CommonAnnotationBeanPostProcessor的postProcessBeforeInstantiation实现是空的，因此执行父类InitDestroyAnnotationBeanPostProcessor的postProcessBeforeInitialization方法，最终执行到@PostConstruct注解标注的方法。调用链路如下：
在这里插入图片描述

初始化

invokeInitMethods(beanName, wrappedBean, mbd);

通过下面的代码调用
在这里插入图片描述
调用链路如下：
在这里插入图片描述

初始化后

wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

getBeanPostProcessors()获取Bean处理器时，有个AnnotationAwareAspectJAutoProxyCreator处理器，它及它的父类均没有实现postProcessAfterInitialization方法，最后只能执行org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization

@Override
	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
		if (bean != null) {
			Object cacheKey = getCacheKey(bean.getClass(), beanName);
			if (this.earlyProxyReferences.remove(cacheKey) != bean) {
				//这里生成了AOP的代理对象
				return wrapIfNecessary(bean, beanName, cacheKey);
			}
		}
		return bean;
	}

调用链路如下：
在这里插入图片描述

需要注意的是，如果是循环依赖的情况，是根据三级缓存中的对象工厂，创建AOP代理对象的。

ludkjava
关注
Spring Bean生命周期源码详解
qq_44027353的博客
04-23 1619
之后child需要根据BeanDefinition来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition，也就是RootBeanDefinition。我们知道BeanPostProcessor接口的作用是在bean初始化前和初始化后执行一些方法，Spring提供了该接口的子接口来进行实例化前后执行的一些方法。可以在这个步骤中，对Bean最终进行处理，Spring中的AOP就是基于初始化后实现的，初始化后返回的对象才是最终的Bean对象。
大厂高频面试题Spring Bean生命周期最详解
wadfdhsajd的博客
06-21 176
Spring作为当前Java最流行、最强大的轻量级框架。Spring Bean的生命周期也是面试高频题，了解Spring Bean周期也能更好地帮助我们解决日常开发中的问题。程序员应该都知道Spring的基础容器是ApplicationContext。应很多粉丝的强烈建议，本文我来分析分析 ApplicationContext中Bean的生命周期。ApplicationContext是顶层容器接口BeanFactory的实现类，因此，我们了解了ApplicationContext的生命周期逻辑，也基本上了解
Spring Bean的生命周期源码解析
大尾巴狼学编程的博客
11-16 1864
主要讲解了spring Bean的生命周期的从头到尾做了那些事情，以及包含的所有扩展点
SpringBean 生命周期源码解析
养歌的博客
01-17 1234
前言 Spring 作为当前 Java 最流行、最强大的轻量级框架，受到了程序员的青睐。准确的了解 Spring Bean 的生命周期是非常必要的，Spring Bean 的生命周期是 Spring 面试热点问题，想要答好并不容易！本文将从源码的角度入手，帮助小伙伴彻底掌握 Spring Bean 的生命周期。 而 Spring Bean 的生命周期只有 4 个阶段： 主要逻辑都在 doCreateBean 方法（AbstractAutowireCapableBeanFactory类中，逻辑很清晰，就是顺
Spring Bean 生命周期源码
黄沙客栈
08-15 542
Spring Bean 生命周期非常重要，今天我们来进入到源码了解一下整个bean的生命周期 先来一张流程图(懒得画了，截图的) 大概了解了bean的生命周期后，我们来看源码
Spring Bean生命周期源码篇
最新发布
qq_43649937的博客
04-26 1873
这里先对AOP进行简单的介绍AOP （AspectOrient Programming）,直译过来就是 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
一文详解Spring Bean生命周期
2301_76607156的博客
04-26 622
之前我们在总结Spring扩展点：后置处理器时谈到了SpringBean的生命周期和其对Spring框架原理理解的重要性，所以接下来我们就来分析一下Bean生命周期的整体流程。首先Bean就是一些Java对象，只不过这些Bean不是我们主动newBean的实例化(Instantiation)
一文带你深入理解SpringBean生命周期之PostConstruct、PreDestroy详解
Moonxiyue的博客
06-20 1224
想必大家在项目中都用过这个注解把，知道它会在应用启动的时候执行被这个注解标注的方法。其实它还有另外一个注解，实在Bean销毁前执行，它们都是Bean生命周期的一环，那他们具体在什么阶段执行呢？我们从源码的角度带大家分析下。和是规范中定义的类两个类，表示Bean初始化后和销毁前指定的注解，位于包下，而不是spring jar中的类。JSR-250, Java Specification Requests的缩写，意思是Java 规范提案。它是Java界共同制定的一个重要标准。它定义了一组通用的注解，比如@Pos
Spring 源码 | bean的生命周期（图文详解）
Awwwze的博客
03-02 456
下面先用一张图描述下 bean 装载到 Spring 应用上下文中的一个典型的生命周期过程： 下面对上面的图进行详细解读： 1、首先容器启动后，会对scope为singleton且非懒加载的bean进行实例化； 2、按照Bean定义信息配置信息，注入所有的属性 （依赖注入"DI"）； 3、如果 bean 实现了 BeanNameAware 接口，Spring 会回调该接口的 setBeanName () 方法，传递该Bean的id，此时该Bean就获得了自己在配置文件中的id； 4、如果 bean 实现了
Spring Bean生命周期源码分析
微光的博客
06-19 1204
剑指Spring源码 本文使用的Spring版本为5.1.2，现在JavaConfig风格+注解的方式来使用Spring是Spring官方主推的，也是现在的主流方式，所以我们从这里出发： import org.springframework.context.annotation.AnnotationConfigApplicationContext; public class App { ...
Spring的bean生命周期源码整理
m0_37588577的博客
11-01 250
spring的容器初始化和bean生命周期源码整理
03-Spring之Bean生命周期源码解析上
future-wy
09-09 339
Spring核心IOC（对象创建）、AOP，而启动Spring就是为创建Bean对象做准备，所以我们先明白Spring到底是怎么去创建Bean的，也就是先弄明白Bean的生命周期。 Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的 Bean生命周期流程图 Bean的生成过程 1. 生成BeanDefinition Spring启动的时候会进行扫描，会先调用org.springframework.context.annotation.ClassPathS.
spring bean的生命周期源码解析
北诗
04-09 676
源码分析Spring IOC与Bean的生命周期什么是Ioc(控制反转)/DI(依赖注入)？Bean的生命周期源码分析 说在前面：spring的源码极其庞大，虽然这里我们只讨论bean的生命周期，所谓生命周期就是一个普通对象走完了spring为它设置好的“陷阱”，其实就是一系列函数改变这个对象，函数一环扣一环，希望大家耐心看第一次看可能会有些吃力，所以跟着debug会比较好，我这里只讲关于IOC和...
Spring之Bean生命周期源码解析
c243311364的博客
03-21 950
1.启动接口介绍 具体的流程图：Spring扫描底层流程 | ProcessOn免费在线作图,在线流程图,在线思维导图 | AnnotationConfigApplicationContext接口主要做了两件事情：1.scan 2.加载非懒加载的spring对象 68和70行是java中的JFR机制，相当于查看69行代码执行的黑盒子（耗时，性能等） ClassPathBeanDefinitionScanner接口主要是把扫描到的BeanDefinition注册到spring容器中
spring bean生命周期源码剖析
stay_the_course的博客
10-04 2555
spring bean生命周期记不住？看完这篇源码剖析就会了，根本不用背诵
【spring】创建Bean的方法：createBean源码分析
qq_35436158的博客
02-22 548
深入了解Bean是如何创建的，在创建 过程中需要维护什么信息！
Spring bean生命周期的源码分析（超级详细）
Android_la的博客
06-12 2918
文章目录一. 问题背景二. 储备知识三. 问题引入3.1 循环依赖3.2 对循环依赖的分析3.3 两个小结论3.4 验证两个小结论 一. 问题背景 遇到面试题“Spring Bean的生命周期是怎么样？”，很多网上的博客博文都有总结性的阐述，但是笔者想知道是从哪里开始切入到Spring Bean的生命周期，从什么时候开始，从哪句代码开始研究。因此今天研究一下Spring源码分析Spring Bean的生命周期。 此笔记仅供自己参考，如有错误请指正 参考自： 请别再问Spring Bean的生命周期了！ 【
Spring Bean的生命周期源码分析
Turbo码先生
06-14 494
Bean的生命周期 文章目录Bean的生命周期前言一、实例化Bean二、设置对象属性（依赖注入）三、initializeBean3.1 调用Aware接口3.2 调用BeanPostProcessor的前置处理3.3 invokeInitMethods3.3.1 afterPropertiesSet()3.3.2 invokeCustomInitMethod3.4 调用BeanPostProcessor的后置处理4 destory总结 前言 对于普通的Java对象，当new的时候创建对象，当它没有任
Spring Bean扩展接口详解：InitialingBean与DisposableBean应用
- 当你在实际项目中遇到Bean生命周期管理的问题时，可以考虑是否可以通过实现这些接口来优化代码结构，提高代码的可维护性和可扩展性。 通过掌握和实践`InitializingBean`和`DisposableBean`接口，开发者可以更...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值