Grails partie 4 : Les relations
10/10/2014
Dans ce quatrième article sur le framework Grails, nous allons aborder les relations entre entités. Cela va nous permettre de posséder enfin un modèle de données correct et permettre à l’utilisateur, dans notre cas par exemple, de choisir à quelle course il veut participer.
Nous partons du principe que vous avez déjà suivi les trois articles précédents : Introduction à Grails, Grails partie 2 : création d’une application basique et Grails partie 3 : La validation.
Nous allons voir quatre types de relations puis les mettre en oeuvre sur notre application que nous mettons à jour depuis le deuxième article. Pour rendre notre explication plus claire, nous l’agrémenterons d’exemples très parlants de la documentation officielle.
Relation many-to-one
Commençons par la relation la plus simple. Une relation many-to-one n’est rien de plus qu’une classe possédant un attribut du type d’une autre classe. Voici comment ceci est réalisé dans une application Grails :
Rien de bien compliqué ici, cette relation est réalisée de la même façon que dans beaucoup de langages.
Si nous voulons ensuite rendre cette relation bidirectionnelle et ainsi activer la sauvegarde et la suppression en cascade, il nous suffit de rajouter un attribut à la classe Nose :
Nous spécifions ainsi que la classe Nose appartient à la classe Face. Si nous supprimons un objet Face de la base de données, son objet Nose associé sera également supprimé. Vous pouvez remarquer que la façon de déclarer cet attribut est un peu spéciale. Nous devons spécifier le nom de l’attribut suivi de son type.
Relation one-to-one
La relation one-to-one ne diffère pas beaucoup de la précédente. Nous devons utiliser la propriété hasOne du côté de la classe propriétaire.
Ici, il s’agit bien de la figure qui possède un nez et non l’inverse.
Relation one-to-many
La relation one-to-many est également très simple à mettre en place :
Il suffit, comme vous pouvez le voir, de déclarer un attribut hasMany du côté approprié de la relation. Ici, un auteur possède plusieurs livres. Cette collection books sera automatiquement injectée par Grails et sera de type java.util.Set. Elle sera chargée de façon lazy. Si vous souhaitez rendre cette relation bidirectionnelle, il suffit de faire la même opération que précédemment :
Relation many-to-many
Pour cette dernière relation, many-to-many, chaque objet possède plusieurs autres objets d’un même type. Il suffit donc de déclarer un attribut hasMany des deux côtés de la relation. En plus de ceci, vous devrez définir un belongsTo du côté de la classe non propriétaire :
Ainsi, la classe Author devient « propriétaire », et si elle est supprimée, tous ses Books associés le seront également. Vous devriez cependant éviter de vous servir de cette relation, car la génération des vues et contrôleurs de Grails ne la prend pas charge. Si vous vous en servez, vous devrez donc la gérer vous-même.
Mise en application
Maintenant que nous avons passé en revue les différents types de relations pouvant exister, nous allons les mettre en place sur notre application RaceTrack. Reprenons notre modèle de données :
D’après notre schéma, nous allons ici nous retrouver avec deux relations one-to-many. Une course peut avoir plus enregistrements et un participant peut participer à plusieurs courses (et donc avoir plusieurs enregistrements). Voici le résultat de la mise en place de ces deux relations :
Il ne vous reste plus qu’à regénérer les vues et contrôleurs pour ces trois classes, comme vu dans le deuxième article.
Vous pouvez maintenant lancer l’application, créer une Race, un Runner, puis les relier grâce à une Registration.
Il ne nous reste plus qu’un petit détail à régler, l’affichage des objets. Comme vous pouvez le voir, le label par défaut est le nom de la classe, suivi de son id. Pour changer ceci, il vous suffit de surcharger la méthode toString, tout comme en Java.
Retournez sur la création d'une Registration et voici le résultat !
Ainsi, nous avons fait le tour dans cet article des différentes relations possibles et mis à jour notre application en conséquence. Vous avez pu voir que le tout reste très simple, rapide et intuitif à implémenter.
Pour le prochain article, nous aborderons et analyserons plus en détail les contrôleurs et les vues.
Sources
http://www.infoq.com/minibooks/grails-getting-started