深度解析：Spring Bean 注入如何优雅应对循环依赖

2023-12-07 18:59:10

Spring Bean 注入与循环依赖的痛点

在 Spring 的 Bean 注入过程中，循环依赖是指 Bean 之间相互依赖，导致注入陷入无限循环。循环依赖会导致 Bean 无法正确实例化，从而引发应用程序启动失败或运行时异常。例如，当 Bean A 依赖 Bean B，而 Bean B 又依赖 Bean A 时，就会形成循环依赖。

Spring 的解决方案：三级缓存

为了解决 Bean 注入中的循环依赖问题，Spring 巧妙地设计了三级缓存机制。三级缓存分为一级缓存、二级缓存和三级缓存。

一级缓存

一级缓存存储着已经实例化的 Bean 对象。当 Spring 遇到一个需要注入的 Bean 时，它首先会检查一级缓存中是否已经存在该 Bean。如果存在，则直接从一级缓存中获取 Bean 对象，从而避免重复实例化。

二级缓存

二级缓存存储着正在被实例化的 Bean 对象。当 Spring 开始实例化一个 Bean 时，它会将该 Bean 放入二级缓存。这样，如果其他 Bean 依赖于正在被实例化的 Bean，则 Spring 可以从二级缓存中获取该 Bean，避免循环依赖。

三级缓存

三级缓存存储着未实例化的 Bean 对象。当 Spring 遇到一个需要注入的 Bean，但该 Bean 还未被实例化时，它会将该 Bean 放入三级缓存。这样，Spring 就可以在实例化其他 Bean 时，检查三级缓存中是否存在该 Bean 的依赖。如果存在，则 Spring 可以从三级缓存中获取该 Bean，避免循环依赖。

懒加载：延迟实例化，避免循环

除了三级缓存，Spring 还巧妙地利用了懒加载机制来解决循环依赖问题。懒加载是指延迟实例化 Bean 对象，直到它们真正被需要时才进行实例化。这样，可以避免在应用程序启动时就实例化所有 Bean，从而降低内存消耗并防止循环依赖的发生。

代理：优雅地处理循环依赖

在某些情况下，即使使用了三级缓存和懒加载，循环依赖仍然可能发生。为了解决这个问题，Spring 采用了代理机制。代理机制是指创建一个代理对象来代替实际的 Bean 对象。当一个 Bean 依赖于另一个 Bean 时，Spring 会创建一个代理对象来代替实际的 Bean 对象。这样，当注入依赖时，Spring 实际上是在注入代理对象，从而避免了循环依赖。

构造器注入和属性注入

Spring 提供了两种 Bean 注入方式：构造器注入和属性注入。构造器注入是指通过 Bean 的构造函数来注入依赖。属性注入是指通过 Bean 的属性来注入依赖。在解决循环依赖时，构造器注入通常优于属性注入。这是因为构造器注入可以在 Bean 实例化时就完成依赖注入，而属性注入需要在 Bean 实例化之后才能完成依赖注入。

循序渐进的示例，清晰解析解决方案

为了更清晰地理解 Spring 如何解决循环依赖问题，我们来看一个循序渐进的示例。

示例一：简单循环依赖

class BeanA {
    private BeanB beanB;
}

class BeanB {
    private BeanA beanA;
}

在这种情况下，BeanA 和 BeanB 相互依赖，形成了循环依赖。Spring 可以通过三级缓存来解决这个问题。当 Spring 实例化 BeanA 时，它会将 BeanA 放入三级缓存。当 Spring 实例化 BeanB 时，它会检查三级缓存中是否存在 BeanA。如果存在，则 Spring 可以从三级缓存中获取 BeanA，从而避免循环依赖。

示例二：复杂循环依赖

class BeanA {
    private BeanB beanB;
    private BeanC beanC;
}

class BeanB {
    private BeanC beanC;
    private BeanA beanA;
}

class BeanC {
    private BeanA beanA;
}

在这种情况下，BeanA、BeanB 和 BeanC 互相依赖，形成了复杂循环依赖。Spring 可以通过三级缓存和懒加载来解决这个问题。当 Spring 实例化 BeanA 时，它会将 BeanA 放入三级缓存。当 Spring 实例化 BeanB 时，它会检查三级缓存中是否存在 BeanA 和 BeanC。如果不存在，则 Spring 会将 BeanB 放入二级缓存，并开始实例化 BeanC。当 Spring 实例化 BeanC 时，它会检查三级缓存中是否存在 BeanA。如果不存在，则 Spring 会将 BeanC 放入二级缓存，并开始实例化 BeanA。这样，Spring 就可以通过三级缓存和懒加载来避免循环依赖。