透过源码，捋清楚循环依赖到底是如何解决的！-低调大师

透过源码，捋清楚循环依赖到底是如何解决的！

2023-08-09 293

@[toc] 以下内容基于 Spring6.0.4。

关于 Spring 循环依赖，松哥已经连着发了三篇文章了，本篇文章松哥从源码的角度来和小伙伴们捋一捋 Spring 循环依赖到底是如何解决了。如果没看过前面的文章建议先看一下，大家在面试中如果遇到循环依赖相关的问题，其实看前面三篇文章就可以答出来了，本文主要是从源码角度来验证一下我们前面文章所讲的内容是无误的。

前三篇传送门：

如何通过三级缓存解决 Spring 循环依赖
Spring 能解决所有循环依赖吗？
[@Lazy 注解为啥就能破解死循环？](https://mp.weixin.qq.com/s/GjI4xPGXscCGQtcalwnJKQ)

小伙伴们一定要先熟悉前面文章的内容，否则今天的源码可能会看起来有些吃力。

接下来我通过一个简单的循环依赖的案例，来和大家梳理一下完整的 Bean 循环依赖处理流程。

1. 案例设计

假设我有如下 Bean：

@Service
public class A {
    @Autowired
    B b;
}
@Service
public class B {
    @Autowired
    A a;
}

就这样一个简单的循环依赖，默认情况下，A 会被先加载，然后在 A 中做属性填充的时候，去创建了 B，创建 B 的时候又需要 A，就会从缓存中拿到 A，大致流程如此，接下来我们结合源码来验证一下这个流程。

2. 源码分析

首先我们来看获取 Bean 的时候，如何利用这三级缓存。

小伙伴们知道，获取 Bean 涉及到的就是 getBean 方法，像我们上面这个案例，由于都是单例的形式，所以 Bean 的初始化其实在容器创建的时候就完成了。

在 preInstantiateSingletons 方法中，又调用到 AbstractBeanFactory#getBean 方法，进而调用到 AbstractBeanFactory#doGetBean 方法。

Bean 的初始化就是从这里开始的，我们就从这里来开始看起吧。

2.1 doGetBean

AbstractBeanFactory#doGetBean（方法较长，节选部分关键内容）：

protected <t> T doGetBean(
		String name, @Nullable Class<t> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
		throws BeansException {
	String beanName = transformedBeanName(name);
	Object beanInstance;
	// Eagerly check singleton cache for manually registered singletons.
	Object sharedInstance = getSingleton(beanName);
	if (sharedInstance != null &amp;&amp; args == null) {
		beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}
	else {
		// Fail if we're already creating this bean instance:
		// We're assumably within a circular reference.
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
		// Check if bean definition exists in this factory.
		BeanFactory parentBeanFactory = getParentBeanFactory();
		if (parentBeanFactory != null &amp;&amp; !containsBeanDefinition(beanName)) {
			// Not found -&gt; check parent.
			String nameToLookup = originalBeanName(name);
			if (parentBeanFactory instanceof AbstractBeanFactory abf) {
				return abf.doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
			}
			else if (args != null) {
				// Delegation to parent with explicit args.
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			}
			else if (requiredType != null) {
				// No args -&gt; delegate to standard getBean method.
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
			else {
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}
		if (!typeCheckOnly) {
			markBeanAsCreated(beanName);
		}
		StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
				.tag("beanName", name);
		try {
			if (requiredType != null) {
				beanCreation.tag("beanType", requiredType::toString);
			}
			RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			checkMergedBeanDefinition(mbd, beanName, args);
			// Guarantee initialization of beans that the current bean depends on.
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep : dependsOn) {
					if (isDependent(beanName, dep)) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
					}
					registerDependentBean(dep, beanName);
					try {
						getBean(dep);
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
					}
				}
			}
			// Create bean instance.
			if (mbd.isSingleton()) {
				sharedInstance = getSingleton(beanName, () -&gt; {
					try {
						return createBean(beanName, mbd, args);
					}
					catch (BeansException ex) {
						// Explicitly remove instance from singleton cache: It might have been put there
						// eagerly by the creation process, to allow for circular reference resolution.
						// Also remove any beans that received a temporary reference to the bean.
						destroySingleton(beanName);
						throw ex;
					}
				});
				beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			}
		}
	}
	return adaptBeanInstance(name, beanInstance, requiredType);
}

这个方法比较长，我来和大家说几个关键的点：

首先这个方法一开始就调用了 getSingleton 方法，这个是尝试从三级缓存中获取到想要的 Bean，但是，当我们第一次初始化 A 的时候，很显然这一步是无法获取到 A 的实例的，所以这一步会返回 null。
如果第一步拿到了 Bean，那么接下来就进入到 if 分支中，直接获取到想要的 beanInstance 实例；否则进入到第三步。
如果第一步没有从三级缓存中拿到 Bean，那么接下来就要检查是否是循环依赖了，首先调用 isPrototypeCurrentlyInCreation 方法判断当前 Bean 是否已经在创建了，如果已经在创建了，那么显然要抛异常出去了（BeanCurrentlyInCreationException）。接下来就去 parent 容器中各种查找，看能否找到需要的 Bean，Spring 中的父子容器问题松哥在之前的文章中也已经讲过了，小伙伴们可以参考：Spring 中的父子容器是咋回事？。
如果从父容器中也没找到 Bean，那么接下来就会调用 markBeanAsCreated 方法来标记当前 Bean 已经创建或者正准备创建。
接下来会去标记一下创建步骤，同时检查一下 Bean 的 dependsOn 属性是否存在循环关系，这些跟我们本文关系都不大，我就不去展开了。
关键点来了，接下来判断如果我们当前 Bean 是单例的，那么就调用 getSingleton 方法去获取一个实例，该方法的第二个参数一个 Lambda 表达式，表达式的核心内容就是调用 createBean 方法去创建一个 Bean 实例，该方法将不负众望，拿到最终想要的 Bean。

以上就是 doGetBean 方法中几个比较重要的点。

其中有两个方法我们需要展开讲一下，第一个方法就是去三级缓存中查询 Bean 的 getSingleton 方法（步骤一），第二个方法则是去获取到 Bean 实例的 getSingleton 方法（步骤六），这是两个重载方法。

接下来我们就来分析一下这两个方法。

2.2 查询三级缓存

DefaultSingletonBeanRegistry#getSingleton：

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	// Quick check for existing instance without full singleton lock
	Object singletonObject = this.singletonObjects.get(beanName);
	if (singletonObject == null &amp;&amp; isSingletonCurrentlyInCreation(beanName)) {
		singletonObject = this.earlySingletonObjects.get(beanName);
		if (singletonObject == null &amp;&amp; allowEarlyReference) {
			synchronized (this.singletonObjects) {
				// Consistent creation of early reference within full singleton lock
				singletonObject = this.singletonObjects.get(beanName);
				if (singletonObject == null) {
					singletonObject = this.earlySingletonObjects.get(beanName);
					if (singletonObject == null) {
						ObjectFactory<!--?--> singletonFactory = this.singletonFactories.get(beanName);
						if (singletonFactory != null) {
							singletonObject = singletonFactory.getObject();
							this.earlySingletonObjects.put(beanName, singletonObject);
							this.singletonFactories.remove(beanName);
						}
					}
				}
			}
		}
	}
	return singletonObject;
}

首先去 singletonObjects 中查找，这就是所谓的一级缓存，如果这里能直接找到想要的对象，那么直接返回即可。
如果一级缓存中不存在想要的 Bean，那么接下来就该去二级缓存 earlySingletonObjects 中查找了，二级缓存要是有我们想要的 Bean，那么也是直接返回即可。
二级缓存中如果也不存在，那么就是加锁然后去三级缓存中查找了，三级缓存是 singletonFactories，我们从 singletonFactories 中获取到的是一个 ObjectFactory 对象，这是一个 Lambda 表达式，调用这里的 getObject 方法最终有可能会促成提前 AOP，至于这个 Lambda 表达式的内容，松哥在前面的文章中已经和小伙伴们介绍过了，这里先不啰嗦（如何通过三级缓存解决 Spring 循环依赖）。
如果走到三级缓存这一步了，从三级缓存中拿到了想要的数据，那么就把数据存入到二级缓存 earlySingletonObjects 中，以备下次使用。同时，移除三级缓存中对应的数据。

当我们第一次创建 A 对象的时候，很显然三级缓存中都不可能有数据，所以这个方法最终返回 null。

2.3 获取 Bean 实例

接下来看 2.1 小节步骤六的获取 Bean 的方法。

DefaultSingletonBeanRegistry#getSingleton（方法较长，节选部分关键内容）：

public Object getSingleton(String beanName, ObjectFactory<!--?--> singletonFactory) {
	synchronized (this.singletonObjects) {
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null) {
			if (this.singletonsCurrentlyInDestruction) {
				throw new BeanCreationNotAllowedException(beanName,
						"Singleton bean creation not allowed while singletons of this factory are in destruction " +
						"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
			}
			beforeSingletonCreation(beanName);
			boolean newSingleton = false;
			boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
			if (recordSuppressedExceptions) {
				this.suppressedExceptions = new LinkedHashSet&lt;&gt;();
			}
			try {
				singletonObject = singletonFactory.getObject();
				newSingleton = true;
			}
			if (newSingleton) {
				addSingleton(beanName, singletonObject);
			}
		}
		return singletonObject;
	}
}

这个方法首先也是尝试从一级缓存中获取到想要的 Bean，如果 Bean 为 null，就开始施法了。
首先会去判断一下，如果这个工厂的单例正在销毁，那么这个 Bean 的创建就不被允许。
接下来会有一堆准备工作，关键点在 singletonFactory.getObject(); 地方，这个就是方法第二个参数传进来的回调函数，将来在回调函数中，会调用到 createBean 方法，真正开始 A 这个 Bean 的创建。将 A 对象创建成功之后，会把 newSingleton 设置为 true，第 4 步会用到。
现在调用 addSingleton 方法，把创建成功的 Bean 添加到缓存中。

我们来看下 addSingleton 方法：

protected void addSingleton(String beanName, Object singletonObject) {
	synchronized (this.singletonObjects) {
		this.singletonObjects.put(beanName, singletonObject);
		this.singletonFactories.remove(beanName);
		this.earlySingletonObjects.remove(beanName);
		this.registeredSingletons.add(beanName);
	}
}

小伙伴们看一下，一级缓存中存入 Bean，二级缓存和三级缓存移除该 Bean，同时在 registeredSingletons 集合中记录一下当前 Bean 已经创建。

所以现在的重点其实又回到了 createBean 方法了。

2.4 createBean

createBean 方法其实就到了 Bean 的创建流程了。bean 的创建流程在前面几篇 Spring 源码相关的文章中也都有所涉猎，所以今天我就光说一些跟本文主题相关的几个点。

createBean 方法最终会调用到 AbstractAutowireCapableBeanFactory#doCreateBean 方法，这个方法也是比较长的，而我是关心如下几个地方：

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {
	// Eagerly cache singletons to be able to resolve circular references
	// even when triggered by lifecycle interfaces like BeanFactoryAware.
	boolean earlySingletonExposure = (mbd.isSingleton() &amp;&amp; this.allowCircularReferences &amp;&amp;
			isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		addSingletonFactory(beanName, () -&gt; getEarlyBeanReference(beanName, mbd, bean));
	}
	// Initialize the bean instance.
	Object exposedObject = bean;
	try {
		populateBean(beanName, mbd, instanceWrapper);
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	return exposedObject;
}

这里我比较在意的有两个地方，一个是调用 addSingletonFactory 方法向三级缓存中添加回调函数，回调函数是 getEarlyBeanReference，如果有需要，将来会通过这个回调提前进行 AOP，即使没有 AOP，就是普通的循环依赖，三级缓存也是会被调用的，这个大家继续往后看就知道了，另外还有一个比较重要的地方，在本方法一开始的时候，就已经创建出来 A 对象了，这个时候的 A 对象是一个原始 Bean，即单纯的只是通过反射把对象创建出来了，Bean 还没有经历过完整的生命周期，这里 getEarlyBeanReference 方法的第三个参数就是该 Bean，这个也非常重要，牢记，后面会用到。

第二个地方就是 populateBean 方法，当执行到这个方法的时候，A 对象已经创建出来了，这个方法是给 A 对象填充属性用的，因为接下来要注入 B 对象，就在这个方法中完成的。

由于我们第 1 小节是通过 @Autowired 来注入 Bean 的，所以现在在 populateBean 方法也主要是处理 @Autowired 注入的情况，那么这个松哥之前写过文章，小伙伴们参考@Autowired 到底是怎么把变量注入进来的？，具体的注入细节我这里就不重复了，单说在注入的过程中，会经过一个 DefaultListableBeanFactory#doResolveDependency 方法，这个方法就是用来解析 B 对象的（至于如何到达 doResolveDependency 方法的，小伙伴们参考 @Autowired 到底是怎么把变量注入进来的？一文）。

doResolveDependency 方法也是比较长，我这里贴出来和本文相关的几个关键地方：

@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
		@Nullable Set<string> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
	    //...
		Map<string, object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
		if (matchingBeans.isEmpty()) {
			if (isRequired(descriptor)) {
				raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
			}
			return null;
		}
		String autowiredBeanName;
		Object instanceCandidate;
		if (matchingBeans.size() &gt; 1) {
			autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
			if (autowiredBeanName == null) {
				if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
					return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
				}
				else {
					// In case of an optional Collection/Map, silently ignore a non-unique case:
					// possibly it was meant to be an empty collection of multiple regular beans
					// (before 4.3 in particular when we didn't even look for collection beans).
					return null;
				}
			}
			instanceCandidate = matchingBeans.get(autowiredBeanName);
		}
		else {
			// We have exactly one match.
			Map.Entry<string, object> entry = matchingBeans.entrySet().iterator().next();
			autowiredBeanName = entry.getKey();
			instanceCandidate = entry.getValue();
		}
		if (autowiredBeanNames != null) {
			autowiredBeanNames.add(autowiredBeanName);
		}
		if (instanceCandidate instanceof Class) {
			instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
		}
        //...
}

在这个方法中，首先调用 findAutowireCandidates 方法，以类型为依据，找到所有满足条件的 Class 并组成一个 Map 返回。例如第一小节的案例，这里就会找到所有 B 类型的 Class，通过一个 Map 返回。
如果第一步返回的 Map 存在多条记录，那么就必须从中挑选一个出来，这就是 matchingBeans.size() > 1 的情况。
如果第一步返回的 Map 只有一条记录，那么就从 Map 中提取出来 key 和 value，此时的 value 是一个 Class，所以接下来还要调用 descriptor.resolveCandidate 去完成 Class 到对象的转变。

而 descriptor.resolveCandidate 方法又开启了新一轮的 Bean 初始化，只不过这次初始化的 B 对象，如下：

public Object resolveCandidate(String beanName, Class<!--?--> requiredType, BeanFactory beanFactory)
		throws BeansException {
	return beanFactory.getBean(beanName);
}

2.5 后续流程

后续流程其实就是上面的步骤，我就直接来跟大家说一说，就不贴代码了。

现在系统调用 beanFactory.getBean 方法去查找 B 对象，结果又是走一遍本文第二小节的所有流程，当 B 创建出来之后，也要去做属性填充，此时需要在 B 中注入 A，那么又来到本文的 2.4 小节，最终又是调用到 resolveCandidate 方法去获取 A 对象。

此时，在获取 A 对象的过程中，又会调用到 doGetBean 这个方法，在这个方法中调用 getSingleton 的时候（2.1 小节的第一步），这个时候的执行逻辑就跟前面不一样了，我们再来看下这个方法的源码：

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	// Quick check for existing instance without full singleton lock
	Object singletonObject = this.singletonObjects.get(beanName);
	if (singletonObject == null &amp;&amp; isSingletonCurrentlyInCreation(beanName)) {
		singletonObject = this.earlySingletonObjects.get(beanName);
		if (singletonObject == null &amp;&amp; allowEarlyReference) {
			synchronized (this.singletonObjects) {
				// Consistent creation of early reference within full singleton lock
				singletonObject = this.singletonObjects.get(beanName);
				if (singletonObject == null) {
					singletonObject = this.earlySingletonObjects.get(beanName);
					if (singletonObject == null) {
						ObjectFactory<!--?--> singletonFactory = this.singletonFactories.get(beanName);
						if (singletonFactory != null) {
							singletonObject = singletonFactory.getObject();
							this.earlySingletonObjects.put(beanName, singletonObject);
							this.singletonFactories.remove(beanName);
						}
					}
				}
			}
		}
	}
	return singletonObject;
}

现在还是尝试从三级缓存中获取 A，此时一二级缓存中还是没有 A，但是三级缓存中有一个回调函数，当执行 singletonFactory.getObject() 方法的时候，就会触发该回调函数，这个回调函数就是我们前面 2.4 小节提到的 getEarlyBeanReference 方法，我们现在来看下这个方法：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
	Object exposedObject = bean;
	if (!mbd.isSynthetic() &amp;&amp; hasInstantiationAwareBeanPostProcessors()) {
		for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
			exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
		}
	}
	return exposedObject;
}

这个方法有一个参数 Bean，这个参数 Bean 会经过一些后置处理器处理之后返回，后置处理器主要是看一下这个 Bean 是否需要 AOP，如果需要就进行 AOP 处理，如果不需要，直接就把这个参数 Bean 返回就行了。至于这个参数是哪来的，我在 2.4 小节中已经加黑标记出来了，这个参数 Bean 其实就是原始的 A 对象！

好了，现在 B 对象就从缓存池中拿到了原始的 A 对象，B 对象属性注入完毕，对象创建成功，进而导致 A 对象也创建成功。

大功告成。

3. 小结

老实说，如果小伙伴们认认真真看过松哥最近发的 Spring 源码文章，今天的内容很好懂～至此，Spring 循环依赖，从思路到源码，都和大家分析完毕了～感兴趣的小伙伴可以 DEBUG 走一遍哦～</string,></string,></string></t></t>

微信关注我们

原文链接：https://my.oschina.net/lenve/blog/10094025

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

GPT-4助力数据分析：提升效率与洞察力的未来关键技术 | 京东云技术团队

摘要随着大数据时代的到来，数据分析已经成为企业和组织的核心竞争力。然而，传统的数据分析方法往往无法满足日益增长的数据分析需求的数量和复杂性。在这种背景下，ChatGPT-4作为一种先进的自然语言处理技术，为数据分析带来了革命性的提升，助力企业和组织更高效地挖掘数据价值。本文将探讨ChatGPT-4在数据分析中的应用，以及如何通过该技术提高数据分析的效率和洞察力。注：此图片选自阿里巴巴集团达摩院和新加坡南洋理工大学合作论文《Is GPT-4 a Good Data Analyst》 1. 引言随着互联网和移动设备的普及，数据的产生和传播速度不断加快，企业和组织需要更高效的方法来处理和分析这些数据。传统的数据分析方法往往依赖于人工处理和分析，在需求量大的时候容易出现效率低的问题。因此，如何利用先进的技术提高数据分析的效率和准确性成为了一个迫切的问题。ChatGPT-4作为一种基于深度学习的自然语言处理技术，为解决这一问题提供了新的思路。 2. ChatGPT-4技术概述 ChatGPT-4是一种基于深度学习的自然语言处理（NLP）技术，能够理解和生成人类语言。通过大量的训练数据和复杂...

2023-08-09

360

v9.28.51.优化MacOSX系统下，隧道守护进程在Dock任务栏中的显示与隐藏。2.增加配置文件的保密能力，防止随意修改配置。3.丰富主菜单的各项功能入口，看起来逼格更专业。4.[SFTP]修复选项卡切换时，会导致上下载终止的缺陷。5.[SerialPort]增强串口输入模式、分割模式、输出模式，使其能处理更复杂的场景。6.[RLogin]优化帐号断开及自动登录的逻辑过程。本次优化重点在于增强串口的功能，使其能处理更复杂的场景。下载地址：http://woterm.com 开源地址：https://github.com/aoyiduo/woterm 或 https://gitee.com/aoyiduo/woterm

2023-08-08

361

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。