Dagger 2 подкомпоненты vs зависимости компонентов

зависимости компонентов-используйте это, когда:

• вы хотите сохранить два независимых компонента.
• вы хотите явно показать, какие зависимости от одного компонента используются другим

Подкомпоненты-используйте это, когда:

• вы хотите сохранить два компонента сплоченными
• вы не можете явно показать, какие зависимости от одного компонента используются другое

я постараюсь показать это на примере. Учитывая, что у нас есть следующие модули и классы. SomeClassB1 зависит от SomeClassA1. Обратите внимание на provideSomeClassB1 метод ModuleB, который показывает эту зависимость.

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

обратите внимание на следующие моменты в Примере Подкомпонента:

• SomeClassB1 зависит от SomeClassA1. ComponentB не нужно явно определять зависимость.
• ComponentA признает ModuleB. Это делает два компонента связанными.

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