Question

我有两个类，Foo<T>和Bar，它们相互依赖，以及其他各种类。我使用Dagger-2进行依赖注入，但如果我天真地添加循环依赖，Dagger会在运行时遇到堆栈溢出。什么是重构类来解决这个问题的好方法，同时仍然使用Dagger注入所有其他依赖项，并且对现有调用的重复和更改最少？

Answer 1

简单的方法是在一边使用Lazy<T>。

Lazy<Foo> foo;

@Inject
Bar(Lazy<Foo> foo) {
    this.foo = foo;
}

// use foo.get(); when needed

Answer 2

经过过多的思考和与同事的谈话后，我们最终做了以下事情：

class Foo<T> extends FooWithoutDep<T> {
    @Inject Foo(Bar bar, OtherDep1 dep1, OtherDep2 dep2) {
        super(dep1, dep2);
        setBarDep(bar);
    }
}

class FooWithoutDep<T> {
    //Field declarations elided
    @Inject FooWithoutDep(OtherDep1 dep1, OtherDep2 dep2) {
        //Normal constructor stuff
    }
    void setBarDep(Bar bar) { this.bar = bar; }

    //The rest of the actual logic
}

class Bar {
    //Field declarations elided
    @Inject Bar(FooWithoutDep<Thing> foo, OtherDep3 dep3) {
        this.foo = foo;
        this.foo.setBarDep(this);
        this.dep3 = dep3;
    }

    //Code that uses Foo and the other dependencies
}

解释这一点 - 我们将Foo的实际逻辑移动到父类（FooWithoutDep）中，它将循环依赖作为可设置字段而不是构造函数参数。然后原始类只包含一个构造函数，该构造函数接受循环依赖并调用setter。另一个类Bar依赖于父类（FooWithoutDep），并显式调用setter，传递自己（this）。这使得对类的所有现有引用保持不变，同时仍然使用Dagger注入所有依赖项。

这似乎令人困惑，值得在这里写一下。

Answer 3

这是我没有父类的情况下解决的方法。

第1类：引擎。（在组件界面中） @提供 public Engine myEngine（Context context）{ 返回新引擎（上下文）； }

第2类：零件。引擎还需要Parts实例，但是创建会延迟。

@Inject
public Parts(Context context, Engine engine) {
    this.context = context;
    this.engine= engine;
    engine.setParts(this);
}

可以实现循环依赖，但是必须先启动一个类，然后再发起另一个类。

如果可能的话，再次重构代码以避免循环DI。

如何在仍然使用Dagger2的同时解决循环依赖？

3 个答案: