Waarvoor dienen componenten en modules in Dagger?

De componenten (Components) en modules (Modules) in Dagger vormen de fundamenten van het framework voor dependency management in Android-applicaties.

Modules (Modules):

• Dit zijn klassen gemarkeerd met @Module.
• Ze zijn verantwoordelijk voor het leveren (provisioneren) van objectinstanties, oftewel het creëren van afhankelijkheden.
• Methoden binnen de module, gemarkeerd met @Provides, geven aan Dagger hoe een specifiek type object gemaakt moet worden.
• Modules groeperen de logica voor het creëren van afhankelijkheden, waardoor de code georganiseerder en beter testbaar wordt.

@Module
public class AppModule {

    @Provides // Geeft aan Dagger hoe een Context te maken
    Context providesContext(Application application) {
        return application.getApplicationContext();
    }

    @Provides // Geeft aan Dagger hoe SomeApi te maken
    SomeApi providesSomeApi(Retrofit retrofit) {
        return retrofit.create(SomeApi.class);
    }
}

Componenten (Components):

• Dit zijn interfaces of abstracte klassen gemarkeerd met @Component.
• Ze verbinden modules met de klassen waarin afhankelijkheden geïnjecteerd moeten worden (bijvoorbeeld, Activities, Fragments, Services).
• Componenten functioneren als "afhankelijkheidsgrafieken" die afhankelijkheden verzamelen en leveren vanuit de aangegeven modules.
• Methoden in het component zonder parameters (injectiemethoden) geven aan Dagger in welke klasse afhankelijkheden geïnjecteerd moeten worden.
• Methoden in het component die een type teruggeven (voorzieningsmethoden) maken het mogelijk een afhankelijkheidsinstantie uit het graf te verkrijgen.
• De annotatie @Component(modules = { ... }) geeft aan welke modules het component gebruikt voor het leveren van afhankelijkheden.

@Component(modules = AppModule.class) // Het component gebruikt AppModule
public interface AppComponent {

    // Injectiemethode: Dagger injecteert afhankelijkheden in MainActivity
    void inject(MainActivity activity);

    // Voorzieningsmethode: maakt het mogelijk een SomeApi instantie uit het graf te halen
    SomeApi someApi();
}

Relatie:

• Componenten gebruiken modules om instructies te krijgen over hoe objecten (afhankelijkheden) gemaakt moeten worden.
• Vervolgens leveren de componenten deze gemaakte objecten aan de klassen die ze nodig hebben, via injectie of voorzieningsmethoden.
• Deze twee-laags structuur (modules voor maken, componenten voor koppelen) maakt het mogelijk afhankelijkheden efficiënt te beheren, de code meer modulair, testbaar en onderhoudsvriendelijk te maken.

Op deze manier leveren modules afhankelijkheden, en koppelen componenten deze afhankelijkheden aan de klassen die ze gebruiken.