Субкомпоненты Dagger 2 против зависимостей компонентов

plus()Метод Dagger 1 я часто использовал в предыдущих приложениях, поэтому я понимаю ситуации, когда вам может понадобиться субкомпонент с полным доступом к привязкам родительских графов.

В какой ситуации было бы полезно использовать компонентную зависимость вместо субкомпонентной зависимости и почему?

Зависимости компонентов - используйте этот параметр, если хотите сохранить независимость двух компонентов.

Субкомпоненты - используйте это, если вы хотите соединить два компонента.

Я буду использовать приведенный ниже пример для объяснения зависимостей компонентов и подкомпонентов . Вот некоторые моменты, на которые стоит обратить внимание:

• SomeClassA1может быть создан без какой-либо зависимости. ModuleAпредоставляет и экземпляр SomeClassA1через provideSomeClassA1()метод.
• SomeClassB1не может быть создан без SomeClassA1. ModuleBможет предоставить экземпляр, SomeClassB1только если экземпляр SomeClassA1передается в качестве аргумента 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;
    }
}

Dagger позаботится о передаче экземпляра SomeClassA1в качестве аргумента provideSomeClassB1()методу при ModuleBкаждой ModuleBинициализации объявления компонента / субкомпонента . Нам нужно проинструктировать Кинжал, как выполнить зависимость. Это можно сделать с помощью зависимости компонента или субкомпонента .

Компонентная зависимость

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

• 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:

• Поскольку 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);
    }
}

Согласно документации :

Component Dependencyдает вам доступ только к привязкам, предоставляемым в качестве методов предоставления через зависимости компонентов, т.е. у вас есть доступ только к тем типам, которые объявлены в parent Component.

SubComponentдает вам доступ ко всему графу связывания от его родителя, когда он объявлен, т.е. у вас есть доступ ко всем объектам, объявленным в его Modules.

Скажем, у вас есть , ApplicationComponentсодержащее все Androidродственное вещество ( LocationService, Resources, SharedPreferenceи т.д.). Вы также хотите, чтобы DataComponentвы постоянно управляли вещами, а также имели WebServiceдело с API. Единственное, чего тебе не хватаетDataComponent это Application Contextчто находится в ApplicationComponent. Самый простой способ получить Contextот DataComponent- это зависимость ApplicationComponent. Вы должны быть уверены, что у вас есть Contextявное объявление, ApplicationComponentпотому что у вас есть доступ только к объявленным вещам. В этом случае нет ручной работы, то есть вам не нужно указывать Submodulesв parent Componentи явно добавлять свой подмодуль в родительский модуль, например:

MySubcomponent mySubcomponent = myComponent.plus(new ChildGraphModule("child!")); // No need!

Теперь рассмотрим тот случай, когда вы хотите ввести WebServiceиз DataComponentи LocationServiceиз ApplicationComponentв ваш, Fragmentкоторый связывает с помощью@Submodule plus функции выше. Крутая вещь здесь заключается в том, что компонент, к которому вы привязываете ( ApplicationComponent), не нужно раскрывать WebServiceни LocationServiceпотому, что у вас есть доступ ко всему графику сразу.

Вот пример кода со скриншотом для лучшего понимания Компонента и Подкомпонента:

Составная часть:

1. AppComponent содержит две декларации.
2. AppComponent инициализируется в классе App.
3. HomeActivityComponent зависит от AppComponent.
4. В HomeActivity по инициализации DaggerHomeActivityComponent я даю объект AppComponent в виде композиции.

подкомпоненте:

1. AppComponent содержит субкомпонент или субкомпоненты.
2. AppComponent инициализируется в классе App.
3. Субкомпонент не знает о своем ParentComponent. Это только обеспечивает свои собственные зависимости, включая модуль.
4. В HomeActivity я внедряю субкомпонент, используя его родительский компонент.

И наглядная схема:

Источник: ссылка

Еще одна вещь, которую я до сих пор не осознавал, это то, что:

• @SubcomponentЭкземпляр имеет ровно один родительский компонент (хотя различные компоненты могут создать экземпляр в том же @Subcomponentи быть родителем этого экземпляра)
• A @Componentможет иметь ноль, один или несколько «родительских» компонентов, объявленных через зависимости компонентов