Quelle est la différence entre Dagger 1 et Dagger 2…

La principale différence est que Dagger 2 génère du code lors de la compilation, tandis que Dagger 1 se reposait sur la réflexion à l'exécution.

Avantages de Dagger 2 par rapport à Dagger 1 :

Performance : L'absence de réflexion rend l'exécution plus rapide.
Débogage : Les erreurs de configuration sont visibles lors de la compilation, pas à l'exécution.
Fiabilité : Le code généré est plus prévisible et testable.
Absence d'erreurs cachées : La réflexion peut masquer des erreurs qui n'apparaissent que dans certaines conditions.

Dans Dagger 1, on utilisait les annotations @Module et @Inject, ainsi que les classes @ObjectGraph pour gérer les dépendances.

Dans Dagger 2, on utilise aussi @Module et @Inject, mais le mécanisme principal est @Component, qui sert de fabrique pour les objets injectés et est généré par Dagger.

Exemple de module en Dagger 1 :

// Module Dagger 1
@Module(injects = MyActivity.class)
public class MyModule {

    @Provides
    public MyDependency provideMyDependency() {
        return new MyDependency();
    }
}

Exemple de module en Dagger 2 :

// Module Dagger 2
@Module
public class MyModule {

    @Provides
    public MyDependency provideMyDependency() {
        return new MyDependency();
    }
}

Exemple de composant en Dagger 2 :

// Composant Dagger 2
@Component(modules = MyModule.class)
public interface MyComponent {

    void inject(MyActivity activity);
}

Principe principal de Dagger 2 : vous décrivez le graphe de dépendances à l'aide de modules et d'annotations, et Dagger génère des classes qui implémentent ce graphe, permettant d'obtenir des instances de dépendances. Cela ressemble à l'écriture manuelle de fabriques, mais de manière automatique et efficace.

Quelle est la différence entre Dagger 1 et Dagger 2?