Dagger 2 sottocomponenti contro le dipendenze dei componenti

Question

Il metodo plus() di Dagger 1 è stato utilizzato molto spesso nelle applicazioni precedenti, quindi capisco le situazioni in cui si potrebbe desiderare di avere un sottocomponente con accesso completo ai collegamenti dei grafici padre.

In quale situazione sarebbe vantaggioso utilizzare un componente dipendenza invece di una dipendenza sottocomponente e perché?

Answer 1

componenti Dipendenze - Utilizzare questo quando:

• si desidera mantenere due componenti indipendenti.
• si vuole mostrare in modo esplicito ciò che dipendenze da un componente viene utilizzato dagli altri

sottocomponenti - Utilizzare questa funzione quando:

• si desidera mantenere due componenti coesa
• si potrebbe non cura per mostrare esplicitamente quale dipendenza da un componente viene utilizzata dall'altro

Proverò a mostrare questo e l'esempio. Dato che abbiamo i seguenti moduli e classi.SomeClassB1 dipende da SomeClassA1. Notare il metodo provideSomeClassB1 in ModuleB che mostra questa dipendenza.

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

Nota i seguenti punti nell'esempio Dipendenza Componente seguito:

• SomeClassB1 dipende SomeClassA1. ComponentB deve definire esplicitamente la dipendenza.
• ComponentA non ha bisogno di dichiarare ModuleB. Ciò mantiene indipendenti le due componenti.

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

Nota i seguenti punti nell'esempio Sottocomponente:

• SomeClassB1 dipende SomeClassA1. ComponentB non è necessario definire esplicitamente la dipendenza.
• ComponentA deve dichiarare ModuleB. Questo rende accoppiati i due componenti.

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

Answer 2

Secondo il documentation:

Component Dependency permette di accedere solo alle legature esposte come modalità di erogazione attraverso le dipendenze dei componenti, vale a dire si ha accesso a solo i tipi che sono dichiarate nel genitore Component.

Submodules ti dà l'accesso a tutta la grafico vincolante dal suo genitore, quando viene dichiarato, vale a dire si dispone di un accesso a tutti gli oggetti dichiarati nelle sue Module s.

Diciamo, si dispone di un ApplicationComponent contenente tutte Android roba correlata (LocationService, Resources, SharedPreference, ecc). Vuoi anche avere il tuo DataComponent dove gestisci le cose per la persistenza insieme a WebService per gestire le API. L'unica cosa che ti manca in DataComponent è Application Context che risiede in ApplicationComponent. Il modo più semplice per ottenereda DataComponent è una dipendenza da ApplicationComponent. Devi essere sicuro di avere un 012 esplicitamente dichiarato in ApplicationComponent perché hai solo accesso ai contenuti dichiarati. In questo caso, non c'è lavoro manuale, il che significa che non è necessario specificare Submodules nel genitore Component ed esplicitamente aggiungere il modulo ad un modulo genitore come:

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

Ora considerare che caso in cui si desidera iniettare WebService da DataComponent e LocationService da ApplicationComponent a Fragment che si lega utilizzando la funzione @Submoduleplus in alto. La cosa interessante è che il componente a cui si sta legando (ApplicationComponent) non è non, non è necessario esporre WebService né LocationService perché si ha accesso all'intero grafico subito.