1. 什么是循环依赖（常问）？

循环依赖（Cyclic Dependency）是指在软件系统中，两个或多个模块（类、组件、服务等）相互依赖，形成了一个闭环。例如，模块 A 依赖于模块 B，而模块 B 又依赖于模块 A，这就形成了循环依赖。循环依赖通常会导致系统的复杂性增加，甚至可能引发运行时错误或死锁等问题。

1. 循环依赖的常见场景

循环依赖可以在多个层面上出现，以下是几个常见的场景：

1.1 类之间的循环依赖

在面向对象编程中，类 A 依赖类 B，而类 B 又依赖类 A。例如：

class ClassA {
    private ClassB b;

    public ClassA(ClassB b) {
        this.b = b;
    }

    public void doSomething() {
        b.someMethod();
    }
}

class ClassB {
    private ClassA a;

    public ClassB(ClassA a) {
        this.a = a;
    }

    public void someMethod() {
        a.doSomething();
    }
}

在这种情况下，ClassA 和 ClassB 相互依赖，形成了循环依赖。

1.2 组件或模块之间的循环依赖

在大型系统中，组件或模块之间也可能形成循环依赖。例如，模块 A 使用模块 B 提供的功能，而模块 B 又依赖模块 A 的某些服务。

1.3 依赖注入框架中的循环依赖

在依赖注入框架（如 Spring）中，如果两个 Bean 之间存在相互依赖，则会导致循环依赖问题。例如：

@Component
class ServiceA {
    @Autowired
    private ServiceB serviceB;
}

@Component
class ServiceB {
    @Autowired
    private ServiceA serviceA;
}

在这个例子中，ServiceA 和 ServiceB 之间存在相互依赖，当 Spring 尝试自动注入这些 Bean 时，就会导致循环依赖的问题。

2. 循环依赖的影响

• 编译问题：在某些编程语言中，循环依赖可能导致编译错误，因为编译器无法确定类或模块之间的依赖关系。
• 运行时问题：在运行时，循环依赖可能导致堆栈溢出、死锁、无限递归等问题。
• 设计复杂性：循环依赖会增加系统的复杂性，使代码难以理解和维护。

3. 解决循环依赖的方法

3.1 重新设计类或模块的职责

• 解耦合：重新设计类或模块的职责，消除相互之间的直接依赖。例如，将共同依赖的功能提取到一个独立的模块中。
• 依赖倒置原则：使用接口或抽象类，使得高层模块不依赖于低层模块，而是依赖于抽象。

3.2 使用依赖注入框架的延迟注入

在依赖注入框架中，可以使用延迟注入（Lazy Initialization）或构造函数注入来解决循环依赖问题。例如，使用 Spring 的 @Lazy 注解：

@Component
class ServiceA {
    private final ServiceB serviceB;

    @Autowired
    public ServiceA(@Lazy ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

@Component
class ServiceB {
    private final ServiceA serviceA;

    @Autowired
    public ServiceB(@Lazy ServiceA serviceA) {
        this.serviceA = serviceA;
    }
}

3.3 使用设计模式

• 中介者模式：引入中介者来管理类之间的交互，避免直接相互依赖。
• 观察者模式：用观察者模式来通知对象之间的变化，而不是直接相互依赖。

4. 总结

循环依赖是一种常见的设计问题，可能导致系统的复杂性增加，甚至引发编译和运行时问题。通过重构代码、使用设计模式、或者依赖注入的延迟注入技术，可以有效地避免和解决循环依赖问题，从而提高代码的可维护性和系统的健壮性。