Bonjour,

Aujourd’hui, je vais parler de la façon de démarrer avec Google Guice pour l’injection de dépendances en Java. Tout d’abord, je présenterai quelques concepts sur le framework, puis nous écrirons une application simple à illustrer.

Injection de dépendances

Comme nous en avons parlé dans ce post, l’injection de dépendances (DI) est une technique permettant de fournir des dépendances aux clients au lieu que ces derniers les obtiennent explicitement. DI est essentiellement un moyen d’atteindre un objectif plus général appelé principe d’inversion de dépendance (DIP), qui stipule:

Au lieu de dépendre des implémentations, préférez dépendre des abstractions.

Lors de l’application de DI, nous avons besoin d’un moyen d’injecter (câbler, lier) les dépendances pour les clients qui les demandent, nous pourrions le faire manuellement lors de l’instanciation de la classe client ou nous pourrions compter sur un framework pour automatiser ces tâches et ajouter également des fonctionnalités intéressantes, comme la gestion du cycle de vie.

En ce qui concerne Java, il existe une variété de frameworks avec éventuellement des avantages et des inconvénients, par exemple, Weld, Spring, Guice, etc.

Dans ce post, nous utiliserons Guice et dans un prochain post, j’ai l’intention de parler de Spring, probablement dans le contexte de la conception d’API RESTful avec Spring Boot et Spring REST.

Google Guice

Google Guice est un framework pour automatiser l’injection de dépendances en fournissant un conteneur où nous pouvons mapper des abstractions et des implémentations. Après le mappage, les dépendances seront automatiquement injectées dans les clients à la demande.

La cartographie dans Guice est réalisée par la mise en œuvre de com.Google.injecter.Module qui se fait normalement en héritant de la classe de base abstraite com.Google.injecter.Module abstrait.

Après, nous devons remplacer la méthode configure et nous appuyer sur une API fluide en appelant les méthodes bind et to pour définir le mappage entre l’abstraction (paramètre de bind) et l’implémentation (paramètre de to).

Ensuite, nous pouvons injecter les dépendances en annotant vos dépendances avec com.Google.injecter.Injecter.

Enfin, il faut obtenir un com.Google.injecter.Injecteur de notre module précédemment défini, nous sommes donc maintenant en mesure de récupérer le client avec la méthode getInstance et ses dépendances seront automatiquement injectées.

Exemple

Cet exemple consiste en une partie d’un système Java qui envoie des informations de journal sur son fonctionnement. Pour simplifier l’inclusion de Guice dans notre projet, nous allons utiliser Maven comme outil de construction.

Dans le pom.xml, ajoutez l’artefact suivant pour Guice à la version 4.0 dans la section dépendances:

<dependency>
<groupId>com.google.inject</groupId>
<artifactId>guice</artifactId>
<version></version >
</dependency >

Créons l’interface LogSender pour représenter le comportement : « envoie le journal à un support”:

Ce service sera utilisé par la classe Exchanger qui a une référence à LogSender et l’injection sera effectuée par son constructeur annoté avec @Inject:

L’implémentation StdoutLogSender enverra le journal au flux de sortie standard, dans ce cas la console :

div>

Maintenant, nous devons dire à Guice comment mapper LogSender à StdoutLogSender, et nous le faisons par la classe LoggingModule:

Enfin, dans l’application de la classe principale, nous pouvons créer un injecteur et transmettre notre LoggingModule à son constructeur. Ensuite, nous pouvons obtenir une instance d’Exchanger qui aura sa dépendance sur LogSender bound:

Conclusion

Dans cet article, nous avons discuté des bases concernant la façon de démarrer avec Google Guice pour l’automatisation des tâches d’injection de dépendances dans l’application Java. Nous avons écrit une application simple pour illustrer comment définir le mappage entre les abstractions et les implémentations et comment les injecter dans nos clients.

J’espère qu’avec cet aperçu de base de Guice, vous pourrez continuer vos études sur l’injection de dépendance et comment développer du code avec un niveau de couplage inférieur et un niveau de cohésion élevé.