Tutoriel sur le développement rapide d'application Web Java avec Spring ROO

Spring ROO est un outil proposé par la société SpringSource et par l'un de ses contributeurs, Ben Alex, à qui l'on doit notamment la solution Spring Security. Il s'agit d'un outil de productivité qui d'une part permet la création rapide d'applications Web Java et d'autre part, simplifie le développement en s'occupant du code fastidieux.

Imaginez une situation classique pour n'importe quel développeur ou architecte : vous devez démarrer un nouveau projet. Pour cela, vous devez le créer, décider d'une base de données, d'un fournisseur de persistance, créer les objets du domaine, les contrôleurs associés, les vues, les tests, ajouter un contrôle de la sécurité et des accès, ajouter la gestion des logs… La liste ne se veut pas exhaustive, mais demandez-vous combien cela vous prend de temps ? Deux, trois jours ? Une journée tout au mieux ? Une fois votre projet démarré, combien de temps perdez-vous à développer des assesseurs, des mutateurs, des méthodes toString() et autres joyeusetés du genre ?

C'est ici que ROO intervient, car il s'agit d'un outil fullstack, c'est-à-dire qu'il couvre toutes les couches d'une application. La liste que je viens de citer dans l'exemple précédent n'est ni plus ni moins que le domaine d'action de cette solution qui s'articule aujourd'hui autour des solutions suivantes :

Dans cet article, je vais créer une application « from scratch » utilisant Spring ROO. En particulier nous allons traiter les points suivants :

• création d'un projet Spring ROO avec l'outil Spring Tool Suite ;
• création et développement d'objets du domaine (entités JPA) ;
• ajouter des champs de différents types aux objets du domaine ;
• création de relations entre les différents objets du domaine ;
• automatisation du lancement des tests d'intégration ;
• création d'un workspace pour importer le projet dans l'IDE Eclipse ;
• création de la partie Web ;
• lancer l'application dans un conteneur Web.

Il est temps de nous plonger dans le fonctionnement de ROO. Celui-ci effectue deux types de traitements ; la génération de squelettes d'application et la surveillance de projet avec modifications de code le cas échéant. Il est tout à fait possible d'utiliser ROO (via son terminal) avec votre EDI classique (voire avec un éditeur de texte). Cependant, les projets créés étant largement basés sur l'ensemble Spring, je vous recommande de l'utiliser (toujours via son terminal) à l'intérieur de l'EDI SpringSource Tool Suite (STS, http://spring.io/tools). Il ne s'agit que d'une version d'Eclipse RCP optimisée pour fonctionner avec Spring et Maven.

Pour pouvoir observer ROO en action, il nous faut d'abord créer un projet de ce type. Ouvrez donc STS et allez sur le menu File/New puis sur Project… et enfin Spring pour sélectionner Spring Roo Project.

Cette action a pour effet d'ouvrir un assistant à la création d'un projet :

Bien que celui-ci comporte beaucoup de champs, il est très simple à utiliser (voyez ci-dessus une capture d'écran). Remplissez un nom de projet et un package de haut niveau (dans notre exemple com.springsource.roo.burgershop) puis cliquez sur Next.

On vous demande alors de confirmer la création du projet, cliquez sur Finish. Le projet est ensuite créé et vous pouvez l'observer dans le Package Explorer sur votre gauche. Il s'articule alors autour d'une structure standard Maven :

Vous pouvez observer que quelques fichiers de configuration basiques ont déjà été générés par ROO, notamment pour Log4j (log4j.properties), Maven (pom.xml) et Spring (applicationContext.xml). Un autre fichier important est log.roo qui va contenir toutes les commandes qui seront tapées dans le terminal. Cela va s'avérer très utile pour lancer rapidement un ensemble de ces dernières et donc accélérer encore plus la création.

Vous pouvez par ailleurs observer l'aspect du terminal ROO, en bas au centre :

Si celui-ci possède une apparence classique, son comportement l'est moins puisqu'il propose des réponses contextuelles, qui vous guident pas à pas. Quel que soit l'état d'avancement de votre projet, la commande hint vous permet de connaitre les actions possibles à l'instant présent. Voyons ce que cette commande nous donne maintenant, alors que nous n'avons fait que créer notre projet :

/ __ \/ __ \/ __ \
/ /_/ / / / / / / /
/ _, _/ /_/ / /_/ /
/_/ |_|\____/\____/    1.2.4.RELEASE [rev 75337cf]

Welcome to Spring Roo. For assistance press CTRL+SPACE or type "hint" then hit ENTER.
roo> hint
Roo requires the installation of a persistence configuration,
for example, JPA or MongoDB.

For JPA, type 'jpa setup' and then hit CTRL+SPACE three times.
We suggest you type 'H' then CTRL+SPACE to complete "HIBERNATE".
After the --provider, press CTRL+SPACE twice for database choices.
For testing purposes, type (or CTRL+SPACE) HYPERSONIC_IN_MEMORY.
If you press CTRL+SPACE again, you'll see there are no more options.
As such, you're ready to press ENTER to execute the command.

Once JPA is installed, type 'hint' and ENTER for the next suggestion.

Similarly, for MongoDB persistence, type 'mongo setup' and ENTER.
roo>

ROO vous indique qu'il est maintenant nécessaire d'ajouter une base de données et un fournisseur de persistance. En effet, les applications créées avec ROO sont domain driven, littéralement orientées métier. Cela signifie que l'on va d'abord créer les entités métier avant d'ajouter les contrôleurs et vues associés. Ici, nous choisissons Hibernate comme fournisseur de persistance sur une base en mémoire (H2_IN_MEMORY), pour une question de rapidité bien entendu.

Nous pouvons donc taper la commande correspondante dans le terminal sachant que pour cette dernière, l'autocomplétion est disponible (Ctrl + Space), inutile donc de vous rappeler de sa syntaxe complète ; ROO vous aide au maximum.

ROO continue ainsi son petit bonhomme de chemin en créant de nouveaux fichiers et en mettant à jour ceux existants dans notre arborescence :

Pour les objets du domaine, nous nous baserons sur le diagramme de classe suivant :

Maintenant il est temps de créer les objets du domaine et les champs qui sont associés à notre diagramme de classes. Pour commencer, nous pouvons utiliser la commande entityjpa pour créer les objets du domaine. La commande entity jpa a un nombre d'attributs optionnels que l'on retrouve à l'adresse :

Elle est composée par un attribut obligatoire qui est --class. En plus de l'attribut obligatoire, nous utilisons --testAutomatically qui permet de créer des tests d'intégration pour le domain object. Commençons par l'objet du domaine Topping.

Et maintenant nous allons ajouter les champs « name » field à notre objet du domaine Topping avec la commande suivante :

Nous ferons de même avec les autres objets du domaine , avec les commandes suivantes :

entity jpa --class ~.domain.Base --testAutomatically 
field string --fieldName name --notNull --sizeMin 2
entity jpa --class ~.domain.Burger --testAutomatically 
field string --fieldName name --notNull --sizeMin 2
field number --fieldName price --type java.lang.Float

Nous allons maintenant créer les relations entre les objets. Pour créer une relation de type many-to-many entre Topping et Burger, nous allons exécuter la commande suivante :

~.domain.Burger roo> field set --fieldName toppings --type ~.domain.Topping

De façon similaire pour créer une relation m:1 (many to one) nous utiliserons la commande suivante :

~.domain.Burger roo> field reference --fieldName base --type ~.domain.Base

De manière similaire nous créerons un objet BurgerOrder avec les commandes suivantes :

entity jpa --class ~.domain.BurgerOrder --testAutomatically 
field string --fieldName name --notNull --sizeMin 2
field string --fieldName address --sizeMax 30
field number --fieldName total --type java.lang.Float 
field date --fieldName deliveryDate --type java.util.Date
field set --fieldName burgers --type ~.domain.Burger

Il est encore possible de créer des tests avec la commande test integration. Une fois tous les tests créés, il est possible de tous les lancer en utilisant la commande perform tests :

~.domain.BurgerOrder roo> perform tests
...
-------------------------------------------------------
 T E S T S
-------------------------------------------------------

Tests run: 36, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS 
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.860s
[INFO] Finished at: Tue Feb 14 18:01:45 EST 2012
[INFO] Final Memory: 6M/81M
[INFO] ------------------------------------------------------------------------

Par défaut ROO ne contient pas de workspace spécifique à un IDE. Pour rendre le workspace compatible avec un IDE il faut utiliser la commande suivante perform eclipse.

~.domain.BurgerOrder roo> perform eclipse
...
[INFO] Adding support for WTP version 2.0.
[INFO] Using Eclipse Workspace: null
[INFO] Adding default classpath container: org.eclipse.jdt.launching.JRE_CONTAINER
[INFO] Wrote settings to /Users/stewarta/projects/roo-test/burgershop/.settings/org.eclipse.jdt.core.prefs
[INFO] Wrote Eclipse project for "burgershop" to /Users/stewarta/projects/roo-test/burgershop.
[INFO] n.BurgerOrder roo> 
       Javadoc for some artifacts is not available.
       Please run the same goal with the -DdownloadJavadocs=true parameter in order to check remote repositories for javadoc.
       List of artifacts without a javadoc archive:
         o org.springframework.roo:org.springframework.roo.annotations:1.2.1.RELEASE
...
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS 
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.685s
[INFO] Finished at: Tue Feb 14 18:04:20 EST 2012
[INFO] Final Memory: 7M/81M
[INFO] ------------------------------------------------------------------------

Si vous utilisez STS ou avez installé le plugin m2eclipse dans Eclipse, vous pouvez passer l'étape d'utilisation de cette commande perform eclipse. Dans ce cas, il suffit de choisir l'option « File > Import > General > Maven Projects » dans STS/Eclipse.

Pour cette partie, nous allons générer la partie Web l'application Burger Shop. Cette action est accomplie par l'utilisation de la commande web mvc. La façon la plus simple de générer les controllers et tous les Web artifacts est d'utiliser la commande web mvc setup suivie par la commande web mvc all :

~.domain.BurgerOrder roo> web mvc setup

~.domain.BurgerOrder roo> web mvc all --package ~.web

Cette commande scannera Burger Shop project pour toutes les entités de domaine et mettra en place un Spring MVC controller pour chaque entité détectée.

Pour déployer l'application dans un conteneur Web durant la phase de développement, il existe plusieurs options disponibles :

• déployer à partir du shell /ligne de commande (sans besoin d'assembler le projet en une archive war) :

  • lancer « mvn tomcat:run » sur la racine de votre projet (pas à l'intérieur du shell Roo) pour déployer sur un Tomcat,
  • lancer « mvn jetty:run » sur la racine du projet pour déployer sur un Jetty ;

• déployer sur le serveur Web intégré de STS :

  • drag and drop votre projet sur le serveur Web désiré dans la server view de STS,
  • clic droit sur le projet et sélectionner « Run As > Run on Server » pour déployer sur le serveur Web désiré,
  • après avoir déployé votre application sur le serveur avec la méthode choisie, votre application devrait être disponible à l'URL http://localhost:8080/burgershop

Cet article a été publié avec l'aimable autorisation de Jeremy Jeanne.

Nous tenons à remercier Claude Leloup pour sa relecture orthographique attentive de cet article et Régis Pouiller pour la mise au gabarit.

Cet article est en partie basé sur la documentation officielle. Vous pouvez vous y référencer pour de plus amples informations.