Grails est issue de la vague Ruby On Rails, RoR pour les intimes. Celui-ci a jeté un pavé dans la mare du développement d'applications Web en proposant un environnement permettant de réaliser rapidement un programme, tout en respectant un certain nombre de patterns architecturaux, dont le modèle en couche (couche de persistance, couche métier, couche présentation, ...). Son secret est de s'occuper de toute l'infrastructure logicielle de l'application et de permettre aux programmeurs de se concentrer sur la partie métier et IHM. La persistance est gérée automatiquement par le framework à partir du modèle métier et l'intégration entre les différentes couches sont assurées au travers de règles de convention (au lieu de configuration comme ça se faisait et se fait encore couramment). Bref, là où il faut 1 an de développement d'une application Web en Java par exemple, 3 mois au plus suffit avec la même mais avec RoR !

Toutefois, tout n'est pas parfait. Si RoR, et donc Grails, permet de développer aussi rapidement une application Web que PHP mais avec une qualité largement supérieur, les différentes couches applicatives sont liées et ne peuvent donc être réparties sur différents noeuds selon une architecture n-tiers. En effet, le framework lie le tout par un tissage de conventions qui cachent toute la mécanique d'intégration sous-jacente. Aussi, au fur et à mesure de l'enrichissement naturelle de l'application en fonctionnalités annexes à celles principales, les limites de l'architecture ainsi posée par le framework peuvent être vite atteintes et nécessiter une refonte plus classique, et d'autant plus s'il est alors nécessaire de l'inscrire dans une architecture d'entreprise existante (urbanisme). Néanmoins, Grails comme RoR peuvent être utilisés comme socle de développement d'applications SaaS (Software As A Service) et donc s'inscrire aisément dans une architecture d'entreprise SOA (Service-Oriented Architecture). (C'est par exemple sur quoi je travaille actuellement, et avec, entre autre, Grails.)

Grails est l'implémentation de la communauté Java à l'approche Ruby On Rails. Pour ce faire, au lieu de partir de rien, elle a eu l'intelligence et la sagesse de s'appuyer sur des frameworks existants et qui ont fait leur preuve :

  • Hibernate pour la gestion de la persistance,
  • Spring pour la gestion du cycle de vie des objets et des dépendances,
  • Ant pour la gestion de projet,
  • JUnit pour les tests unitaires et d'intégration,
  • HSQLDB et Jetty en vue des tests d'intégration et fonctionnelles,
  • SiteMesh pour la pagination Web,
  • etc.

Le tout s'appuyant sur un langage orienté objet et dynamique, Groovy, et sur l'approche DDD (Domain Driven Design).

Groovy est un langage fortement inspiré de Ruby et de Python. C'est un langage dynamique dans ses moindres aspects : dynamique dans son typage, mais aussi dynamique au sens où du code peut-être généré à chaud et ajouté dans les classes d'objets. Ci-dessous un exemple de code Groovy (tiré du site Web officiel du langage) :

class Complex {
  def re, im
  Complex (double real, double imaginary) {
    re = real
    im = imaginary
  }
  String toString() { "$re" + (im<0 ? '' : '+') + im + 'i' }
}

Le code ci-dessus définit une classe de nombres complexes. Le fait de définir les attributs re et im génère automatiquement les accesseurs :

def mycomplex = new Complex(3.2, 3.3)
mycomplex.re = 5
println mycomplex.re // affiche 5

Groovy dispose aussi de facilités de codage, comme par exemple l'écriture de document XML (exemple inspiré du site Web officiel du langage) :

import groovy.xml.MarkupBuilder
 
def writer = new StringWriter()
def xml = new MarkupBuilder(writer)
xml.records() {
  car(name:'HSV Maloo', make:'Holden', year:2006) {
    country('Australia')
    record(type:'speed', 'Production Pickup Truck with speed of 271kph')
  }
  car(name:'P50', make:'Peel', year:1962) {
    country('Isle of Man')
    record(type:'size', 'Smallest Street-Legal Car at 99cm wide and 59 kg in weight')
  }
  car(name:'Royale', make:'Bugatti', year:1931) {
    country('France')
    record(type:'price', 'Most Valuable Car at $15 million')
  }
}
println xml

Ce qui produit le XML suivant :

<records>
      <car name='HSV Maloo' make='Holden' year='2006'>
        <country>Australia</country>
        <record type='speed'>Production Pickup Truck with speed of 271kph</record>
      </car>
      <car name='P50' make='Peel' year='1962'>
        <country>Isle of Man</country>
        <record type='size'>Smallest Street-Legal Car at 99cm wide and 59 kg in weight</record>
      </car>
      <car name='Royale' make='Bugatti' year='1931'>
        <country>France</country>
        <record type='price'>Most Valuable Car at $15 million</record>
      </car>
</records>

Autre exemple de facilités de codage, avec les liste :

def myList = [] // équivalent à myList = new ArrayList()
myList << 3 // équivalent à myList.add(3)
myList.each { nb ->  // for(Integer nb: myList) {
   println nb      //     System.out.println(nb);    
}                    // }

Ces petits exemples ne sont que des aperçus des grandes possibilités de Groovy. Vous comprendrez donc pourquoi il a été choisi comme langage dans Grails en sus de Java, sachant qu'il reste compatible avec ce dernier (vous pouvez mixer du code Java dans du code Groovy et réutiliser des classes d'objets Groovy dans Java !)