Groovy and Grails

Le langage Groovy

Sur cette page vous découvrirez les particularités du langage groovy.

Les chaînes de caractères

On distingue trois nouveaux types de chaines de caractères.




Constructeur

Voici un exemple de script groovy. On y voit la déclaration d'un Groovy Bean ainsi que deux utilisations du constructeur par défaut.

package fr.umlv.xpose.groovy;


class Person {

def firstname;

def lastname;

String toString(){

return firstname+" "+lastname;

}

}


def teacher = new Person(firstname:"Etienne" , lastname:"Duris");


HashMap<String,String> resquestParameters = new HashMap<String,String>();

resquestParameter.putAt("firstname", "Etienne");

resquestParameter.putAt("lastname", "Duris");


def teacher2 = new Person(resquestParameters);


println teacher; // Etienne Duris

println teacher2; // Etienne Duris

Dans chaque Groovy Bean, il existe un constructeur qui prend en argument une Map et qui va utiliser les setters correspondant à chaque clé de la Map pour initialiser les champs du Groovy Bean.
Dans les deux exemples, on utilise une Map en argument. Dans le premier exemple, c'est une déclaration simplifiée de la Map.




Les Méthodes

Elles ne sont pas si différentes des méthodes que l'on connait en Java.
Les seules différences sont les suivantes :

Une autre différence par rapport au Java est qu'il possible d'en mettre a l'extérieur des classes. Lorsque c'est le cas on les nomme "fonction" car elles se comportent comme telle.




Les Clôtures

Clôture vient du mot anglais "closure". On retrouve ce type de structure dans d'autres langages.

La clôture est un des éléments les plus intéressants dans le langage groovy. Cela ressemble à des méthodes, mais ça n'en est pas.
Une clôture est avant tout un objet issu d'une classe interne. Cet objet possède une méthode call qui va exécuter toutes les instructions qui sont entre les accolades.

Voici un exemple de clôture sans argument :

def hello = { println "Hello world !" }

hello() // Hello world !

Avec des arguments :

def hello = { name1, name2, name3 -> println "Hello ${name1}, ${name2}, ${name3} !" }

hello("Martin", "Etienne", "DR") // Hello Martin, Etienne, DR !

hello "Martin","Etienne","DR" // Hello Martin, Etienne, DR !

Si on utilise une clôture avec des arguments, l'objet possèdera des champs pour chaque arguments.
Comme on peut le voir dans l'exemple précédant, les arguments sont déclarés avant les instructions en les séparant par une flèche "->".

Comme pour les méthodes, à partir du moment où la clôture possède un argument, celle-ci peut être appelée sans les parenthèses.

Il est aussi possible de passer une clôture à une méthode. C'est d'ailleurs son intérêt principal.
L'utilité des clôtures est le même que les pointeurs de fonction en C, ou que les "delegates" en C#. En voici un exemple :

class Student {

def name;

def doIt(argument){

argument(name);

}

}


def martin = new Student(name : "Martin");


martin.doIt {

studentName -> println "Hello ${studentName} !"

}


// Hello Martin !

Dans cet exemple, on peut voir que j'utilise la méthode "doIt" sans les parenthèses, en lui passant une clôture en argument.
Dans la méthode, j'utilise la clôture en lui passant un champ de la classe en argument.




Les Collections

En Groovy, l'utilisation des collections est simplifiée. On retrouve les trois collections les plus utilisées en Java :

Il existe aussi un nouveau type de collection qui est présent pour simplifier le développement.




Les Opérateurs




Les expressions régulières.

Et oui, ce n'est pas fini avec les nouveaux opérateurs ! Il existe d'autres opérateurs qui sont destinés aux expressions régulières.
Il faut toujours garder à l'esprit que ces opérateurs ne sont que des "raccourcis" par rapport aux classes Java déjà existantes qui permettent de manipuler les expressions régulières.