Spring boot启动流程-解决循环依赖

Spring boot启动流程-解决循环依赖

循环依赖,指的是两个bean之间相互依赖,形成了一个循环。
目前使用的spring版本中,在启动时默认关闭了循环依赖。假设代码中两个bean相互使用@Autowired注解进行自动装配,启动时会报错如下:

Relying upon circular references is discouraged and they are prohibited by default. Update your application to remove the dependency cycle between beans. As a last resort, it may be possible to break the cycle automatically by setting spring.main.allow-circular-references to true.
翻译过来就是:
不鼓励使用循环引用,默认情况下禁止使用循环引用。更新应用程序以删除bean之间的依赖循环。作为最后的手段,可以通过设置spring.main.allow-circular-references为true自动打破循环。

spring还是支持循环依赖的,但前提是我们要手动将其打开。我们在配置文件中设置属性 spring.main.allow-circular-references = true。

解决循环依赖方法:
1、在bean A实例化完成后,如果检测到支持循环依赖,会先把A缓存起来

java">		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		//判断当前bean为单例,且允许循环依赖,且该bean正在创建中
		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");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

addSingletonFactory方法的第二个参数,传入的是一个实现了ObjectFactory<?>函数式接口的lambda表达式,表达式中调用的是getEarlyBeanReference方法,获取bean的早期引用。

	protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		synchronized (this.singletonObjects) {
			/*
			如果 singletonObjects 中不存在当前bean(当前bean还在创建,还没生成最终的单例对象,显然成立),则:
			1)把当前的singletonFactory放入singletonFactories变量中(把获取早期引用的lambda表达式放进三级缓存);
			2)把当前bean从earlySingletonObjects变量中移除(清理二级缓存,确保在循环引用触发时才生成早期引用;实际这里本来也没有);
			3)把当前beanName放入registeredSingletons变量中。
			*/
			if (!this.singletonObjects.containsKey(beanName)) {
				this.singletonFactories.put(beanName, singletonFactory);
				this.earlySingletonObjects.remove(beanName);
				this.registeredSingletons.add(beanName);
			}
		}
	}

这里可能还看不出来什么头绪,继续往下走,在bean A初始化的时候,会自动装配依赖的bean B、C等,而在B、C初始化时又会自动装配它们所依赖的A(当然B、C在实例化之后也会和A一样先缓存起来),但这个时候A也正在创建中,最终的对象肯定是拿不到的,这时候就考虑生成一个A的早期引用,先提供给B、C。

2、在doGetBean方法获取bean A的时候,会先调用getSingleton方法查找缓存,部分源码如下:

		// Eagerly check singleton cache for manually registered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isTraceEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

接下来看getSingleton方法:

	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// Quick check for existing instance without full singleton lock
		//先从singletonObjects中获取bean A,之前说过显然获取不到
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			//再从earlySingletonObjects中获取bean,刚开始也是没有的
			singletonObject = this.earlySingletonObjects.get(beanName);
			if (singletonObject == null && 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) {
							//最后从singletonFactories里拿到singletonFactory
							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
							if (singletonFactory != null) {
								//调用getObject方法获取早期引用,放进earlySingletonObjects,清理singletonFactories
								singletonObject = singletonFactory.getObject();
								this.earlySingletonObjects.put(beanName, singletonObject);
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}

到这里三级缓存的结构就比较清晰了:

一级缓存:singletonObject,这里存放的是最终初始化完成的bean对象。
也就是说bean初始化完成后 ,下次再拿的时候,可以直接从缓存里找,所以这是一个通用缓存,并非专门为循环依赖而设计。

二级缓存:earlySingletonObjects,存放完成了实例化,但还没有完成初始化的半成品bean对象,其实就是相当于把不完整的对象提前暴露了出来。
比如当bean A在初始化注入bean B、C的时候,B、C的初始化又都依赖了A,这时候从一级缓存里找A肯定是找不到的,于是就会下探到二级缓存,如果拿到了A,doGetBean方法就会返回而不是又进入A的初始化,相当于这个循环被切断了。然后B、C就能够完成初始化,最终A也能完成初始化。

三级缓存:singletonFactories,对象工厂,存放的是获取半成品bean对象的方法实现。
二级缓存的数据并不是凭空产生的,而是由于一开始访问二级缓存找不到数据,然后下探到三级缓存,调用了getObject方法,拿到半成品对象后才放进去的,然后其他bean才可以直接从二级缓存里面取。
二级缓存放入数据后,三级缓存对应的数据不再需要,立即被移除。

singletonFactory.getObject()方法其实就是lambda表达式的实现,调用了getEarlyBeanReference方法:

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

这里调用 SmartInstantiationAwareBeanPostProcessor 的 getEarlyBeanReference方法,获取了bean实例的早期引用,其实就是还没有完成初始化的半成品bean对象本身(也可能是创建了一个它的代理对象)。

能不能不要三级缓存,每次实例化bean之后,直接生成一个早期引用放到二级缓存中,方便循环依赖?
可以但不合理,早期引用是可以用来解决循环依赖问题,但实际上spring默认是不推荐使用循环依赖的,如果不结合实际情况是否需要循环依赖,直接缓存一个对象,这种设计显然有问题。

能不能不要二级缓存,每次出现循环依赖的时候,直接调用三级缓存的方法获取早期引用?
不行,首先是重复调用,有可能每次获取早期引用的工作都是完全重复的;其实如果是一个需要AOP动态代理的bean对象,每次都会产生一个新的代理对象,不符合单例的设计原则。

还有个细节,就是当一个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);
		}
	}

这里面不仅将对象放进了一级缓存singletonObjects,还同时清理了对应的二、三级缓存。

最后要注意的是,spring解决循环依赖的方式是在bean的实例化完成之后,所以不要在构造方法中引入循环依赖,因为这时对象还没有实例化,spring也无法解决。

转载请说明出处内容投诉
CSS教程_站长资源网 » Spring boot启动流程-解决循环依赖

发表评论

欢迎 访客 发表评论

一个令你着迷的主题!

查看演示 官网购买