2021-04-22发表 zhaommmmomo Code / Spring9 分钟读完 (大约1421个字)0次访问

循环依赖

是什么？

简单的来说就是对象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是如何解决的？

1. 三级缓存（其实二级缓存也能解决，只是看是否使用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);

2.提前暴露

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);
    }
    
    // ......对其他类型的属性的解析
}