希望之光永远向着目标清晰的人敞开。

1. 循环依赖概述

循环依赖通俗讲就是循环引用,指两个或两个以上对象的bean相互引用对方,A依赖于B,B依赖于A,最终形成一个闭环。

Spring循环依赖的场景有两种:

  • 构造器的循环依赖
  • field 属性的循环依赖

    对于构造器的循环依赖,Spring 是无法解决,只能抛出 BeanCurrentlyInCreationException 异常;对于field 属性的循环依赖,Spring 只解决 scope 为 singleton 的循环依赖,对于scope 为 prototype 的 bean Spring 无法解决,直接抛出 BeanCurrentlyInCreationException 异常。下面重点分析属性依赖的情况。

2. 循环依赖执行流程



以上流程图针对如下代码进行演示:

@Component
public class CircularRefA { public CircularRefA() {
System.out.println("============CircularRefA()===========");
} //这里会触发CircularRefB类型的getBean操作
@Autowired
private CircularRefB circularRefB;
}
@Component
public class CircularRefB { public CircularRefB() {
System.out.println("============CircularRefB()===========");
} //又会触发A的getBean操作
@Autowired
private CircularRefA circularRefA;
}

step1: A类实例化执行,第一次三个缓存中都没有,会走doGetBean一路走到createBeanInstance,完成无参构造函数实例化,并在addSingletonFactory中设置三级缓存;

step2:A类populateBean进行依赖注入,随后触发了B类属性的getBean操作;

step3: B类与A类类似,第一次三个缓存中也都没有,无参构造函数实例化后,设置三级缓存,将自己加入三级缓存;

step4:B类populateBean进行依赖注入,这里触发了A类属性的getBean操作;

step5: A类之前正在创建,此时已经是第二次进入,由于一级二级缓存中都没有,会从三级缓存中获取,并且允许 bean提前暴露则从三级缓存中拿到对象工厂,从工厂中拿到对象成功后,升级到二级缓存,并删除三级缓存;若以后有别的类引用的话就从二级缓存中进行取;

step6:B类拿到了A的提前暴露实例注入到A类属性中了,此时完成B类的实例化;

step7:A类之前依赖B类,B的实例化完成,进而促使A的实例化也完成,并且此时A的类B属性已经有值,A类继续走后续的afterSingletonCreateion与addSingleton方法,删除正在创建缓存中的实例,并将实例从二级缓存移入以及缓存,同时删除二三级缓存;

以上是A类实例化的全过程,下面会针对源码逐一分析。

3. 源码分析

首先创建A的实例,需要从A的getBean方法开始,到doGetBean,第一次优先从缓存中取,进入getSingleton方法:

	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从一级缓存singletonObjects中取
Object singletonObject = this.singletonObjects.get(beanName);
// 一级缓存为空,且单例对象正在创建
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从二级缓存earlySingletonObjects中取
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果二级缓存也为空,且允许bean提前暴露
if (singletonObject == null && allowEarlyReference) {
// 从三级缓存singletonFactories中取
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
// 如果三级缓存不为空
if (singletonFactory != null) {
// 调用getEarlyBeanReference方法提前暴露bean
singletonObject = singletonFactory.getObject();
// 提前暴露的bean放入二级缓存,
this.earlySingletonObjects.put(beanName, singletonObject);
// 将提前暴露的bean从三级缓存中删除
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}

这个方法主要是从三个缓存中获取,分别是:singletonObjectsearlySingletonObjectssingletonFactories,三者定义如下:

	/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); /** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); /** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

意义如下:

  • singletonObjects:单例对象的cache
  • singletonFactories : 单例对象工厂的cache
  • earlySingletonObjects :提前暴露的单例对象的Cache

解决循环依赖的关键是三个缓存,其中一级缓存singletonObjects存放完全实例化的对象,对象以及其依赖的属性都有值;二级缓存earlySingletonObjects存放半实例化的对象,相当于在内存开辟了空间,已完成创建,但是还未进行属性赋值,可以提前暴露使用;三级缓存singletonFactories为对象工厂,用来创建提前暴露的bean并放入二级缓存中。

首次初始化A时,三个缓存中都没有对象,会进入如下getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法,该方法第二个参数是个函数式接口,当内部调用getObject方法时,会调用createBean方法:

				// 创建bean实例
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
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;
}
});
......

先进入getSingleton方法:

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
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!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// bean单例创建前
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 调用createBean方法创建bean
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 创建完成后要从正在实例化的bean集合singletonsCurrentlyInCreation中删除该bean
afterSingletonCreation(beanName);
}
if (newSingleton) {
// bean加入缓存
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}

该方法完成流程图中的四个步骤:

step1:bean单例创建前,将beanName放入singletonsCurrentlyInCreation缓存;

step2: singletonFactory.getObject()调用外面函数式接口中的createBean方法创建bean;

step3afterSingletonCreation方法将beanName从singletonsCurrentlyInCreation缓存删除,表示已创建完;

step4: 实例化后加入一级缓存,二三级缓存删除。

以上1、3、4涉及代码如下:

	protected void beforeSingletonCreation(String beanName) {
// 将正在创建的bean放入缓存singletonsCurrentlyInCreation
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
	protected void afterSingletonCreation(String beanName) {
// 正在创建中的缓存容器singletonsCurrentlyInCreation清除刚刚创建的bean
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
	protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 一级缓存存放bean
this.singletonObjects.put(beanName, singletonObject);
// 三级缓存移除bean
this.singletonFactories.remove(beanName);
// 二级缓存移除bean
this.earlySingletonObjects.remove(beanName);
//
this.registeredSingletons.add(beanName);
}
}

其中step2流程较长,当A第一次实例化时,走到创建无参构造函数实例化createBeanInstance,随后会走addSingletonFactory方法:

	protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}

从这段代码我们可以看出singletonFactories这个三级缓存才是解决循环依赖的关键,该代码在createBeanInstance方法之后,也就是说这个bean其实已经被创建出来了,但是它还不是很完美(没有进行属性填充和初始化),但是对于其他依赖它的对象而言已经足够了(可以根据对象引用定位到堆中对象),能够被认出来了,所以Spring在这个时候选择将该对象提前曝光出来让大家认识认识。当三级缓存有值后,后面如果再次用到该bean的时候,会从三级缓存中,并通过提前暴露,升级到二级缓存中,到这里我们发现三级缓存singletonFactories和二级缓存earlySingletonObjects中的值都有出处了,那一级缓存在哪里设置的呢?就是在A创建完,并把A依赖的属性B也创建完后,B有依赖于A,再次进入A后,A直接从二级缓存中获取,从而促使B对象创建完,随即A也就创建完成,A完成createBean后走上面的step4中的addSingletion方法,完成一级缓存的设置。

4.总结

Spring在创建bean的时候并不是等它完全完成,而是在创建过程中将创建中的 bean 的 ObjectFactory 提前曝光(即加入到 singletonFactories 缓存中),这样一旦下一个 bean 创建的时候需要依赖 bean ,则直接使用 ObjectFactory 的 getObject() 获取了,故在缓存中使用三级缓存获取到实例,并将实例升级到二级缓存,供后续实例如需二次使用时,可直接从二级缓存中取,待实例完全创建后,升级到一级缓存,并清理二级三级缓存,总而言之提前暴露三级缓存,以及一二三级缓存的综合使用是解决循环依赖的关键,各级缓存各司其职,又能够相互呼应,spring的设计实在精妙,给我们自己设计项目提供了一种优秀的思考方式。

【spring源码系列】之【Bean的循环依赖】的更多相关文章

  1. Spring源码系列(二)--bean组件的源码分析

    简介 spring-bean 组件是 Spring IoC 的核心,我们可以使用它的 beanFactory 来获取所需的对象,对象的实例化.属性装配和初始化等都可以交给 spring 来管理. 本文 ...

  2. Spring源码分析(十七)循环依赖

    本文结合<Spring源码深度解析>来分析Spring 5.0.6版本的源代码.若有描述错误之处,欢迎指正. 实例化bean是一个非常复杂的过程,而其中比较难以理解的就是对循环依赖的解决, ...

  3. Spring源码解析(五)循环依赖问题

    引言 循环依赖就是多个类之间互相依赖,比如A依赖B,B也依赖A,如果日常开发中我们用new的方式创建对象,这种循环依赖就会导致不断的在创建对象,导致内存溢出. Spring是怎么解决循环依赖的问题的? ...

  4. spring源码深度解析— IOC 之 循环依赖处理

    什么是循环依赖 循环依赖其实就是循环引用,也就是两个或则两个以上的bean互相持有对方,最终形成闭环.比如A依赖于B,B依赖于C,C又依赖于A.如下图所示: 注意,这里不是函数的循环调用,是对象的相互 ...

  5. spring源码阅读笔记09:循环依赖

    前面的文章一直在研究Spring创建Bean的整个过程,创建一个bean是一个非常复杂的过程,而其中最难以理解的就是对循环依赖的处理,本文就来研究一下spring是如何处理循环依赖的. 1. 什么是循 ...

  6. Spring源码分析之Bean的创建过程详解

    前文传送门: Spring源码分析之预启动流程 Spring源码分析之BeanFactory体系结构 Spring源码分析之BeanFactoryPostProcessor调用过程详解 本文内容: 在 ...

  7. Spring源码系列(三)--spring-aop的基础组件、架构和使用

    简介 前面已经讲完 spring-bean( 详见Spring ),这篇博客开始攻克 Spring 的另一个重要模块--spring-aop. spring-aop 可以实现动态代理(底层是使用 JD ...

  8. Spring源码系列(四)--spring-aop是如何设计的

    简介 spring-aop 用于生成动态代理类(底层是使用 JDK 动态代理或 cglib 来生成代理类),搭配 spring-bean 一起使用,可以使 AOP 更加解耦.方便.在实际项目中,spr ...

  9. Spring源码系列 — Bean生命周期

    前言 上篇文章中介绍了Spring容器的扩展点,这个是在Bean的创建过程之前执行的逻辑.承接扩展点之后,就是Spring容器的另一个核心:Bean的生命周期过程.这个生命周期过程大致经历了一下的几个 ...

  10. Ioc容器依赖注入-Spring 源码系列(2)

    Ioc容器依赖注入-Spring 源码系列(2) 目录: Ioc容器beanDefinition-Spring 源码(1) Ioc容器依赖注入-Spring 源码(2) Ioc容器BeanPostPr ...

随机推荐

  1. 深入理解java虚拟机笔记Chapter4

    JDK命令行工具 其中的重中之重是 jstat 命令!而它最常用的参数就是 -gcutil,使用格式如下: jstat -gcutil [pid] [intervel] [count] 输出如下 D: ...

  2. 如何下载安装Python

     github博客传送门 csdn博客传送门 如何下载安装python 第一步: 在python的官网下载python版本,需要下载对应版本(在计算机-属性中查看自己是32位操作系统还是64位操作系统 ...

  3. 如何在CentOS 7上搭建LAMP环境(使用YUM或编译)

    什么是LAMP? LAMP是Linux,Apache,MySQL和PHP的缩写. 它是一堆应用程序的堆栈,它们在Web服务器上一起工作以托管网站. 话虽如此,每个程序都有不同的目的: 在LAMP中, ...

  4. 搭建 MySQL 高可用高性能集群

    什么是MySQL集群,什么是MySQL集群,如果你想知道什么是MySQL集群,我现在就带你研究. MySQL 是一款流行的轻量级数据库,很多应用都是使用它作为数据存储.作为小型应用的数据库,它完全可以 ...

  5. ClickHouse学习系列之四【副本&分片部署说明】

    背景 以前介绍过ClickHouse相关的系列文章,现在继续说明.本文开始说明ClickHouse的副本与分片,和其他数据库一样,ClickHouse也会出现单节点故障和单节点资源到达上限的情况.所以 ...

  6. NXNSAttack漏洞简析

    漏洞简介: 该漏洞为DNS 放大攻击,是 DDoS 攻击,攻击者利用 DNS 服务器中的漏洞将小查询转换为可能破坏目标服务器的更大负载. 在 NXNSAttack 的情况下,远程攻击者可以通过向易受攻 ...

  7. Spring Cloud专题之三:Hystrix

    在微服务架构中,我们将系统拆分成很多个服务单元,各单位的应用间通过服务注册与订阅的方式相互依赖.由于每个单元都在不同的进程中运行,依赖通过远程调用的方式执行,这样就有可能因为网络原因或是依赖服务自身问 ...

  8. Devops 改变coding —— 安装个指定版本的 jenkins 发现和想象的不太一样?

    你好呀,我是小猿来也,一个刚开始折腾 Devops 的程序猿. 写在前面 前两天在池大那里看到了一段话,原话出自美团首席科学家夏华夏老师,具体内容我贴到了下面. 对于图片里的内容你们是怎么认为的呢?我 ...

  9. 玩转html2canvas以及常见问题解决

    前端小伙伴经常会遇到页面截图或者把网页中指定的区域(某个大div)的内容转换成png的图片.这个时候常常会用到html2canvas库来实现,js真的很强大. 我最近也遇到了一个需求,需要把输入的文本 ...

  10. 02 Linux系统发送告警邮件

    # yum install mailx -y # vim /etc/mail.rc set from=hyjy2504164765@163.com smtp=smtp.163.com set smtp ...