Share
RoboGuice, également appelé Google Guice sur Android, est un framework d'injection de dépendance facile à utiliser, qui peut rendre le développement d'Android plus intuitif et plus pratique. En utilisant cette structure, vous pouvez réduire considérablement la quantité de code que vous écrivez pour effectuer des tâches courantes, telles que l'initialisation de diverses ressources, l'accès aux services système Android et la gestion des événements..
Dans ce tutoriel, je vais vous montrer comment tirer le meilleur parti de RoboGuice 3 dans vos projets Android..
Traditionnellement, si un objet dépend de quelque chose, il lui incombe de satisfaire cette dépendance. En termes plus simples, si une instance de classe A dépend d'une instance de classe B, le développeur est généralement appelé à appeler le constructeur de la classe B à l'intérieur du code de la classe A. Cela conduit évidemment à un couplage plus étroit entre les deux classes..
L'injection de dépendance est un modèle de conception dans lequel les objets s'appuient sur un code externe, généralement appelé injecteur de dépendance, pour satisfaire leurs dépendances. Cela signifie que si un objet dépend d'autres objets, il n'a pas besoin de savoir comment créer ou initialiser ces objets. Cela réduit le couplage entre les objets et conduit à un code plus modulaire, plus facile à modifier et moins complexe à tester..
Ainsi, en utilisant l'injection de dépendance, vous pouvez supprimer les constructeurs et les méthodes d'usine dans la logique métier de votre projet..
Google Guice est un framework qui facilite la création, la configuration et l'utilisation d'un injecteur de dépendance dans vos projets Java. RoboGuice utilise Google Guice et est livré avec un injecteur de dépendance préconfiguré pour Android. Bref, RoboGuice sait comment initialiser divers objets Android, obtenir des références à diverses ressources d'une application, etc..
RoboGuice utilise des annotations Java, qui ne sont que des métadonnées incorporées dans du code Java, pour déterminer ce qui doit être injecté où. Les versions antérieures de RoboGuice utilisées pour traiter les annotations à l'aide de l'API Java Reflection lors de l'exécution et étaient souvent critiquées pour leur lenteur. RoboGuice 3, toutefois, est livré avec RoboBlender, un processeur d'annotation à la compilation qui améliore considérablement les performances de RoboGuice..
Avant d’utiliser RoboGuice, vous devez l’ajouter en tant que compiler la dépendance dans votre app modules build.gradle fichier. Comme il est disponible sur le référentiel par défaut d'Android Studio, jcenter, cela nécessite juste une ligne de code.
groovy compile 'org.roboguice: roboguice: 3.0.1'
Pour améliorer les performances de RoboGuice, il est recommandé d’ajouter RoboBlender, un processeur d’annotation, en tant que à condition de dépendance.
groovy fourni 'org.roboguice: roboblender: 3.0.1'
Pour pouvoir utiliser les annotations de RoboGuice dans vos activités Android, leurs classes doivent être étendues. RoboActivity au lieu de Activité. De même, si vous souhaitez utiliser les annotations dans un service Android, sa classe doit être étendue RoboService au lieu de Un service.
Normalement, vous utiliseriez le setContentView méthode et passez une ressource de présentation à elle afin de définir la mise en page d'un Activité. RoboGuice offre un moyen alternatif de faire la même chose, le @ContentView annotation.
Par exemple, voici comment appliquer la présentation définie dans un fichier XML appelé activity_main.xml à un RoboActivity appelé Activité principale:
"java @ContentView (R.layout.activity_main) la classe publique MainActivity étend RoboActivity
"
Si vous pensez utiliser le findViewById méthode et type de la coulée Vue objet il retourne beaucoup de travail, vous pouvez utiliser RoboGuice @InjectView annotation à la place.
Par exemple, considérons la disposition suivante:
"xml
"
Pour initialiser les deux widgets d’UI définis dans le XML dans une RoboActivity, vous pouvez écrire ce qui suit:
"java @InjectView (R.id.email) email privé TextView;
@InjectView (R.id.okay) Bouton privé okay; "
L'accès aux ressources de votre application à l'aide de l'API Android implique un grand nombre de classes et de fonctions différentes. Pour aller chercher un Drawable, par exemple, vous devrez utiliser ContextCompat.getDrawable. Chercher un Animation, vous auriez à utiliser AnimationUtils.loadAnimation.
RoboGuice @InjectResource Les annotations offrent un moyen plus cohérent de récupérer tous les types de ressources. L’extrait de code suivant vous montre comment injecter une ColorStateList, une Drawable, une Chaîne, Et un Animation Ressource:
"java @InjectResource (R.color.red) privé ColorStateList rouge;
@InjectResource (R.drawable.square) private Square dessinable;
@InjectResource (R.string.hello) private String hello;
@InjectResource (R.anim.fade) private Animation fade; "
Pour obtenir une référence à un service système Android, tel que le PowerManager ou la Vibreur, vous pouvez utiliser le @Injecter annotation au lieu d'utiliser le getSystemService méthode. Par exemple, voici comment obtenir une référence à la PowerManager:
java @Inject privé PowerManager pm;
Vous pouvez utiliser le @InjectExtra annotation pour injecter les extras qui ont été passés à un RoboActivity. L'extrait de code suivant injecte un extra dont la clé est ADRESSE ÉLECTRONIQUE:
java @InjectExtra ("EMAIL_ADDRESS") private String email;
Notez que @InjectExtra provoquera une erreur d'exécution si l'extra n'est pas présent. Si le supplément est facultatif, vous devez inclure un optionnel drapeau dont la valeur est définie sur vrai afin d'éviter l'erreur.
java @InjectExtra (value = "EMAIL_ADDRESS", facultatif = true) Chaîne email;
Jusqu'à présent, nous avons injecté des éléments spécifiques au SDK Android. Pour injecter vos propres cours, vous devez utiliser le @Injecter annotation. @Injecter se comporte beaucoup comme Java Nouveau mot-clé et vous n'avez rien à modifier dans une classe pour la rendre injectable, à condition qu'elle ait un constructeur par défaut. Par exemple, considérons la classe suivante:
java public class Employee public Employee () Log.d ("RG", "Hello");
Pour injecter une instance de Employé classe, vous utiliseriez le code suivant:
java @Inject Employee p; // équivalent à new Employee ()
Si vous voulez un contrôle plus fin sur ce qui est injecté quand @Injecter est utilisé, vous devez créer vos propres fournisseurs personnalisés.
Créons un fournisseur simple qui renvoie un nombre aléatoire à chaque fois @Injecter est utilisé pour initialiser un Entier.
Un fournisseur est juste une classe qui implémente le Fournisseur interface. Par conséquent, créez une nouvelle classe appelée MyRandomNumberProvider qui met en œuvre Fournisseur et remplacer sa obtenir méthode.
"La classe publique java MyRandomNumberProvider implémente le fournisseur
@Override public Integer get () "
Comme vous avez pu le deviner, la valeur de retour du obtenir la méthode est ce qui sera injecté quand @Injecter est utilisé. Pour renvoyer un entier aléatoire, ajoutez le code suivant à obtenir méthode:
java // Retourne un entier aléatoire compris entre 0 et 999 return (int) (Math.random () * 1000);
Pour pouvoir utiliser votre fournisseur personnalisé, vous devez lui créer un module. Un module est une classe qui étend la AbstractModule classe. Dans le module, vous remplacez le configurer méthode et spécifiez la classe à laquelle le fournisseur doit se lier à l'aide du lier et au fournisseur les méthodes.
Pour créer un module pour MyRandomNumberProvider, créer une nouvelle classe Java appelée MyRandomNumberModule et ajoutez-y le code suivant:
"java public class MyRandomNumberModule étend AbstractModule
@Override public void configure () // Bind Integer à MyRandomNumberProvider bind (Integer.class) .toProvider (MyRandomNumberProvider.class); "
Pour informer RoboGuice de votre module, vous devez l’inscrire dans le répertoire de votre application. AndroidManifest.xml utilisant un méta-données étiquette. le prénom attribut de la balise doit être réglé sur roboguice.modules et son valeur attribut doit contenir le nom de classe du module.
"xml
"
Le fournisseur est maintenant prêt. À ce stade, si vous annotez une Entier avec @Injecter, il sera initialisé à un nombre aléatoire.
"java @Inject Integer random1; // Initialisé à un nombre aléatoire
@Inject Integer random2; // Initialisé à un autre nombre aléatoire "
Si vous êtes un développeur qui préfère utiliser un singleton pour partager des données entre plusieurs activités et services, vous pouvez utiliser @Singleton et @Injecter des annotations pour simplifier votre code.
En ajoutant le @Singleton annotation à une classe, vous pouvez indiquer à RoboGuice qu’elle ne doit pas créer plus d’une instance de la classe. Le code suivant crée un singleton appelé MySingleton:
java @Singleton, classe MySingleton
Vous pouvez maintenant utiliser le @Injecter annotation pour injecter le singleton dans vos classes. Par exemple, voici comment vous injectez MySingleton:
java @Inject MySingleton singleton;
En utilisant le @Observe annotation, vous pouvez observer divers événements associés à une Activité. Cela signifie que vous n’avez pas à remplacer le onCreate, pour résumer, et d’autres méthodes du cycle de vie du Activité classe.
Le code suivant vous montre comment le @Observe L’annotation peut être utilisée comme alternative à l’annulation de la onCreate et onDestroy méthodes:
"java public class MainActivity étend RoboActivity
// Appelé lorsque l'activité est créée, initialisation publique vide (@Observes OnCreateEvent e) // le code d'initialisation va ici // Appelé lorsque l'activité est détruite, nettoyage du vide public (@Observes OnDestroyEvent e) // code de nettoyage va ici "
Dans ce didacticiel, vous avez appris à utiliser RoboGuice pour rendre votre code plus concis et lisible. Ce faisant, vous avez également appris à utiliser les annotations Java et le modèle d'injection de dépendance..
Pour en savoir plus sur RoboGuice, je vous recommande de parcourir son wiki sur GitHub..
Accentsconagua