Le contexte:
Le projet a pour but d'améliorer l'ergonomie et l'usabilité du back office d’un produit en cours de développement réalisé en collaboration avec SFEIR
Dans le cadre de ce projet, la version de GWT utilisée passe de la 1.7.1 à la 2.0.3 afin de bénéficier des nouvelles fonctionnalités offertes par cette version. De nouveaux pattern de développement ont également été mis en place au cours de ce projet.
Voici une série d'article sur les nouveautés de GWT 2, les choix d'architectures, et bibliothèques utilisés qui font part de notre retour d'expérience sur le sujet. Ces articles ont été écris par David Aboulkheir, Patrice de Saint Steban et Cyril Lakech
- Nouveautés de GWT 2.0
- UiBinder, enfin une forte collaboration entre le designer et le développeur
- Intégration facile de maquette Html en GWT 2
- Architecture Modèle-Vue-Presenteur
- Implémentation Modèle-Vue-Présenteur
- Ecrire des tests unitaires avec Mockito
- Mise en place de Gin sur le projet
- Internationalisation
Définitions de GIN/GUICE
Définition de Gin# : “GIN (GWT INjection) brings automatic dependency injection (DI) to Google Web Toolkit client-side code. GIN is built on top of Guice and uses (a subset of) Guice's binding language. (See GuiceCompatibility for details.) By using GWT's compile-time Generator support, GIN has little-to-no runtime overhead compared to manual DI.”
Définition de Guice# : “Guice is a dependency injection (DI) container”
Pour résumer, Gin est une librairie permettant de faire de l’injection de dépendance par paramètrage sur des projets GWT. Le but de l’injection de dépendance est de se passer du code permettant de relier les différents modules de l’application entre eux en le centralisant, ce qui améliore la lisibilité du code. Pour cela, il suffit de créer une factory ainsi que la configuration du binding des différents modules.
Configuration de Gin
Ajout de Gin en dépendance du projet (Maven / Classpath)
Il faut que les librairies Gin et Guice soient dans les dépendances Maven / Classpath du projet. Pour cela, il faut ajouter dans le pom.xml les dépendances suivantes :
<dependency>
<groupId>com.googlecode.gwt.inject</groupId>
<artifactId>gin</artifactId>
<version>1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.google.inject</groupId>
<artifactId>guice</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>
Le scope provided est utilisé pour que ces librairies ne soient pas embarquées dans le war généré par le projet qui les utilise.
Ajout de Gin en dépendance du projet (GWT)
Il faut que les librairies Gin et Guice soient dans les dépendances GWT du projet. Pour cela, il faut ajouter dans le Module.gwt.xml la dépendance suivante :
<module> ... <inherits name="com.google.gwt.inject.Inject"/> ... </module>
Création d’un injecteur de dépendances Gin
Pour pouvoir récupérer les modules dont les dépendances sont gérées par Gin, il suffit de créer une interface annotée dans laquelle on défini pour chacun des modules de l’application une méthode permettant de le récupérer.
@GinModules(ModuleInjectorModule.class)
public interface ModuleGInjector extends Ginjector {
AppPresenter getAppPresenter();
FooterPresenter getFooterPresenter();
DisplayFactory getDisplayFactory();
GlobalLayout getGlobalLayout();
}
Par exemple, dans notre cas, nous avons besoin de Gin pour gérer les dépendances du Presenter AppPresenter, nous avons donc défini une méthode getAppPresenter qui retourne un AppPresenter. En appelant cette méthode, Gin va s’occuper d’instancier automatiquement le Presenter en lui injectant les dépendances telles qu’elles sont configurées dans le module de configuration du binding Gin.
L’interface est annotée avec l’annotation @GinModules qui prend en paramètre la class du module de configuration du binding Gin.
Création du module configuration du binding Gin
Gin a besoin de connaitre la configuration du binding des modules de l’application. Pour cela, il faut créer une classe dans laquelle les liaisons entre les modules sont définies.
public class ModuleInjectorModule extends AbstractGinModule {
@Override
protected void configure() {
//Say to GIN to bind the Display to the FooterView and
//use a Singleton scope for the application
//This singleton view will be injected to the MainLayout
bind(FooterPresenter.Display.class).to(FooterView.class).in(Singleton.class);
bind(GlobalLayout.class).in(Singleton.class);
bind(AppPresenter.Display.class).to(GlobalLayout.class).in(Singleton.class);
}
/**
* This Provider is used by GIN to inject all HandlerManager field
* Use the legacy GlobalEventBus.get()
*/
@Provides
HandlerManager getGlobalEventBus() {
return GlobalEventBus.get();
}
}
Par exemple, dans notre cas, le FooterPresenter définie sa vue via l’inner classe Display qui est implémentée par la FooterView et cette classe n’a qu’une seule instance dans l’application. Ce qui se traduit par la ligne suivante :
bind(FooterPresenter.Display.class).to(FooterView.class)
.in(Singleton.class);
Il est également possible de fournir a Gin des classes dont il ne gère pas le cycle de vie. Par exemple, dans notre cas, comme nous avons progressivement migré vers Gin, et pendant cette phase de migration, certaines classes devaient être a la fois utilisée par Gin et également être utilisée par le système d’injection de dépendance manuel utilisé précédemment.
C’est le cas pour notre Bus d'évènement par exemple, c’est pourquoi nous avons ajouté cette méthode :
@Provides
HandlerManager getGlobalEventBus() {
return GlobalEventBus.get();
}
Instancier le Gin Injector dans l’application et l’utiliser
Pour utiliser l’injecteur de dépendance Gin, il suffit d’ajouter dans le Module GWT de l’application un attribut static puis de l’utiliser comme suit:
public class Module implements EntryPoint {
private final ModuleGInjector injector = GWT.create(ModuleGInjector.class);
public void onModuleLoad() {
...
MyPresenter myPresenter = injector.getMyPresenter();
...
}
}
Il est nécessaire de faire ce GWT.create une fois dans l'application pour que GIN puisse être appeler au moins une fois.
Aller plus loin avec Gin
Gin permet de binder les classes GWT utilisant le deferred binding comme les interfaces des constantes et messages pour l'internationalisation, ce qui facilite leur utilisation car c’est Gin qui s’occupera de les instanciers pour nous.
Gin permet également de binder les services RPC GWT pour faciliter leur utilisation.
Gin permet d’utiliser des fonctionnalités de Guice dans GWT mais toutes ne sont pas accessibles à cause des limitations de GWT.
Voir le tableau récapitulatif des fonctionnailités disponibles
