【Spring】循环依赖

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

循环依赖
- 是什么？
- Spring是如何解决的？
- 源码分析
- 细节

循环依赖

是什么？

简单的来说就是对象a的属性中引用了对象b，对象b的属性中引用了对象c......最后引用到a。

<bean id="a" class="com.zmm.test.A" lazy-init="false"> <property name="b" ref="b"/> </bean><bean id="b" class="com.zmm.test.B" lazy-init="false"> <property name="c" ref="c"/> </bean><bean id="c" class="com.zmm.test.C" lazy-init="false"> <property name="a" ref="a"/> </bean>

Spring是如何解决的？

解决方法

三级缓存（其实二级缓存也能解决，只是看是否使用AOP）

// DefaultSingletonBeanRegistry类下的/** *一级缓存 *用来存放成品bean对象（已经成功实例化与初始化了的） * * Cache of singleton objects: bean name to bean instance. */ private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);/** *三级缓存（AOP的关键，如果不用AOP，二级缓存也能解决循环依赖） * 用来存放早期的bean实例(lambda表达式，一个匿名内部类的形式)，看bean对象是否需要被代理。 * ObjectFactory<?>是一个函数式接口， * * Cache of singleton factories: bean name to ObjectFactory. */ private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);/** *二级缓存 * 用来存放半成品bean对象，已经实例化了的但是未初始化的bean对象 * * Cache of early singleton objects: bean name to bean instance. */ private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

提前暴露

AbstractAutowireCapableBeanFactory类的doCreateBean()方法

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { // ....... // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. // 急于缓存单例，以便即使在诸如BeanFactoryAware之类的生命周期接口触发时也能够解析循环引用。 // 是否是单例的 && 允许循环引用 && 是Singleton当前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"); } // 一个匿名内部类，提前暴露创建的实例bean。可以防止循环引用，尽早的持有对象的引用 // 如果一级缓存中不存在指定的bean，就添加到三级缓存中去，将二级缓存中的移除 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // ........................ // 如果是提前暴露的单例 if (earlySingletonExposure) { // 获取指定名称的已注册的单例模式的Bean对象 Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { // 如果获取到的bean对象不为空 if (exposedObject == bean) { // 如果获取到的Bean对象与当前实例化的Bean对象相同 // 将实例暴露出去，当前实例初始化完成 exposedObject = earlySingletonReference; } // 当前Bean依赖其他Bean，并且当发生循环引用时不允许创建新的实例对象 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); // 获取当前Bean所依赖的其他Bean for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } // ....... } } } // ...... return exposedObject; }

BeanDefinitionValueResolver类下的resolveValueIfNecessary()方法

// 解析属性值，对注入类型进行转换 public Object resolveValueIfNecessary(Object argName, @Nullable Object value) { // 对引用类型的属性进行解析 if (value instanceof RuntimeBeanReference) { RuntimeBeanReference ref = (RuntimeBeanReference) value; // 调用引用类型的解析方法 return resolveReference(argName, ref); } // ......对其他类型的属性的解析 }