Loading...
X

Grails partie 2 : création d’une application basique

Grails_logo

 

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.

 

RaceTrack

 

 

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.

Grails new project

 

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.

 

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.

Page d'accueil Grails

 

Structure d’une application grails

 

Une fois votre application créée, vous devriez avoir une disposition similaire dans votre explorateur de projets.

Structure application Grails

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 :

def number = 10

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 :

new User(firstName:"John", lastName:"Doe")

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 :

user?.name

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 :

int[] a = {1,2,3};

Mais comme cela :

int[] a = [1,2,3]

Enfin, la boucle for habituellement écrite comme ceci :

for (int i=0; i < len; i++) {...}

Peut également être raccourcie comme cela :

for (i in 0..len-1) {...}
for (i in 0..<len) {...}
len.times {...}

 

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é.

package com.viaxoft.racetrack

class Race {

    static constraints = {
    }
}

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.

package com.viaxoft.racetrack
 
class Race {
 
    String name
    Date startDate
    String city
    BigDecimal distance
    BigDecimal cost
    Integer maxRunners
 
    static constraints = {
    }
}
package com.viaxoft.racetrack
 
class Runner {
 
    String firstName
    String lastName
    Date dateOfBirth
    String gender
    String address
    String city
    String zipcode
    String email
 
    static constraints = {
    }
}

 

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 :

def runner = new Runner(firstName: "John", lastName: "Doe", gender: "male")

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.

 

Sources

http://www.infoq.com/minibooks/grails-getting-started

http://groovy.codehaus.org/Documentation