Grails 2.0 - Nouveautés et retours d'expériences

Image non disponible

Moins attendu que Spring 3.1 mais pourtant tellement lié, Grails 2.0 est sorti le 15 décembre 2011.

Mon équipe et moi même étions impatient car la sortie de cette version majeure était planifiée depuis plusieurs mois mais sans cesse retardée pour attendre la release finale (GA) de spring 3.1. Cela fait en effet déjà deux mois que je travaille sur la béta, puis les releases candidates, mais sortir un produit basé sur une RC, c'est pas sérieux.

Développeur Grails depuis 3 ans, je vais vous détailler les nouveautés les plus marquantes de Grails 2.0 et de son écosystème en essayant d'aller un peu plus loin que ce qu'on peut trouver habituellement dans les RELEASES NOTES.

Pour réagir au contenu de cet article, un espace de dialogue vous est proposé sur le forum 6 commentaires Donner une note à l'article (5).

Article lu   fois.

Les deux auteurs

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

1. Upgrade des librairies

On y échappe pas, c'est le cas à chaque version de Grails, les librairies utilisées sont toujours mises à jour et on a le droit maintenant à Groovy 1.8, Spring 3.1 (ça on sait), Hibernate 3.6, Serlvet 3.0...

2. Vers le développement continu

Pour ce qui est du développement, Grails 2.0 propose un meilleur rechargement à chaud de nos modifications et permet donc de travailler plus longtemps sans redémarrer l'application.

Concrètement, les principales causes de redémarrage sont liés à des modifications des objets du domaine (le modèle de données), car même si elles sont généralement prises en compte à chaud, la reconstruction de la base de données vide les tables des données de test qui sont généralement ajoutées au lancement de l'application via la classe Boostrap.groovy.

Petit astuce au passage, le plugin fixture permet de gérer de façon élégante les données de tests, que ce soit pour votre application en mode développement ou pour vos tests (unitaires, intégration, fonctionnel) - http://grails.org/plugin/fixtures

3. Du nouveau dans les ressources

3-A. Utilisation de jquery

Un des fait marquant de la version 2.0 est l'intégration par défaut de jquery à la place de prototype, mais derrière tout cela se cache une refonte complète de la gestion des ressources.

Le plugin jquery-ui complète d'ailleurs très bien l'intégration de jquery dans votre application.

3-B. Nouveau plugin resource inclu dans Grails

Grails vient avec de nouvelles balises <r:> qui optimisent la gestion des resources (images, css, js, ..) en évitant les chargements multiples ou facilite la gestion du code javascript propre à chaque page.

Par exemple la balise <r:script> ajoute par défaut le contenu javascript en fin de page HTML pour améliorer le temps de chargement dans les navigateurs.

Note: C'est d'ailleurs un principe qu'on retrouve partout dans Grails, souvent sans s'en rendre compte, celui de mettre en place les meilleurs pratiques à tous les niveaux de l'application.

Pour finir sur les resources, ce nouveau système ouvre la voie à de nombreuses fonctionnalités telles que la compression des resources, la gestion de bundle, etc.

4. Du choix au niveau de la Persistance

4-A. H2 à la place de HSQL

Petit changement mais qui a son importance, avec H2 embarquée, une application Grails en mode développement permet d'accéder automatiquement à la console d'administration de la base h2 (affichage des tables, requêtes SQL, ...) en accédant simplement à l'url http://localhost:8080/application/dbconsole (Prêt à l'emploi !)

4-B. Des solutions avec GORM

Grails 2.0 (et son architecture interne basée elle même sur des plugins) permet de remplacer la solution de persistance classique (Hibernate) par d'autres solutions, telles que JPA, MyBatis et le monde NoSQL est loin d'être oublié avec Redis, MongoDb, Gemfire et bien d'autres.

Et beaucoup de ces plugins sont supportés par SpringSource ce qui est un gage de qualité certain. En effet Graeme Rocher, le tech leader de Grails est responsable également d'un projet ambitieux concernant le support de très nombreuses solutions de gestion de données. Parce que la liste est trop longue et que je vous laisse la découvrir par vous même, je ne vais pas vous la détailler, mais vous pouvez la consulter directement le github du projet https://github.com/SpringSource/grails-data-mapping

4-C. Multi-datasource

Mieux encore, GORM, l'ORM de Grails permet maintenant d'utiliser plusieurs datasources très facilement. Il suffit de déclarer une ou plusieurs datasource supplémentaires dans le fichier DataSource.groovy et de préciser au niveau des domaines quel datasource utiliser :

 
Sélectionnez
class Comment {
   String author
   String comment
 
   static mapping = {
      datasource 'social'
   }
}

On peut ainsi utiliser deux bases relationnelles ou mixer une base relationnelle avec une base NoSQL ou tout autre configuration.

5. La face cachée de l'Iceberg

Comme beaucoup de développeur passionné, j'aime regarder ce qui se passe à l'intérieur d'un framework pour comprendre comment cela fonctionne ou mieux, trouver des fonctionnalités non documentées.

En regardant les classes de Grails, on remarque qu'il y a eu énormément de travail de refactoring depuis la version 1.3. Les raisons sont nombreuses mais en voici quelques une en vrac :

  • améliorer l'architecture interne en plugin
  • permettre de remplacer plus facilement un plugin par un autre et notamment tout ce qui concerne la persistance
  • séparer clairement les responsabilités (binding, validation, persistance, ...)
  • faciliter l'intégration dans les IDE
  • parce que le refactoring c'est essentiel quand un projet grossi

Un exemple qui caractérise bien cela est la classe org.codehaus.groovy.grails.plugins.web.api.ControllersApi qui regroupe toutes les méthodes ajoutés par Grails au niveau des controlleurs MVC.

6. Les plugins !

6-A. Grails Market

On est encore loin des markets Android ou Apple, mais Grails dispose aujourd'hui de plus de 700 plugins disponibles dans le repository officiel, et on peut en trouver bien d'autres sur github notamment.

Bonne nouvelle, les plugins officiellement maintenu par SpringSource sont déjà compatibles avec la version 2.0 de Grails. On retrouve donc le plugin spring-security-core et ses dépendances (ui, acl, OpenID, LDAP, ...), mais aussi les plugins de persistance cités ci-dessus (JPA, MongoDB, Redis, ...) et des plugins plus anciens mais toujours utiles (Quartz, WebService, Mail).

6-B. Cloud Ready

Grails n'est pas resté à l'écart de cette mouvance et les plugins Cloud Foundry Integration ou App Engine permettent de les déployer en un clic !

Heroku vient d'ailleurs d'annoncer le support de Grails sur sa plateforme http://blog.heroku.com/archives/2011/12/15/grails/

7. L'IDE

"Que serait un bon framework sans un bon IDE ?" Personnellement, je pense que cet adage se rapproche beaucoup de celui-ci : "Que serait un bon langage sans compilateur ?"

Utilisateur depuis des années d'Eclipse, je ne vous parlerai que de STS, mais Grails est supporté également par IntelliJ et Netbeans.

Depuis maintenant plus de trois ans, Springsource fourni beaucoup d'efforts pour améliorer sans cesse le support de Groovy et de Grails dans son IDE, SpringSource Tools Suite (STS).

Outre le support de groovy, STS intègre des wizards pour l'utilisation des commandes Grails ou la gestion des plugins (installation, désinstallation, mise à niveau), Toujours plus étonnant, STS supporte également la complétion sur les fameux dynamicFinder de Grails qui permettent d'exécuter des requêtes SQL uniquement à partir du nom de la méthode. En voici un exemple issu de la doc officielle :

 
Sélectionnez
def results = Book.findAllByTitleIlike("%Hobbit%")

STS supporte également les DSL groovy et la complétion des tag Grails dans les GSP. Cette dernière fonctionnalité, basée sur une convention de nommage des commentaires au niveau des tags Groovy est extrêmement pratique et je vous encourage fortement à l'utiliser sur tous les tags que vous créerez dans vos projets ou plugins.

8. Mais encore

Au niveau des autres améliorations majeures, on trouve également :

  • le support HTML 5 au niveau du scaffolding
  • un nouvelle console pour l'exécution des commandes Grails
  • une meilleure gestion des erreurs affichées dans le navigateur avec des informations de debug au niveau des GSP, controlleur, exception, ...
  • une solution pour gérer les montées de version de la base de données (que je ne préfère pas utiliser au profit d'un vrai outil de modélisation)
  • des tests unitaires et d'intégration plus avancés et plusieurs solutions de tests fonctionnels
  • une amélioration continue de la documentation, utile par exemple lorsqu'il s'agit d'installer un repository d'entreprise pour déployer et gérer vos plugins Grails

9. Au final

Certes, il est impossible d'être complet tant il y a de nouveautés. Je dirai plutôt d'améliorations, car venant de Grails 1.2 ou 1.3, on n'est pas dépaysé, tout est dans la continuité, et on en découvre un peu plus tous les jours.

J'espère que cet aperçu vous a donné envie d'aller voir plus loin ce qui se cache derrière Grails 2.0.

Vous trouverez plus de détail sur l'annonce officielle de sortie sur le blog de springsource et également dans la documentation officielle de Grails.

Bon développement.

X. Remerciements

Cet article a été publié avec l'aimable autorisation de la société ZenikaZenika, le billet original peut être trouvé sur le blog de ZenikaBlog de Zenika.

Nous tenons à remercier mlny84 et Mickael Baron pour la mise au gabarit du billet original.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Copyright © 2011 Manuel Boillod. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.