Dagger 2 子组件与组件依赖关系

Question

Dagger 1 的 plus() 方法是我在以前的应用程序中经常使用的方法，因此我理解您可能希望子组件能够完全访问父图绑定(bind)的情况。

在什么情况下使用组件依赖项而不是子组件依赖项会更有好处？为什么？

Answer 1

组件依赖关系 - 当您想要保持两个组件独立时使用此选项。

子组件 - 当您想要保持两个组件耦合时使用此组件。

<小时/>

我将使用下面的示例来解释组件依赖项和子组件。该示例中值得注意的一些要点是:

• SomeClassA1 可以在没有任何依赖的情况下创建。 ModuleA 通过 provideSomeClassA1() 方法提供 SomeClassA1 的实例。
如果没有 SomeClassA1，则无法创建
• SomeClassB1。仅当 SomeClassA1 的实例作为参数传递给 provideSomeClassB1() 时，ModuleB 才能提供 SomeClassB1 的实例方法。

@Module
public class ModuleA {
    @Provides
    public SomeClassA1 provideSomeClassA1() {
        return new SomeClassA1();
    }
}

@Module
public class ModuleB {
    @Provides
    public SomeClassB1 provideSomeClassB1(SomeClassA1 someClassA1) {
        return new SomeClassB1(someClassA1);
    }
}

public class SomeClassA1 {
    public SomeClassA1() {}
}

public class SomeClassB1 {
    private SomeClassA1 someClassA1;

    public SomeClassB1(SomeClassA1 someClassA1) {
        this.someClassA1 = someClassA1;
    }
}

每当组件/子组件声明时，Dagger 都会将 SomeClassA1 的实例作为参数传递给 ModuleB 上的 provideSomeClassB1() 方法ModuleB 已初始化。我们需要指示 Dagger 如何实现依赖关系。这可以通过使用组件依赖或子组件来完成。

组件依赖

请注意下面的组件依赖关系示例中的以下几点:

• ComponentB 必须通过 @Component 注释上的 dependencies 方法定义依赖关系。
• ComponentA 不需要声明 ModuleB。这使两个组件保持独立。

public class ComponentDependency {
    @Component(modules = ModuleA.class)
    public interface ComponentA {
        SomeClassA1 someClassA1();
    }

    @Component(modules = ModuleB.class, dependencies = ComponentA.class)
    public interface ComponentB {
        SomeClassB1 someClassB1();
    }

    public static void main(String[] args) {
        ModuleA moduleA = new ModuleA();
        ComponentA componentA = DaggerComponentDependency_ComponentA.builder()
                .moduleA(moduleA)
                .build();

        ModuleB moduleB = new ModuleB();
        ComponentB componentB = DaggerComponentDependency_ComponentB.builder()
                .moduleB(moduleB)
                .componentA(componentA)
                .build();
    }
}

子组件

请注意 SubComponent 示例中的以下几点:

• 由于ComponentB尚未定义对ModuleA的依赖，因此它无法独立存在。它依赖于提供 ModuleA 的组件。因此它有一个 @Subcomponent 注释。
• ComponentA 已通过接口(interface)方法 componentB() 声明了 ModuleB。这使得两个组件耦合。事实上，ComponentB只能通过ComponentA来初始化。

public class SubComponent {
    @Component(modules = ModuleA.class)
    public interface ComponentA {
        ComponentB componentB(ModuleB moduleB);
    }

    @Subcomponent(modules = ModuleB.class)
    public interface ComponentB {
        SomeClassB1 someClassB1();
    }

    public static void main(String[] args) {
        ModuleA moduleA = new ModuleA();
        ComponentA componentA = DaggerSubComponent_ComponentA.builder()
                .moduleA(moduleA)
                .build();

        ModuleB moduleB = new ModuleB();
        ComponentB componentB = componentA.componentB(moduleB);
    }
}