Créer une application Grails

Logo Grails

Grails est un framework basé sur le langage Groovy créé en 2005 et développé par Graeme Rocher, Guillaume Laforge, Marc Palmer, Dierk Koenig et Steven Devijver sous licence Apache 2.0. Il tend à répondre aux contraintes de développement agile d’application web et s’intègre à l’univers Java/JEE (via Spring) puisqu’il tourne sur une JVM.

L’intérêt de Grails est qu'il permet de générer, à partir d'un modèle de données bien définis, une application web en respectant de manière implicite des méthodes de développement agile. Du modèle à la vue en passant par la récupération des différentes librairies jusqu’au lancement de l’application sur serveur tomcat. Son langage de programmation (Groovy) est aussi très flexible.

Nous allons voir comment créer une application simple avec ce framework.

I - Préparation des Outils de développement

A la base, Grails est utilisable via la console windows. Mais l’informatique a évolué et nous sommes en 2014. Il existe plusieurs IDE permettant d’utiliser Grails (GGTS, Eclipse, Ntbeans,…).

Nous allons utiliser Groovy / Grails Tool Suite (GGTS). C’est un environnement de développement Eclipse optimisé pour créer des applications Groovy Grails. Pour ma part, j’ai utilisé la version 3.5.1.RELEASE-e4.3.2-win32-x86_64.

Prérequis
L’environnement Java est nécessaire. Il est possible de récupérer la version 7 sur le site d’oracle.

Installation
L’installation par défaut de GGTS convient parfaitement dans notre cas.

A la fin de l’installation, allez dans le répertoire d’installation ouvrez le fichier ggts-3.5.1.RELEASE/GGTS.ini et remplacez les lignes -Xms40m
-Xmx768m
par : -Xms256m
-Xmx1024m

Pour info, le Xmx précise la valeur maximal de l'allocation de mémoire pour une machine virtuelle Java (JVM), tandis que Xms est spécifie le pool initial d'allocation de mémoire.

Lancement de GGTS
Lors du lancement de GGTS, il est demandé de sélectionner un workspace. C’est le répertoire de travail dans lequel vont être sauvegardés les projets que nous allons créer. Il est possible d’avoir plusieurs workspaces avec leurs propres configurations, propriétés d’affichage, etc.

Lors du 1er lancement, l’interface devrait ressembler à ça :
Fenetre GGTS

Nous sommes dans la perspective Grails. Dans cette perspective, nous distinguons plusieurs vues dont les plus importantes sont Project Explorer et Console... à ne pas perdre sinon aller dans Window > Show View puis les sélectionner.

Avant toute chose, dans Window > Preferences > Java > Installed JREs, vérifiez que jdk1.7 est bien coché.
Installed JREs

Si ce n’est pas le cas, il faut l’ajouter : Add > Standard VM > Next > Directory Sélectionnez le dossier d’une jdk puis Finish. Attention à ne pas confondre jdk et jre

II - Création du projet

File > New > Grails Project
Renseignez le nom du projet Project_Grails_Demo puis cliquez sur Finish.

Le projet grails est généré. Il devrait ressembler à ça :
Structure_Projet

Présentation du projet Grails

Notre projet comprend plusieurs parties.

  • Domain, services, controllers : Les classes de notre application
  • views : Les interface de notre application
  • i18n : Les libellés des champs de l’interface
  • conf : Les élément servant à configurer notre application
  • test/unit : Les classes permettant de tester l’application

Nous allons lancer notre projet pour la première fois :
Pour se faire, il suffit d’ouvrir la commande grails :
Commande Grails
Sélectionnez notre projet et tapez run-app pour lancer l’application (stop-app pour l’arrêter).

Lorsque la console affiche :
Serveur Running

Le port par défaut est 8080. Pour le changer, lancez la commande -Dserver.port=numéro_de_port run-app

Ouvrir un navigateur web et aller sur l’adresse indiquée.
Vous devrez tomber sur la page ci-dessous.
Accueil_Application

Notre application fonctionne !!

III - Génération des objets :

Notre application sera le plus simple possible. Elle permettra de créer des articles.

Génération des domaines.
Le domaine représente le modèle du paradigme MVC. C'est une entité persistante qui aura pour but d'être mappée dans une table de la base de données sous jacente.
La commande à utiliser pour créer un domaine appelé « Article » dans le package « fr.demo » est :

Create-domain-class fr.demo.Article

2 fichiers .groovy sont alors créés :

  • ArticleSpec.groovy qui comprendra nos cas de test (Basé sur le principe du TDD, c’est lui que nous devons normalement modifier en premier)
  • Article.groovy qui est notre objet

Nous allons ensuite créer nos controllers et nos vues.

Génération des contrôlleurs.
La commande à utiliser pour créer un controller appelé « Article » dans le package « fr.demo » est :

Generate-controller fr.demo.Article

Génération des vues
La commande à utiliser pour créer une vue appelée « Article» dans le package « fr.demo » est ///Generate-views fr.demo.Article///

Alternative : Génération des controllers et vues.
Au lieu de faire les commandes generate-controller et generate-view, il est possible de faire la commande generateAll.

GenerateAll fr.demo.Article

Vous pouvez maintenant aller sur la page d'accueil de votre application dans votre navigateur et y trouver le controller de votre article.
Cliquer dessus vous permettra de créer un nouvel article.

Conclusion 

Nous avons vu ici que Grails permet de générer rapidement une application fonctionnelle. Si vous aimez le concept, n'hésitez pas à vous renseigner d'avantage à ce sujet et aller plus loin. https://grails.org/

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Captcha *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.