Iniezione a più componenti indipendenti

Question

La mia configurazione di pugnale per un progetto Android su cui sto lavorando: Nota: ho fornito tutte le necessarie annotazioni @Component, @Module, @Provides ovunque sia necessario.

MainActivity { 

@Inject A a; 
@Inject B b; 

onCreate(){ 
    ComponentX.inject(this); 
    ComponentY.inject(this); 
} 
} 

ComponentX-> ModuleA ->providerA 
ComponentY -> ModuleB -> providerB 

Come si può vedere, si tratta di due componenti completamente indipendenti tra loro non in alcun modo tranne che nel punto di iniezione.

Durante la compilazione ottengo il seguente errore:

In file A.java 
error: B cannot be provided without an @Provides- or @Produces-annotated method. 
MainActivity.b 
[injected field of type: B b] 

mi sbaglio a pensare che più componenti può essere utilizzato durante l'utilizzo di pugnale 2 o è l'applicazione dovrebbe utilizzare una grande componente che si occupa di tutti i iniezioni?

Qualcuno può aiutarmi a capire dove sto andando male?

Answer 1

Non è necessario avere un singolo componente, ci sono vari modi per rendere modulare loro, ma ogni oggetto che si crea, o iniettare valori in, deve avere tutti i suoi valori forniti da un singolo componente.

Un modo per ristrutturare il codice è che ComponentY dipenda da ComponentX o viceversa, ad es.

@Component(dependencies = ComponentX.class) 
interface ComponentY { 
    void inject(MainActivity activity); 
} 

Oppure si potrebbe creare un terzo componente, dicono ComponentZ, se componentX e componentY sono completamente ortogonali tra loro.

@Component(dependencies = {ComponentX.class, ComponentY.class}) 
interface ComponentZ { 
    void inject(MainActivity activity); 
} 

Oppure si potrebbe semplicemente riutilizzare i moduli, ad es.

@Component(modules = {ModuleA.class, ModuleB.class}) 
interface ComponentZ { 
    void inject(MainActivity activity); 
} 

Come esattamente si decide di dividerlo dipende in gran parte dalla struttura del codice. Se i componenti X e Y sono visibili ma i moduli non lo sono, usa le dipendenze dei componenti, in quanto esse (e le dipendenze del modulo) sono in realtà dettagli di implementazione del componente. Altrimenti, se i moduli sono visibili, li riutilizzi semplicemente.

Non utilizzerei gli scope per questo dato che sono veramente utili per gestire oggetti con durate diverse, ad es. oggetti associati a un utente specifico la cui durata è il tempo a partire dal momento in cui un utente accede al momento del logout o la durata di una richiesta specifica. Se hanno una durata di vita diversa, stai cercando di utilizzare ambiti e sottocomponenti.

Answer 2

is the application supposed to use one big component which takes care of all the injections?

È possibile utilizzare Subcomponent. Nei tuoi componenti caso di dichiarazione sarà simile a questa:

@Subcomponent(modules=ModuleB.class) 
public interface ComponentY{ 
    void inject(MainActivity mainActivity); 
} 

@Component(modules=ModuleA.class) 
public interface ComponentX{ 
    ComponentY plus(ModuleB module); 
} 

ComponentY creazione: creationCompunentY = ComponentX.plus(new ModuleB());

Ora in MainActivity si chiamano solo ComponentY.inject(this);

MainActivity { 

@Inject A a; 
@Inject B b; 

onCreate(){ 
    ComponentY.inject(this); 
} 
} 

ulteriori informazioni sui componenti secondari può essere trovato in migration from Dagger1 guide (guarda la parte dei sottografi), Subcomponent JavaDoc e Component JavaDoc (guarda la sezione Sottocomponenti).

Answer 3

is the application supposed to use one big component

In genere, dovresti pensarci negli ambiti. Per un dato ambito, c'è un componente. Gli ambiti sono ad esempio ApplicationScope, FragmentScope (conservato), ActivityScope, ViewScope. Per ogni ambito, c'è un dato componente; gli ambiti non sono condivisi tra i componenti.

(Ciò significa essenzialmente che se si desidera avere singleton globali nello @ApplicationScope, esiste un componente con ambito applicazione per esso. Se si desidera classi specifiche dell'attività, quindi si crea un componente per tale attività specifica, che dipenderà dal componente dell'ambito dell'applicazione).

Fare riferimento a @MyDogTom per l'annotazione @Subcomponent, ma è anche possibile utilizzare le dipendenze del componente per la creazione di componenti sottoposti a sottoscrizione.

@YScope 
@Component(dependencies = ComponentX.class, modules=ModuleB.class) 
public interface ComponentY extends ComponentX { 
    B b(); 

    void inject(MainActivity mainActivity); 
} 

@XScope 
@Component(modules=ModuleA.class) 
public interface ComponentX{ 
    A a(); 
} 

ComponentY componentY = DaggerComponentY.builder().componentX(componentX).build();