Dans ce deuxième article sur le framework Grails, nous allons créer une application simple de CRUD. Vous pourrez ainsi voir à quel point il est rapide et facile de créer une telle application.
Nous partons du principe que vous avez suivi l’article précédent.
Dans cet article et dans les suivants, nous donnerons à chaque fois les deux possibilités pour réaliser une action : la version graphique et la version en ligne de commande qui vous servira principalement si vous n’utilisez pas le même IDE.
Présentation de l’application
Nous allons réaliser une application nommée RaceTrack. Celle-ci nous permettra de gérer des courses de voitures. Nous aurons donc un objet Race, un objet Runner et un objet Registration qui réalisera le lien entre les deux autres. Voici un schéma UML représentant l’application.
Création de l’application
Commencez par ouvrir votre environnement de développement. Pour rappel, nous utiliserons GGTS.
Créez une nouvelle application Grails : File -> New -> Grails Project. Donnez-lui le nom de « RaceTrack » et laissez les paramètres par défaut.
Vous pouvez ensuite essayer de lancer l’application pour tester si tout est bon avant d’aller plus loin. Pour cela cliquez sur l’habituelle flèche verte dans la barre d’outils, ou cliquez sur le bouton Grails Command et exécutez la commande run-app.
Vous devriez pouvoir accéder à votre application sur cette URL : http://localhost:8080/RaceTrack/ et arriver sur la page d’accueil par défaut qui listera tous nos contrôleurs.
Structure d’une application grails
Une fois votre application créée, vous devriez avoir une disposition similaire dans votre explorateur de projets.
Nous allons voir à quoi sert chacun de ces dossiers :
[table id=2 /]
Comme vous pouvez le voir, les dossiers sont nombreux, mais ont chacun leur fonction qui sera utile par la suite.
Introduction au Groovy
Avant d’aller plus loin, il est nécessaire d’avoir quelques notions du langage Groovy. Le but de cette partie n’est pas de vous apprendre le Groovy mais juste de vous donner les connaissances nécessaires pour continuer.
Il s’agit un langage de programmation orienté objet destiné à la plateforme Java. Si vous connaissez déjà le Java, vous n’aurez aucun mal à vous y habituer. Nous allons voir les principales différences avec celui-ci.
Tout d’abord, il s’agit d’un langage à typage dynamique, ce qui veut dire que vous n’êtes pas obligés de spécifier le type d’une variable lors de sa définition. L’extrait de code suivant est par exemple tout à fait valide :
[pastacode lang= »java » message= » » highlight= » » provider= »manual »]
def number = 10[/pastacode]
Ensuite, le point-virgule à la fin de chaque ligne n’est pas obligatoire. Le mot-clé return est également optionnel, ainsi que les parenthèses lors de l’appel d’une fonction avec au moins un paramètre.
Vous pouvez aussi passer des paramètres nommés à une méthode comme ceci :
[pastacode lang= »java » message= » » highlight= » » provider= »manual »]
new User(firstName:"John", lastName:"Doe")[/pastacode]
Il est possible d’éviter de vérifier si un objet est null avant d’accéder à un de ses attributs ou une de ses méthodes, tout simplement avec cette syntaxe :
[pastacode lang= »java » message= » » highlight= » » provider= »manual »]
user?.name[/pastacode]
Ainsi, aucune exception de type NullPointerException ne sera levée, même si l’objet user n’a pas été initialisé.
La déclaration d’un tableau ne s’effectue pas comme ceci :
[pastacode lang= »java » message= » » highlight= » » provider= »manual »]
int[] a = {1,2,3};[/pastacode]
Mais comme cela :
[pastacode lang= »java » message= » » highlight= » » provider= »manual »]
int[] a = [1,2,3][/pastacode]
Enfin, la boucle for habituellement écrite comme ceci :
[pastacode lang= »java » message= » » highlight= » » provider= »manual »]
for (int i=0; i < len; i++) {...}[/pastacode]
Peut également être raccourcie comme cela :
[pastacode lang= »java » message= » » highlight= » » provider= »manual »]
for (i in 0..len-1) {...}
for (i in 0..<len) {...}
len.times {...}[/pastacode]
Pour ce qui est des fonctionnalités propres au Groovy telles que les Closures, la syntaxe pour les Collections, les expressions régulières et autres, nous vous laissons consulter la documentation.
Les domain classes
Nous allons maintenant créer les modèles de notre application. Commençons avec la classe Race. Sur GGTS, faites un clic droit sur votre projet, choisissez New -> Domain Class puis renseignez com.viaxoft.racetrack.Race comme nom de classe. Vous pouvez également exécuter la commande create-domain-class com.viaxoft.racetrack.Race. Grails vous générera la classe avec un bloc constraints à l’intérieur dont nous verrons plus tard l’utilité.
[pastacode lang= »java » message= » » highlight= » » provider= »manual »]
package com.viaxoft.racetrack
class Race {
static constraints = {
}
}[/pastacode]
Réalisez la même opération avec les deux classes restantes : Runner et Registration.
Nous allons maintenant créer les attributs pour Race et Runner, sans nous préoccuper des relations pour le moment. Nous créerons également les attributs pour Registration lorsque nous aborderons les relations entre entités.
[pastacode lang= »java » message= » » highlight= » » provider= »manual »]
package com.viaxoft.racetrack
class Race {
String name
Date startDate
String city
BigDecimal distance
BigDecimal cost
Integer maxRunners
static constraints = {
}
}[/pastacode]
[pastacode lang= »java » message= » » highlight= » » provider= »manual »]
package com.viaxoft.racetrack
class Runner {
String firstName
String lastName
Date dateOfBirth
String gender
String address
String city
String zipcode
String email
static constraints = {
}
}[/pastacode]
Rien de bien compliqué ici, pour chaque attribut il suffit de préciser son type et son nom. Comme vous pouvez le voir, il est inutile de spécifier l’accessibilité d’un champ, ainsi que de réaliser des accesseurs. Le langage Groovy gère l’encapsulation à notre place. Il est également inutile de réaliser des constructeurs; comme nous l’avons vu précédemment, le Groovy nous permet de passer des paramètres nommés à une méthode. Nous pourrions ainsi instancier un objet Runner de cette manière :
[pastacode lang= »java » message= » » highlight= » » provider= »manual »]
def runner = new Runner(firstName: "John", lastName: "Doe", gender: "male")[/pastacode]
Pour finir, le champ id est également optionnel, puisque généré et géré automatiquement par Grails.
Génération des contrôleurs et des vues
C’est maintenant que vous allez comprendre toute la puissance de Grails.
Une fois nos deux entités créées, faites sur chacune d’elle : clic droit -> new -> Generate Controller and Views, ou exécutez la commande generate-all <nom du package>.<nom de la classe>.
C’est fini ! Vous pouvez lancer l’application et vous rendre compte par vous même de tout ce qu’a généré Grails. Sur la page d’accueil, vous pouvez voir les deux nouveaux contrôleurs et manipuler l’entité correspondante en cliquant dessus. Vous pouvez afficher tous les objets, en créer, en éditer et en supprimer.
En revanche, toutes les données enregistrées seront supprimées si vous arrêtez le serveur. Il s’agit simplement d’une convention de Grails : en mode développement les données sont réinitialisées au redémarrage du serveur. Si vous voulez conserver les données, lancez l’application en mode production avec prod run-app. Les données seront enregistrées dans la base de données HSQLDB intégrée à Grails.
Si vous souhaitiez réaliser une application simple de CRUD, vous pouvez vous arrêter ici ! Pour les autres, nous verrons plus en détail, dans les prochains articles, le fonctionnement des contrôleurs, des GSP, la manière de personnaliser les champs affichés, comment gérer les relations, et bien d’autres éléments.
