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

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

在什么情况下使用组件依赖代替子组件依赖为什么？

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

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

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

• SomeClassA1可以在没有任何依赖的情况下创建。ModuleA提供和实例SomeClassA1通过provideSomeClassA1() method.
• SomeClassB1没有的话就无法创建SomeClassA1. ModuleB可以提供一个实例SomeClassB1仅当一个实例SomeClassA1作为参数传递给provideSomeClassB1() method.

@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作为一个论点provideSomeClassB1()方法上ModuleB每当组件/子组件声明ModuleB已初始化。我们需要指示 Dagger 如何实现依赖关系。这可以通过使用来完成组件依赖 or 子组件.

组件依赖

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

• ComponentB必须通过以下方式定义依赖关系dependencies方法上@Component注解。
• 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 示例中请注意以下几点：

• As ComponentB尚未定义依赖关系ModuleA，它不能独立生活。它变得依赖于将提供的组件ModuleA。因此它有一个@Subcomponent注解。
• ComponentA已宣布ModuleB通过接口方法componentB()。这使得两个组件耦合。实际上，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);
    }
}