网站需要租服务器吗发布项目信息的平台

什么是循环依赖

注册一个bean对象的过程：
Spring扫描class得到BeanDefinition – 根据得到的BeanDefinition去生成bean – 现根据class推断构造方法 – 根据推断出来的构造方法，反射，得到一个对象 – 填充初始对象中的属性(依赖注入) – 如果原始对象种的某个方法被AOP了，那么要根据原始对象生成一个代理对象 – 把最终生成的代理对象放入单例池(singletonObjects，也叫一级缓存)中，下次getBea你就直接从单例池拿

循环依赖就是在依赖注入的时候相互注入，如

public class AService{@Autowiredprivate BService bService;
}
public class BService{@Autowiredprivate AService aService;
}

三级缓存过程

Spring使用了三级缓存的策略来解决循环依赖问题，过程大致如下
创建AService的bean：

因为暂时还没有BService，所以创建个BService

创建过程中，因为AService已经在三级缓存中出现过，所以会进行以下操作

因为BService的属性都已经赋值了，所以BService的初始化就结束了，可以直接放到一级缓存中，完整过程为：

此时BService已经实例化完成，那么AService中的依赖就可以进行注入了：

完整流程图如下：

简单的源码解析

首先在AbstractAutowireCapabaleBeanFactory类里(我是用ctrl+shift+alt+n找到的)的doCreateBean
先创造了一个bean原始对象，此时还没有依赖注入

		BeanWrapper instanceWrapper = null;if (mbd.isSingleton()) {instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);}if (instanceWrapper == null) {instanceWrapper = this.createBeanInstance(beanName, mbd, args);}Object bean = instanceWrapper.getWrappedInstance();

然后将lambda表达式放入三级缓存中

        if (earlySingletonExposure) {if (this.logger.isTraceEnabled()) {this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");}//放入三级缓存，这个lambda表达式是为了执行aop生成代理对象用的，如果有aop操作，就会拿到代理对象出来this.addSingletonFactory(beanName, () -> {return this.getEarlyBeanReference(beanName, mbd, bean);});}

紧接着就是A的依赖填充

	this.populateBean(beanName, mbd, instanceWrapper);

在这个里面会走到一个getSingleton方法,也就是在缓存中找BService

	//allowEarlyReference是是否允许循环依赖@Nullableprotected Object getSingleton(String beanName, boolean allowEarlyReference) {Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {synchronized(this.singletonObjects) {//一级缓存中找singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {//二级缓存中找singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null) {//三级缓存中找ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);if (singletonFactory != null) {	//找到了//这里相当于上面图文分析中BService在三级缓存中找到AService//直接用lambda表达式注册，然后把他移动到二级缓存中singletonObject = singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}}}return singletonObject;}

但是显然AService肯定不会找到，然后就会重新走到createBean，创建一个BService，与A一样走到上述的getSingleton，这时会在三级缓存中找到A，然后注入

填充完成之后就会把BService放到一级缓存中,移除三级缓存中的B，然后结束

	exposedObject = this.initializeBean(beanName, exposedObject, mbd);

执行完整个BService的创建，上面的A的依赖填充才会结束，然后A也执行一遍exposedObject = this.initializeBean(beanName, exposedObject, mbd);这行代码，A也结束。

结合图文演示看代码更容易理解捏