Java中如何最优重构需引用待构建类的成员变量实例化构造函数？

这是个很典型的循环依赖+依赖注入场景问题，我来给你拆解下最优的重构思路和方案，核心是既要满足依赖注入的测试需求，又要处理Bar需要引用当前Foo实例的特殊情况：

1. 优先推荐：用抽象接口打破循环依赖 #

如果Bar只需要调用Foo的部分方法，最符合SOLID设计原则的做法是定义抽象接口，让Foo实现这个接口，然后Bar依赖接口而非具体的Foo类。这不仅解决了循环依赖，还大幅降低了类之间的耦合度。

示例代码：

// 定义Foo对外暴露的操作接口，只保留Bar需要的方法
interface FooOperations {
    void processBusinessData();
}

// Bar现在依赖抽象接口，而非具体的Foo类
class Bar {
    private final FooOperations fooOps;

    // 构造函数注入依赖，完美支持依赖注入规范
    public Bar(FooOperations fooOps) {
        this.fooOps = fooOps;
    }

    public void executeBarTask() {
        // 调用接口方法，无需关心具体实现
        fooOps.processBusinessData();
    }
}

final class Foo implements FooOperations {
    private final Bar bar;

    // 构造函数注入Bar，完全符合依赖注入要求
    public Foo(Bar bar) {
        this.bar = bar;
    }

    @Override
    public void processBusinessData() {
        // Foo自身的核心业务逻辑
    }

    // 静态工厂方法封装实例创建细节（处理循环依赖的逻辑）
    public static Foo create() {
        // 用数组持有Foo实例，因为lambda需要引用final变量
        final Foo[] fooHolder = new Foo[1];
        // 创建Bar时传入Supplier，延迟获取Foo实例
        Bar bar = new Bar(() -> fooHolder[0]);
        // 实例化Foo并赋值给holder
        fooHolder[0] = new Foo(bar);
        return fooHolder[0];
    }
}

这种方案的测试友好性拉满：

• 测试Foo时，可以直接注入Mock的Bar，无需关心Bar和Foo的关联逻辑
• 测试Bar时，可以注入Mock的FooOperations，完全隔离Foo的具体实现

2. 保留直接依赖：用Supplier延迟解决循环依赖 #

如果因为业务限制，Bar必须直接依赖Foo类，那可以用Supplier<Foo>来延迟获取Foo实例，避免构造函数层面的循环依赖。

示例代码：

class Bar {
    private final Supplier<Foo> fooSupplier;

    // 注入Supplier而非直接的Foo，延迟获取实例
    public Bar(Supplier<Foo> fooSupplier) {
        this.fooSupplier = fooSupplier;
    }

    public void executeBarTask() {
        // 需要Foo时再通过Supplier获取
        Foo foo = fooSupplier.get();
        foo.invokeFooMethod();
    }
}

final class Foo {
    private final Bar bar;

    // 构造函数注入Bar，符合依赖注入规范
    public Foo(Bar bar) {
        this.bar = bar;
    }

    public static Foo create() {
        final Foo[] fooHolder = new Foo[1];
        // 创建Bar时传入指向当前Foo的Supplier
        Bar bar = new Bar(() -> fooHolder[0]);
        fooHolder[0] = new Foo(bar);
        return fooHolder[0];
    }
}

测试时的用法（以Mockito为例）：

// 测试Foo的方法
@Test
void testFooInvokeBar() {
    Bar mockBar = Mockito.mock(Bar.class);
    Foo foo = new Foo(mockBar);
    foo.triggerBarTask();
    Mockito.verify(mockBar).executeBarTask();
}

// 测试Bar的方法
@Test
void testBarInvokeFoo() {
    Foo mockFoo = Mockito.mock(Foo.class);
    Bar bar = new Bar(() -> mockFoo);
    bar.executeBarTask();
    Mockito.verify(mockFoo).invokeFooMethod();
}

3. 特殊场景参考：构造函数参数验证+外部工厂 #

如果你希望完全由外部控制依赖注入，但又要保证Bar引用的是当前Foo实例，可以在Foo的构造函数里添加验证逻辑，同时用外部工厂处理实例创建：

final class Foo {
    private final Bar bar;

    public Foo(Bar bar) {
        this.bar = bar;
        // 验证Bar关联的Foo是否是当前实例，避免传入错误的依赖
        if (bar.getAssociatedFoo() != this) {
            throw new IllegalArgumentException("Bar must reference this Foo instance");
        }
    }
}

// 外部工厂类负责创建关联的Foo和Bar
public class FooFactory {
    public static Foo createFoo() {
        final Foo[] fooHolder = new Foo[1];
        Bar bar = new Bar(() -> fooHolder[0]);
        fooHolder[0] = new Foo(bar);
        return fooHolder[0];
    }
}

关键注意事项 #

• 保持不可变性：尽量让Foo和Bar的成员变量为final，保证线程安全和实例状态稳定
• 避免setter注入：setter会破坏不可变性，且容易导致实例处于未完全初始化的状态
• 审视循环依赖：循环依赖往往是职责划分不清晰的信号，如果可以，尝试拆分Foo和Bar的共同功能到独立类，从根源消除循环

内容的提问来源于stack exchange，提问作者Johannes