Android
Bibliothèque Dagger 2: injection de dépendance dans les applications
Recherche…
Introduction
Dagger 2, comme expliqué sur GitHub , est une approche évolutive à la compilation de l'injection de dépendance. En prenant l'approche de Dagger 1.x, Dagger 2.x élimine toute réflexion et améliore la clarté du code en supprimant l' ObjectGraph / Injector traditionnel au profit des interfaces @Component spécifiées @Component utilisateur.
Remarques
- Configuration de la bibliothèque dans l'application (pour les projets maven, gradle, java)
- Avantages de l'utilisation de Dragger
- Liens importants (pour la documentation et les démos)
- Comment intégrer et utiliser des composants Dragger
Dagger 2 API:
Dagger 2 expose plusieurs annotations spéciales:
@Module pour les classes dont les méthodes fournissent des dépendances
@Provides pour les méthodes dans les classes @Module
@Inject pour demander une dépendance (un constructeur, un champ ou une méthode)
@Component est une interface de pont entre les modules et l'injection
Liens importants:
GitHub: https://github.com/google/dagger
UserGuide (Google): https://google.github.io/dagger/users-guide.html
Vidéos: https://google.github.io/dagger/resources.html
Tutoriel Vogella: http://www.vogella.com/tutorials/Dagger/article.html
Didacticiel Codepath: https://github.com/codepath/android_guides/wiki/Dependency-Injection-with-Dagger-2
Créer une annotation @Module Class et @Singleton pour Object
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
@Module
public class VehicleModule {
@Provides @Singleton
Motor provideMotor(){
return new Motor();
}
@Provides @Singleton
Vehicle provideVehicle(){
return new Vehicle(new Motor());
}
}
Chaque fournisseur (ou méthode) doit avoir l'annotation @Provides et la classe doit avoir l'annotation @Module . L'annotation @Singleton indique qu'il n'y aura qu'une seule instance de l'objet.
Demander des dépendances dans des objets dépendants
Maintenant que vous avez les fournisseurs de vos différents modèles, vous devez les demander. Tout comme Vehicle besoin de Motor , vous devez ajouter l'annotation @Inject dans le constructeur du Vehicle comme suit:
@Inject
public Vehicle(Motor motor){
this.motor = motor;
}
Vous pouvez utiliser l'annotation @Inject pour demander des dépendances dans le constructeur, les champs ou les méthodes. Dans cet exemple, je garde l'injection dans le constructeur.
Connecter @Modules avec @Inject
La connexion entre le fournisseur de dépendances, @Module , et les classes les demandant via @Inject est effectuée à l'aide de @Component , qui est une interface:
import javax.inject.Singleton;
import dagger.Component;
@Singleton
@Component(modules = {VehicleModule.class})
public interface VehicleComponent {
Vehicle provideVehicle();
}
Pour l'annotation @Component , vous devez spécifier les modules à utiliser. Dans cet exemple, VehicleModule est utilisé, ce qui est défini dans cet exemple . Si vous devez utiliser plus de modules, ajoutez-les simplement en utilisant une virgule comme séparateur.
Utilisation de l'interface @Component pour obtenir des objets
Maintenant que chaque connexion est prête, vous devez obtenir une instance de cette interface et appeler ses méthodes pour obtenir l'objet dont vous avez besoin:
VehicleComponent component = Dagger_VehicleComponent.builder().vehicleModule(new VehicleModule()).build();
vehicle = component.provideVehicle();
Toast.makeText(this, String.valueOf(vehicle.getSpeed()), Toast.LENGTH_SHORT).show();
Lorsque vous essayez de créer un nouvel objet de l'interface avec l'annotation @Component , vous devez le faire en utilisant le préfixe Dagger_<NameOfTheComponentInterface> , dans ce cas Dagger_VehicleComponent , puis utilisez la méthode de générateur pour appeler tous les modules.