Spring 如何解决 Bean 循环依赖问题

·  阅读 190

什么是循环依赖问题

循环依赖其实就是循环引用,也就是两个或则两个以上的bean互相持有对方,最终形成闭环。比如A依赖于B,B依赖于C,C又依赖于A。

Spring 如何解决循环依赖问题

简而言之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);
复制代码

三级缓存分别为

  • singletonObjects:单例Bean缓存;

  • singletonFactories:单例Bean工厂缓存;

  • earlySingletonObjects:提前曝光的单例Bean缓存;

	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;
	}
复制代码

获取单例Bean的大致过程如下:

  • 首先从一级缓存singletonObjects中通过beanName获取单例bean;
  • 若一级缓存中不存在该bean,并且isSingletonCurrentlyInCreation返回为true,那么通过earlySingletonObjects获取提前曝光的bean;
  • 若二级缓存中不存在该bean,并且允许通过singletonFactories获取对象,那么通过工厂来创建bean。

isSingletonCurrentlyInCreation表示当前bean是否正在创建中,例如对象A通过构造函数依赖B,获取对象A在填充属性的过程中,发现通过成员变量的形式依赖对象B,那么需要先对B进行实例化,这种情况下,对象A的状态就是在正在创建中。

要理解Spring如何解决循环依赖问题,还需要了解Spring Bean的初始化过程,spring bean 的初始化大致可以分为如下过程

  • 调用构造方法进行实例化;
  • 填充对象属性;
  • 通过init方法进行初始化

创建Bean的过程中,完成第一步骤,对象已经被生产出来了,只是对象缺失了一些属性,但是对象已经能够被引用了。

解决循环依赖的关键就是三级缓存,其中三级缓存singletonFactories是在方法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);
			}
		}
	}
复制代码

该方法被AbstractAutowireCapableBeanFactory类中的doCreateBean调用,那么在bean实例化之后,即调用了构造函数之后,singletonFactories已经被注册,通过singletonFactories,spring将未完整初始化的对象暴露出来,供其他类使用。

若对象A通过成员变量的形式依赖对象B,对象B通过循环依赖的形式依赖对象A,我们来看一下Spring解决循环依赖的步骤

  • 对象A进行初始化,首先通过构造函数进行实例化,然后填充属性,发现依赖的对象B没有进行加载;
  • 对象B进行初始化,首先通过构造函数进行实例化,然后填充属性,此时对象A以被提前暴露出来,对象B完成初始化;
  • 对象A通过对象B完成属性填充,完成初始化。

通过spring解决循环依赖的原理,可以看出,对于相互通过构造函数产生的循环依赖是无法解决的,如对象A通过构造函数依赖对象B,同时对象B通过构造函数依赖对象A,此时Spring就无能为力了,因为对象A和对象B,都无法通过构造函数完成初始化来提前暴露自身。

分类:
后端
标签:
收藏成功!
已添加到「」, 点击更改