循环依赖

1. 代码示例2. 核心代码2.1 AbstractBeanFactory#doGetBean()2.2 DefaultSingletonBeanRegistry#getSingleton(String beanName)2.3 回到2.1步，DefaultSingletonBeanRegistry#getSingleton(String beanName, ObjectFactory<?> singletonFactory)2.4 AbstractAutowireCapableBeanFactory#doCreateBean()2.5 B类执行doGetBean()2.6 流程2.7 缓存 3. 二级缓存的作用4. 不支持有参构造函数5. 不支持多例总结

1. 代码示例

A.java

B.java

2. 核心代码

这里直接看循环依赖相关的核心方法

2.1 AbstractBeanFactory#doGetBean()

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { final String beanName = transformedBeanName(name); Object bean; // 1.从缓存中拿实例 // Eagerly check singleton cache for manually registered singletons. Object sharedInstance = getSingleton(beanName); // 2.如果缓存里面能拿到实例 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 + "'"); } } // 3.该方法是FactoryBean接口的调用入口 bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // 4.如果singletonObjects缓存里面没有，则走下来 // Fail if we're already creating this bean instance: // We're assumably within a circular reference. //如果是scope 是Prototype的，校验是否有出现循环依赖，如果有则直接报错 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory. BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } else if (args != null) { // Delegation to parent with explicit args. return (T) parentBeanFactory.getBean(nameToLookup, args); } else if (requiredType != null) { // No args -> delegate to standard getBean method. return parentBeanFactory.getBean(nameToLookup, requiredType); } else { return (T) parentBeanFactory.getBean(nameToLookup); } } if (!typeCheckOnly) { markBeanAsCreated(beanName); } try { //父子BeanDefinition合并 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); checkMergedBeanDefinition(mbd, beanName, args); //获取依赖对象属性，依赖对象要先实例化 // Guarantee initialization of beans that the current bean depends on. String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } registerDependentBean(dep, beanName); try { //实例化 getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } // 5.着重看，大部分是单例的情况 // Create bean instance. 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; } }); // 6.该方法是FactoryBean接口的调用入口 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { // It's a prototype -> create a new instance. Object prototypeInstance = null; try { beforePrototypeCreation(beanName); prototypeInstance = createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { String scopeName = mbd.getScope(); final Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { Object scopedInstance = scope.get(beanName, () -> { beforePrototypeCreation(beanName); try { return createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } }); bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException ex) { throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider " + "defining a scoped proxy for this bean if you intend to refer to it from a singleton", ex); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } } // Check if required type matches the type of the actual bean instance. if (requiredType != null && !requiredType.isInstance(bean)) { try { T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType); if (convertedBean == null) { throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } return convertedBean; } catch (TypeMismatchException ex) { if (logger.isTraceEnabled()) { logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex); } throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } } return (T) bean; }

2.2 DefaultSingletonBeanRegistry#getSingleton(String beanName)

先从一级缓存拿，A第一次进来肯定拿不到，再从二级缓存中拿，二级缓存这时候也没有，就会从三级缓存中拿到对象工厂，还是nul，返回空对象singletonObject。 protected Object getSingleton(String beanName, boolean allowEarlyReference) { //根据beanName从缓存中拿实例 //先从一级缓存拿 Object singletonObject = this.singletonObjects.get(beanName); //如果bean还正在创建，还没创建完成，其实就是堆内存有了，属性还没有DI依赖注入 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { synchronized (this.singletonObjects) { //从二级缓存中拿 singletonObject = this.earlySingletonObjects.get(beanName); //如果还拿不到，并且允许bean提前暴露 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; }

2.3 回到2.1步，DefaultSingletonBeanRegistry#getSingleton(String beanName, ObjectFactory<?> singletonFactory)

缓存里都拿不到A的实例，就会走到这个getSingleton()方法；

createBean(beanName, mbd, args)这个方法会创建一个A的实例，通过这个ObjectFactory对象的getObject()方法就可以得到这个创建出来的A的实例；

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 + "'"); } //把beanName添加到singletonsCurrentlyInCreation Set容器中，在这个集合里面的bean都是正在实例化的bean beforeSingletonCreation(beanName); boolean newSingleton = false; boolean recordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { this.suppressedExceptions = new LinkedHashSet<>(); } try { //如果这里有返回值，就代表这个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) { System.out.println("====beanName==" + beanName + "===instance end===="); //创建对象成功时，把对象缓存到singletonObjects缓存中,bean创建完成时放入一级缓存 addSingleton(beanName, singletonObject); } } return singletonObject; } } 把beanName添加到singletonsCurrentlyInCreation Set容器中，在这个集合里面的bean都是正在实例化的bean

这里会调到外部那个lamdba表达式，匿名类中createBean方法，该方法会创建完一个实例并返回，如果这里有返回值，就代表这个bean已经结束创建了，已经完全创建成功

A实例已经通过createBean()方法创建成功，则从正在实例化的bean的缓存singletonsCurrentlyInCreation中移除

A创建成功后，把A缓存到一级缓存singletonObjects中，后面会再次提到这个结论

//一级缓存添加 this.singletonObjects.put(beanName, singletonObject); //三级缓存删除 this.singletonFactories.remove(beanName); //二级缓存删除 this.earlySingletonObjects.remove(beanName);

2.4 AbstractAutowireCapableBeanFactory#doCreateBean()

进入createBean的核心代码

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { //创建实例,,重点看，重要程度：5 instanceWrapper = createBeanInstance(beanName, mbd, args); } final Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // Allow post-processors to modify the merged bean definition. synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { //CommonAnnotationBeanPostProcessor 支持了@PostConstruct，@PreDestroy,@Resource注解 //AutowiredAnnotationBeanPostProcessor 支持 @Autowired,@Value注解 //BeanPostProcessor接口的典型运用，这里要理解这个接口 //对类中注解的装配过程 //重要程度5，必须看 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } } // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. //是否 单例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"); } //这里着重理解，对理解循环依赖帮助非常大，重要程度 5 添加三级缓存 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject = bean; try { //ioc di，依赖注入的核心方法，该方法必须看，重要程度：5 populateBean(beanName, mbd, instanceWrapper); //bean 实例化+ioc依赖注入完以后的调用，非常重要，重要程度：5 exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); } } if (earlySingletonExposure) { Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example."); } } } } // Register bean as disposable. try { //注册bean销毁时的类DisposableBeanAdapter registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; } 实例创建成功

earlySingletonExposure是true，走下面的代码，添加三级缓存

只有A创建成功后，把A缓存到一级缓存singletonObjects中，所以这时候singletonObjects里拿不到A，会进入if，添加匿名类和beanName的对应关系到三级缓存。 //添加匿名类和beanName的对应关系到三级缓存 this.singletonFactories.put(beanName, singletonFactory); //从二级缓存删除 this.earlySingletonObjects.remove(beanName); 这个匿名类就是A这个bean，只是这个bean没有属性，因为还没有执行到ioc依赖注入的方法populateBean()

getEarlyBeanReference(beanName, mbd, bean)，循环所有SmartInstantiationAwareBeanPostProcessor类型的BeanPostProcessor类，返回bean

这个方法只是把你传进来的bean又返回给你了，什么都没做

三级缓存设置成功，走到ioc依赖注入方法，populateBean()

因为A类中依赖注入了B，所以会触发B的doGetBean() 方法，B开始从2.1步开始走一遍流程；这个时候的A的实例化还没有完成，停留在populateBean()方法，等待B去实例化。

2.5 B类执行doGetBean()

按照2.1步到2.4步执行代码，过程和A一模一样；走到2.4步的ioc依赖注入的populateBean()方法，触发A的doGetBean()；这时是A的第二次doGetBean()，在执行到2.2步getSingleton(String beanName)方法时

三级缓存内可以拿到A，把A放入二级缓存，再从三级缓存中删除

这里A中的B是一个半成品，因为B的属性还没有注入

sharedInstance!=null，进入if，得到bean

代码不会进入else，直接走到最后一行，return A对象

A实例化完成，afterSingletonCreation()把beanName从singletonsCurrentlyInCreation中删除，addSingleton()添加一级缓存。 经过2轮doGetBean()，A中的B，B中的A都是实例化完成的Bean。

循环依赖过程结束。

2.6 流程

A实例化开始 调用A的无参构造函数 设置三级缓存A类对应的匿名对象 A类触发B的doGetBean()

B实例化开始 调用B的无参构造函数 设置三级缓存B类对应的匿名对象 B类触发A的doGetBean()

A实例化开始 从三级缓存中拿到A对应的匿名对象（这时后A中的B是还没有属性赋值的半成品）

B实例化结束 A实例化结束

2.7 缓存

A第一次执行doGetBean，addSingletonFactory() //添加到三级缓存 this.singletonFactories.put(beanName, singletonFactory); //从二级缓存删除 this.earlySingletonObjects.remove(beanName);

A第二次执行doGetBean，getSingleton() //添加到二级缓存 this.earlySingletonObjects.put(beanName, singletonObject); //从三级缓存删除 this.singletonFactories.remove(beanName);

A创建后addSingleton() //一级缓存添加 this.singletonObjects.put(beanName, singletonObject); //三级缓存删除 this.singletonFactories.remove(beanName); //二级缓存删除 this.earlySingletonObjects.remove(beanName);

最后所有的bean都会存在一级缓存中

3. 二级缓存的作用

提交获取singletonObject的效率添加一个C类

A同时依赖B和C

B把A从三级缓存升级到二级缓存，当C再执行getSingleton(String beanName, boolean allowEarlyReference)时，可以直接从二级缓存中拿到A，不需要走三级缓存。

如果没有二级缓存，只有三级缓存，每次拿A都需要去循环所有BeanPostProcessor的类，来获取A。

4. 不支持有参构造函数

createBeanInstance(beanName, mbd, args)中，如果有@Autowired注解的有参构造函数，如果函数是一个引用类型，就会触发这个引用类型的getBean操作

还没有走到添加三级缓存的代码，就提前doGetBean()了

所以在A第二次执行doGetBean()时，getSingleton(beanName)返回null，因为三级缓存里没有添加A

代码和第一次进来一样，又会执行到这个getSingleton()

又执行到beforeSingletonCreation(beanName)

又往singletonsCurrentlyInCreation内添加一次A，因为里面已经有A了，所以会返回false，进入if，抛出异常，所以有参构造函数不支持循环依赖。singletonsCurrentlyInCreation可以用来阻断非属性方式和非单例情况下的循环依赖。

有参构造函数参数没有值，对象是不能创建成功；A要实例化，但是入参B没有属性，A不能实例化成功；B的实例化又要依靠A，A的属性也不完整，B也不能实例化成功，所以会出现死锁。

5. 不支持多例

只有属性方式而且是单例的依赖注入才能循环依赖

总结

第一个getSingleton 根据beanName先从一级缓存拿，如果拿不到，而且是正在实例化的 bean，就从二级缓存中拿如果二级缓存也拿不到，并且允许bean提前暴露，从三级缓存中拿到对象工厂如果对象工厂不为空，获取对象，放到二级缓存，删除三级缓存最后就是缓存中有对象就返回，没有就返回空对象 第二个getSingleton 缓存中没有，加入到singletonsCurrentlyInCreation正在实例化的 bean的集合中创建bean（通过推断构造方法反射调用创建bean）如果是单例的，允许循环依赖，是正在实例化的bean，addSingletonFactory就把这个正在实例化但是还没有属性的bean添加到三级缓存singletonFactories，从二级缓存删除（因为还没有执行到ioc依赖注入的方法populateBean）三级缓存设置成功，走到ioc依赖注入方法，populateBean()，触发B的doGetBean()方法，等待B去实例化B也会执行到populateBean()方法，触发A的doGetBean()，第二次执行第一个getSingleton(String beanName)方法，这时候三级缓存内可以拿到A，把A放入二级缓存，再从三级缓存中删除这里A中的B是一个半成品，因为B的属性还没有注入，最后B会通过InjectionMetadata对象inject方法完成属性和方法的注入bean创建完成后singletonsCurrentlyInCreation要删除该bean，添加一级缓存，三级和二级缓存删除