Spring源码分析——解决循环依赖

3 篇文章 0 订阅

Spring源码分析——解决循环依赖

一、循环依赖

什么是循环依赖?

存在类A实例Bean、类B实例Bean、类C实例Bean,在类A中引用了类B,类B中引用了类C,同时类C中引用了类A,此时使用Spring初始化类A、B、C便会存在循环引用的情况。当实例化A时发现其引用了B实例;于时对B进行实例化,实例化B时又对C实例进行引用;于时再实例化C,实例化C时,又引用了A实例,而此时A还在等待B初始化完成,因此出现死循环的现象。

在这里插入图片描述

二、循环依赖解决

1.三级缓存

在Spring中解决循环引用的方式是使用三级缓存策略,分别如下

/** 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);
  1. 一级缓存:singletonObjects,用于缓存单例对象实例,这里存放的是已经实例完的对象Bean
  2. 二级缓存:earlySingletonObjects,用于存放早期实例的单例对象,这里存放的是正在创建实例,且还没实例完成的Bean
  3. 三级缓存:singletonFactories,用于缓存单例工厂

2.循环依赖解决过程

(1)缓存添加过程

单例模式下,第一次获取Bean时由于Bean示例还未实例化,因此会先创建Bean然后放入缓存中,以后再次调用获取Bean方法将直接从缓存中获取,不再重新创建。Spring中,获取Bean的流程:

在这里插入图片描述

缓存添加过程主要发生在创建Bean也就是doCreateBean()过程中。doCreateBean()中有这样一句代码

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

其源码如下

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);
		}
	}
}

创建Bean主要经历了一下三个过程:

  1. createBeanInstance:通过构造方法创建实例
  2. populateBean:填充属性
  3. initializeBean:调用init()方法初始化Bean

从代码中可以看到在这里将beanName放入三级缓存中,并且从二级缓存中移除。这里的addSingletonFactory发生在createBeanInstance之后,此时已经有了实例对象,但是还没创建完成便放入三级缓存当中。在doCreateBean()方法执行完成之后,Bean实例创建完成,因此在第二个getSingleton()中的finally块中如果是新的单例对象则会调用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);
	}
}

可以看到此时将加入一级缓存中,并且从二级、三级缓存中移除。

(2)获取缓存过程

缓存的获取是通过getSingleton(String beanName)方法获取的,其源码如下:

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	Object singletonObject = this.singletonObjects.get(beanName);
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		synchronized (this.singletonObjects) {
			singletonObject = this.earlySingletonObjects.get(beanName);
			if (singletonObject == null && allowEarlyReference) {
				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;如果获取不到并且获取的Bean被标记为正在创建中,则从二级缓存earlySingletonObjects中获取;如果二级缓存中依然获取不到Bean,并且允许从三级换从中获取Bean,则从三级缓存中获取Bean,此时如果获取到了Bean,则将该Bean从三级缓存中移除,然后添加进二级缓存(缓存升级),否则返回null。

在这里插入图片描述

3.三级缓存解决循环依赖流程

通过使用三级缓存可以解决循环依赖的问题,以A、B、C相互依赖的情况为例,其解决循环依赖流程如下:

  1. 创建A对象,执行createInstance之后将对象放入三级缓存singletonFactories中提前曝光自己,并继续执行
  2. 执行populateBean为A对象填充属性,此时发现A依赖了B对象,于是通过getBean获取B对象,此时B还没创建,便会执行创建B的Bean对象流程
  3. 执行createInstance创建B对象,并放入三级缓存singletonFactories提前曝光
  4. 执行populateBean为B对象填充属性时,发现B对象依赖了C对象,于是getBean获取C对象
  5. 此时C对象未创建,于是执行创建C对象Bean过程,在填充C时发现C依赖A对象,于是通过getBean获取对象A
  6. 此时A对象并未初始化完成,仅仅是放入三级缓存中,在getSingleton时从三级缓存中取出A的ObjecFactory来获取对象,并且将A对象进行缓存升级,从二级缓存放入三级缓存,此时C也拿到了A对象实例
  7. A缓存从三级升到了二级,在Bean创建完成之后会通过addSingleton将缓存从二级再升到三级中。B、C流程相同

在这里插入图片描述

三、总结

  1. 当两个Bean相互引用依赖的情况称为循环引用,Spring使用三级缓存的方式解决循环依赖
  2. 循环依赖发生在创建Bean的过程中,具体发生在doCreateBean方法中调用createBeanInstance和populateBean方法时
  3. 由于在createBeanInstance时用构造方法提前曝光实例,之后再将实例放入三级缓存中,因此Spring不能解决构造函数中的循环依赖问题
  4. 在使用getSingleton获取Bean实例时,如果对象在三级缓存中,则会从三级缓存移除添加到二级缓存;如果在二级缓存中,则会从二级缓存中移除添加到一级缓存中,以达到缓存升级的目的
  5. 在三个级别缓存中,二级缓存和三级缓存从代码上看是互斥的,实例对象不能同时存在于二三级缓存当中

四、相关博客

Spring源码分析——Bean创建
Spring源码分析——获取Bean
Spring源码分析——解决循环依赖

  • 2
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值