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

Dagger 1的plus()方法是我在前面的应用程序中经常使用的东西，所以我理解你可能希望有一个子组件可以完全访问父图形绑定的情况。

在什么情况下使用组件依赖性而不是子组件依赖性是有益的，为什么？

组件依赖关系 – 在以下情况下使用：

>你想保持两个组件独立。
>您想要显式地显示一个组件的依赖关系被另一个组件使用

子组件 – 在以下情况下使用：

>你想保持两个组件的粘性
>你可能不在乎显式地显示一个组件的依赖关系被另一个组件使用

我将尝试显示这个和示例。假设我们有下面的模块和类。 SomeClassB1依赖于SomeClassA1。注意ModuleB中的provideSomeClassB1方法显示了这个依赖。

@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;
    }
}

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

> SomeClassB1依赖于SomeClassA1。 ComponentB必须显式定义依赖关系。
> 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示例中的以下几点：

> SomeClassB1依赖于SomeClassA1。 ComponentB不需要显式定义依赖性。
> ComponentA必须声明ModuleB。这使得两个组件耦合。

public class SubComponent {
    @Component(modules = {ModuleA.class,ModuleB.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();
        ModuleB moduleB = new ModuleB();
        ComponentA componentA = DaggerSubComponent_ComponentA.builder()
                .moduleA(moduleA)
                .moduleB(moduleB)
                .build();

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

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

猜你在找的设计模式相关文章