面试官：详细介绍一下Spring的循环依赖

站长

2024年03月19日 18:52 · 阅读数 12

Spring 循环依赖与三级缓存

一、什么是循环依赖

Spring 循环依赖是指：两个不同的 Bean 对象，相互成为各自的字段，当这两个 Bean 中的其中一个 Bean 进行依赖注入时，会陷入死循环，即循环依赖现象。

面试官：详细介绍一下Spring的循环依赖

代码例子：

@Component
public class UserServiceA {
    @Autowire
    private UserServiceB userServiceB;
}

@Component
public class UserServiceB {
    @Autowire
    private UserServiceA userServiceA;
}

UserServiceA 与 UserServiceB 之间相互依赖

二、三级缓存解决循环依赖

2.1 三级缓存

针对循环依赖的现象，Spring 中使用提供了三级缓存解决循环的问题，我们先看 Spring 中使用到三级缓存的代码：

public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {

    /**
     * 一级缓存
     */
    private Map<String, Object> singletonObjects = new ConcurrentHashMap<>();

    /**
     * 二级缓存
     */
    private Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();

    /**
     * 三级缓存
     */
    private Map<String, ObjectFactory<?>> singletonFactory = new HashMap<>();

    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // Quick check for existing instance without full singleton lock
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            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) {
                            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                singletonObject = singletonFactory.getObject();
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }
        return singletonObject;
    }
}

SingletonObjects：一级缓存，存储完整的 Bean；
EarlySingletonObjects：二级缓存，存储从第三级缓存中创建出代理对象的 Bean，即半成品的 Bean；
SingletonFactory：三级缓存，存储实例化完后，包装在 FactoryBean 中的工厂 Bean；

在上面的 getSingleton 方法中，先从 SingletonObjects 中获取完整的 Bean，如果获取失败，就从 EarlySingletonObjects 中获取半成品的 Bean，如果 EarlySingletonObjects 中也没有获取到，那么就从 SingletonFactory 中，通过 FactoryBean 的 getBean 方法，获取提前创建 Bean。如果 SingletonFactory 中也没有获取到，就去执行创建 Bean 的方法。

2.2 解决循环依赖

Spring 产生一个完整的 Bean 可以看作三个阶段：

createBean：实例化 Bean；
populateBean：对 Bean 进行依赖注入；
initializeBean：执行 Bean 的初始化方法；

产生循环依赖的根本原因是：对于一个实例化后的 Bean，当它进行依赖注入时，会去创建它所依赖的 Bean，但此时它本身没有缓存起来，如果其他的 Bean 也依赖于它自己，那么就会创建新的 Bean，陷入了循环依赖的问题。

所以，三级缓存解决循环依赖的根本途径是：当 Bean 实例化后，先将自己存起来，如果其他 Bean 用到自己，就先从缓存中拿，不用去创建新的 Bean 了，也就不会产生循环依赖的问题了。过程如下图所示：

面试官：详细介绍一下Spring的循环依赖

在 Spring 源码中，调用完 createInstance 方法后，然后就把当前 Bean 加入到 SingletonFactory 中，也就是在实例化完毕后，就加入到三级缓存中；

2.3 为什么需要三级缓存？一层和两层可以吗？

2.3.1 一级缓存失效的原因

对于只使用一级缓存的情况，是不能够解决循环依赖的，有下面两个原因：

如果只使用一级缓存，在创建 Bean 的过程中，我们会在初始化完毕（注意是初始化，如果只有一级缓存，该缓存需要存储完整的 Bean）后把 Bean 放入到缓存中。此时依然会产生循环依赖问题，因为依赖注入的过程是在初始化之前的，依赖注入时是从缓存中获取不了对应的 Bean，从而再次引起循环依赖问题。

那如果我们提前在 Bean 实例化后就放入到缓存呢？答案也是不行的。因为我们没有考虑到代理对象（Spring AOP） ，如果我们创建的 Bean 是代理对象，就要在实例化后就要创建出来，那么就会带来新的问题：JDK Proxy 代理对象实现的是目标类的接口，在进行依赖注入时会找不到对应的属性和方法而报错（也就是说，提前创建出来的代理对象是没有原来对象的属性和方法的）。

Spring AOP 是依赖于 AnnotationAwareAspectJAutoProxyCreator 的，这是一个后置处理器，在 Bean 实例化完毕后在初始化方法中才执行的。

2.3.2 不使用二级缓存的原因

先说结论，使用二级缓存是可以的。

对于普通对象来说，使用二级缓存是可以解决循环依赖的。在实例化后把对象存入第一级缓存中，如果其他对象依赖注入该对象，就从第一级缓存中拿就行了。对象初始化完毕后，再写入到第二级缓存中即可。

但是对于代理对象来说，就显得十分麻烦了。如果循环依赖注入的对象是代理对象，我们就需要在对象实例化后提前把代理对象创建出来，即提前创建出所有的代理对象。但是在目前 Spring AOP 的设计来说，代理对象的创建是在初始化方法中的 AnnotationAwareAspectJAutoProxyCreator 后置处理器创建的。这与 Spring AOP 的代理设计原则是相违背的。

所以，Spring 就再引用了一层缓存 SingletonFactory，存储着 FactoryBean，我们来看看代码：

if (beanDefinition.isSingleton()) {
    Object finalBean = bean;
    //加入FactoryBean
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, beanDefinition, finalBean));
}

当我们调用这个 FactoryBean 的 getBean 方法时：

protected Object getEarlyBeanReference(String beanName, BeanDefinition beanDefinition, Object bean) {

    Object exposedObject = bean;
    List<BeanPostProcessor> beanPostProcessors = getBeanPostProcessors();
    for (BeanPostProcessor beanPostProcessor : beanPostProcessors) {
        if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
            exposedObject = ((InstantiationAwareBeanPostProcessor) beanPostProcessor).getEarlyBeanReference(bean, beanName);
            if (exposedObject == null) {
                return exposedObject;
            }
        }
    }
    return exposedObject;
}

// AnnotationAwareAspectJAutoProxyCreator
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
    earlyProxyReferences.add(bean);
    return wrapIfNecessary(bean,beanName);
}

发现它其实通过 InstantiationAwareBeanPostProcessor 接口的 getEarlyBeanReference 来创建代理对象。所以对于代理对象来说，Spring 没有直接提前创建，而是在它产生循环依赖时，再通过 getEarlyBeanReference 方法来创建代理对象的。

三、循环依赖被完全解决了吗

3.1 循环依赖只支持单例对象

对于 scope 为 property 的 Bean，三级缓存是没有解决循环依赖的。因为它们的作用域是原型，每次使用到时都会创建一个新对象，不进缓存！

    @Override
    protected Object createBean(String beanName, BeanDefinition beanDefinition, Object... args) throws BeansException {

    Object bean = null;
    try {
        // 加入一级缓存
        if (beanDefinition.isSingleton()) {
            Object finalBean = bean;
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, beanDefinition, finalBean));
        }

    } catch (Exception e) {
        throw new BeansException("Instantiation of bean failed", e);
    }

    Object exposeObject = bean;
    if (beanDefinition.isSingleton()) {

        // 从二级缓存中获取对象
        exposeObject = getSingleton(beanName);
        registerSingleton(beanName, exposeObject);
    }
    return exposeObject;
}

可见，在加入缓存时，都会判断当前的 Bean 是不是 Singleton 的，如果不是就不加入到缓存中。

3.2 通过构造器注入的类无法解决循环依赖

@Component
public class BeanB {
    private BeanA a;
    public BeanB(BeanA a) {
        this.a = a;
    }
}

@Component
public class BeanA {
    private BeanB b;
    public BeanA(BeanB b) {
        this.b = b;
    }
}

上述代码中，我们通过构造器来注入 BeanA 和 Bean B，Spring 是无法解决它们循环依赖的问题的。

因为在调用 BeanA 的构造器方法时 BeanA 是没有实例化完成的，缓存中不存在 BeanA 对象，此时就要注入 BeanB 对象，毫无疑问的会产生循环依赖的问题。

但是，对于这种情况来说，我们可以通过 @Lazy 注解来延迟 BeanB 的加载。即调用构造器方法时先不创建 BeanB 对象，当使用到BeanB 对象时才继续创建，此时 BeanB 也已经创建完成了，就不会产生循环依赖的问题了。

@Component
public class BeanA {
    private BeanB b;
    public BeanA(@Lazy BeanB b) {
        this.b = b;
    }
}