记一次Spring循环依赖问题

站长

2023年07月27日 15:44 · 阅读数 14

Spring 循环依赖问题详解

什么是循环依赖

在软件开发中，循环依赖指的是两个或多个对象之间相互依赖，形成了一个循环的依赖关系。这种情况下，如果没有合适的处理方式，就会导致应用程序无法正常启动或运行，甚至出现死循环等问题。

Spring 中的循环依赖问题

在 Spring 中，循环依赖问题通常出现在 Bean 之间的依赖注入过程中。具体来说，它可能表现为以下几种形式：

构造函数注入的循环依赖：当一个 Bean 的构造函数参数中依赖于另一个 Bean，而另一个 Bean 又依赖于第一个 Bean 时，就会出现构造函数注入的循环依赖问题。

public class A {
    private final B b; // 构造函数注入 B
    public A(B b) {
        this.b = b;
    }
}

public class B {
    private final A a; // 构造函数注入 A
    public B(A a) {
        this.a = a;
    }
}

Setter 注入的循环依赖：当一个 Bean 的属性需要注入另一个 Bean，而另一个 Bean 又依赖于该 Bean 时，就会出现 Setter 注入的循环依赖问题。

public class A {
    private B b; // Setter 注入 B
    public void setB(B b) {
        this.b = b;
    }
}

public class B {
    private A a; // Setter 注入 A
    public void setA(A a) {
        this.a = a;
    }
}

Singleton Bean 之间的循环依赖：当多个 Singleton Bean 之间相互依赖时，也可能出现循环依赖问题。

@Service
public class A {
    private final B b; // 构造函数注入 B
    public A(B b) {
        this.b = b;
    }
}

@Service
public class B {
    private final A a; // 构造函数注入 A
    public B(A a) {
        this.a = a;
    }
}

如何解决 Spring 中的循环依赖问题

为了避免循环依赖的发生，我们可以采取以下措施：

使用构造函数注入：使用构造函数注入可以避免 Setter 注入的循环依赖问题，因为这种方式可以保证 Bean 在实例化时已经完成了依赖关系的设置。

public class A {
    private final B b; // 构造函数注入 B
    public A(B b) {
        this.b = b;
    }
}

public class B {
    private final A a; // 构造函数注入 A
    public B(A a) {
        this.a = a;
    }
}

使用 @Lazy 注解：使用 @Lazy 注解可以使 Bean 延迟初始化，从而避免循环依赖问题的发生。但是需要注意的是，这种方式可能会对应用程序的性能产生一定的影响。

@Service
@Lazy
public class A {
    private B b; // Setter 注入 B
    public void setB(B b) {
        this.b = b;
    }
}

@Service
@Lazy
public class B {
    private A a; // Setter 注入 A
    public void setA(A a) {
        this.a = a;
    }
}

另外，Spring 还提供了一些更高级的解决方案，包括：

使用代理：使用代理可以解决 Singleton Bean 之间的循环依赖问题，即使它们都是非懒加载的。具体来说，我们可以使用 Spring AOP 中的 AspectJ 代理或 CGLIB 代理来实现 Bean 之间的代理引用。

@Service
public class A {
    private B b; // Setter 注入 B
    public void setB(B b) {
        this.b = b;
    }
}

public class B {
    private A a; // Setter 注入 A
    public void setA(A a) {
        this.a = a;
    }
}

@Configuration
public class AppConfig {
    @Bean(name="a")
    @Scope(value="singleton", proxyMode=ScopedProxyMode.TARGET_CLASS)
    public A a() {
        return new A();
    }
    
    @Bean(name="b")
    @Scope(value="singleton", proxyMode=ScopedProxyMode.TARGET_CLASS)
    public B b() {
        return new B();
    }
}

在不同的作用域中处理循环依赖：在 Spring 中，我们可以使用不同的作用域来处理循环依赖问题。例如，将 Bean 的作用域设置为 prototype，就可以在每次请求 Bean 时创建一个新的实例，从而避免循环依赖问题。

@Service
@Scope(value="prototype")
public class A {
    private B b; // Setter 注入 B
    public void setB(B b) {
        this.b = b;
    }
}

@Service
@Scope(value="prototype")
public class B {
    private A a; // Setter 注入 A
    public void setA(A a) {
        this.a = a;
    }
}

底层原因

Spring 采用依赖注入的方式来实现组件之间的松耦合，而循环依赖问题是由于组件之间的相互依赖关系导致的。Spring 设计循环依赖问题主要是为了解决组件之间的相互依赖关系，从而实现更加灵活的组件管理和配置。

在 Spring 中，循环依赖问题主要是由于 Bean 的实例化和依赖注入过程中的顺序问题。当一个 Bean 的依赖关系需要另一个 Bean 的实例时，如果这个 Bean 还没有被实例化，就会导致循环依赖问题的发生。

Spring 采用了一些解决方案来解决循环依赖问题。例如，使用构造函数注入可以避免 Setter 注入的循环依赖问题，因为这种方式可以保证 Bean 在实例化时已经完成了依赖关系的设置。使用 @Lazy 注解可以使 Bean 延迟初始化，从而避免循环依赖问题的发生。使用代理可以解决 Singleton Bean 之间的循环依赖问题，即使它们都是非懒加载的。在不同的作用域中处理循环依赖，例如将 Bean 的作用域设置为 prototype，就可以在每次请求 Bean 时创建一个新的实例，从而避免循环依赖问题。

总结和建议

循环依赖是一个常见的问题，特别是在大型的软件系统中。在 Spring 中，循环依赖问题可能会导致应用程序无法正常启动或运行，因此需要采取适当的解决方案来避免或解决这个问题。在实际项目中，我们应该根据具体的情况选择合适的解决方案，从而保证应用程序的稳定性和性能。