Présentation du framework Grails

Page 1 • © PROXYM-IT

www.proxym-it.com

http://www.proxym-it.com/

Demo

Principes et composants

Architecture

Un peu d’histoire

Introduction

Conclusion

Plan

Mohamed Braham - 2010

Groovy

www.proxym-it.com



Grails est un Framework open source de développement agile d’applications web basé sur le langage Groovy.

• Grails est une plateforme qui met en œuvre la pile complète de système de construction jusqu'à la couche ORM

• Grails s'appuie sur les technologies existantes comme, Groovy Spring, Hibernate, Quartz, etc …

• Grails est la contraction de Groovy on Rails pour dire qu'il s'inspire du framework ruby on rails.

• Grails = pluriel de « grail » en anglais = les graals


Introduction

www.proxym-it.com



Graeme Rocher : le fondateur Guillaume Laforge : le chef du projet Grails de projet Groovy

Ils ont crée la société G2One qui a été rachetée par SpringSource en Novembre 2008, qui a été, à son tour, rachetée par VMware

en Août 2009

Mohamed Braha m - 2010

Un peu d’histoire

www.proxym-it.com



Est un langage dynamique de référence dans le monde Java

Offre en plus de la syntaxe Java classique, une syntaxe

simplifiée et plus intuitive

Est un langage orienté objet et peut être utilisé comme un langage de script, donc il est facile à lire et à maintenir

Groovy est un langage agile dynamique qui est compilé vers du byte-code comme Java et interprété par la JVM


Groovy

www.proxym-it.com



Groovy augmente la productivité de développeurs en réduisant le code d’échafaudage (Scaffolding) lors de développement des applications webs

Groovy simplifie les tests en supportant les tests unitaires et les objet mock.

Groovy s’intègre sans couture avec tous les objets et les bibliothèques Java.

Groovy est basé sur la puissance de Java mais il a des caractéristiques puissantes inspirées d’autres langages comme Ruby, Python et Smalltalk.

Grails propose le principe : "convention over configuration" ce qui permet de réduire la complexité du développement.


Groovy

www.proxym-it.com




Du Java à Groovy : Hello World en Java

public class HelloWorld { String name;

public void setName(String name) { this.name = name; } public String getName(){ return name; }

public String greet() { return “Hello “+ name; }

public static void main(String args[]){ HelloWorld helloWorld = new HelloWorld() helloWorld.setName(“Groovy”) System.err.println( helloWorld.greet() ) }}

www.proxym-it.com








Du Java à Groovy : Hello World en Groovy

www.proxym-it.com




Du Java à Groovy

Etape 1 : Débarrassons-nous du bruit

Tout est public en Groovy à moins qu’il soit défini autrement

Les points-virgules à la fin des lignes sont optionnels

www.proxym-it.com




class HelloWorld { String name

void setName(String name) { this.name = name } String getName(){ return name }

String greet() { return "Hello "+ name }

static void main(String args[]){ HelloWorld helloWorld = new HelloWorld() helloWorld.setName("Groovy") System.err.println( helloWorld.greet() ) }}

Du Java à Groovy : Résultat de l’étape 1

www.proxym-it.com




Du Java à Groovy

Etape 2 : Débarrassons-nous du passe-partout

Programmer un JavaBean nécessite un couple de get/set pour chaque propriété. Nous savons tous ceci. Laissez Groovy nous écrire ça!

Main() nécessite toujours comme paramètre String[ ]. Laissez la définition de la méthode soit plus courte et avec un type optionnel.

L’impression sur la console est si commune, peut-on obtenir une version plus courte aussi? (réduction de la syntaxe de l’impression sur la concsole)

www.proxym-it.com





String greet() { return "Hello "+ name }

static void main( args ){ HelloWorld helloWorld = new HelloWorld() helloWorld.setName("Groovy") println( helloWorld.greet() ) }}


www.proxym-it.com




Du Java à Groovy

Etape 3 : Introduire des types dynamiques

Utiliser le mot clé « def » quand on ne soucie pas du type d’une variable, penser au mot clé var en JavaScript

Groovy permet de configurer le type correct, cela s’appelle typage canard « duck typing »

www.proxym-it.com





def greet() { return "Hello "+ name }

static def main( args ){ def helloWorld = new HelloWorld() helloWorld.setName("Groovy") println( helloWorld.greet() ) }}


www.proxym-it.com




Du Java à Groovy

Etape 4 : Utiliser l’interpolation de variables

Groovy supporte l’interpolation de variable à travers GStringdef name = "Grails" println "Hello ${name}"//Hello Grails

Il fonctionne comme vous attendez dans d’autres langages

Précéder toute expression Groovy avec ${ } dans une chaine de caractère « String »

www.proxym-it.com





def greet(){ return "Hello ${name}" }

static def main( args ){ def helloWorld = new HelloWorld() helloWorld.setName("Groovy") println( helloWorld.greet() ) }}


www.proxym-it.com




Du Java à Groovy

Etape 5 : Débarrassons-nous des autres mots-clés

Le mot-clé return est facultatif, la valeur de retour d’une méthode sera la dernière expression évaluée

On n’a pas besoin d’utiliser def pour une méthode statique

www.proxym-it.com





def greet(){ "Hello ${name}" }

static main( args ){ def helloWorld = new HelloWorld() helloWorld.setName("Groovy") println( helloWorld.greet() ) }}


www.proxym-it.com




Du Java à Groovy

Etape 6 : POJOs sur les stéroïdes

Non seulement les POJOs (on les appelle POGOs en Groovy) écrivent leurs propres accesseurs de propriété, ils fournissent également un constructeur par défaut avec des paramètres nommés (type de)

POGOs soutiennent le tableau sous-script (bean[prop]) et la notation pointée (bean.prop) pour accéder aux propriétés

www.proxym-it.com





def greet(){ "Hello ${name}" }

static main( args ){ def helloWorld = new HelloWorld(name:"Groovy") helloWorld.name = "Groovy" helloWorld["name"] = "Groovy" println( helloWorld.greet() ) }}


www.proxym-it.com




Du Java à Groovy

Etape 7 : Groovy soutient les scripts

Même si Groovy compile les classes en byte-code java, il prend également en charge des scripts, ils sont également compiler vers du byte-code java

Scripts permettent les classes à se définir n’importe où sur eux

Scripts prennent en charge les paquets, après tout, ils sont également des valides classes Java

www.proxym-it.com




class HelloWorld {

String name

def greet() { "Hello $name" }

}

def helloWorld = new HelloWorld(name:"Groovy")

println helloWorld.greet()


www.proxym-it.com




Du Java à Groovy : Résultat final





class HelloWorld {

String name

def greet() { "Hello $name" }

}

def helloWorld = new HelloWorld(name:"Groovy")

println helloWorld.greet()

www.proxym-it.com




Java est Groovy, Groovy est Java

L’apprentissage du Groovy par les développeurs Java commence par la syntaxe Java puis passer à une syntaxe Groovy que vous sentez confortable

Presque 99% du code Java est un code Groovy, ce qui signifie que vous pouvez dans la plupart des changements renommer les *.java en *.groovy et il fonctionne.

www.proxym-it.com




Groovy et JDK 5

Groovy supporte les annotations JSR 175 (comme pour Java). En effet, c’est le deuxième langage sur la plate-forme Java qui peut le faire.

Enumérations Génériques Import Statique La boucle for Varargs peut être déclaré comme en Java (avec la

notation de trois points) ou à travers la convention :

si le dernier paramètre d’une méthode est de type Object[ ] donc Varargs peut être utilisé.

www.proxym-it.com




class Calculator { def addAllGroovy( Object[] args ){ int total = 0 for( i in args ) { total += i } total } def addAllJava( int... args ){ int total = 0 for( i in args ) { total += i } total }}

Calculator c = new Calculator()assert c.addAllGroovy(1,2,3,4,5) == 15assert c.addAllJava(1,2,3,4,5) == 15

Groovy : Varargs en action

www.proxym-it.com




Groovy : Les Closures

Une closure est un bout de code anonyme pouvant prendre des arguments, renvoyer une valeur et utiliser des variables ou des méthodes déclarées dans la portée qui l’englobe.

Le but des closures est de permettre une écriture du code plus concise et lisible.

En effet une closure a toujours au moins un argument implicite nommé it qui serait disponible dans le corps de la closure si aucun paramètre explicite n’est défini pour celle-ci.

www.proxym-it.com




Groovy : Les Closures

def greet = { name -> println “Hello $name” }greet( “Groovy” )// prints Hello Groovy

def greet = { println “Hello $it” }greet( “Groovy” )// prints Hello Groovy

def iCanHaveTypedParametersToo = { int x, int y -> println “coordinates are ($x,$y)”}

def myActionListener = { event -> // do something cool with event} as ActionListener

www.proxym-it.com




Groovy : Itérateurs partout

Comme dans Ruby, vous pouvez utiliser les itérateurs dans presque n’importe quel contexte.

Groovy permet de configurer ce qu’il faut faire dans chaque cas. Les itérateurs exploitent de la puissance des closures, tous les Itérateurs acceptent une closure comme paramètre.

Les Itérateurs vous débarassent du fardeau de construction de bouclage.

www.proxym-it.com




def printIt = { println it }// 3 ways to iterate from 1 to 5[1,2,3,4,5].each printIt1.upto 5, printIt(1..5).each printIt

// compare to a regular loopfor( i in [1,2,3,4,5] ) printIt(i)// same thing but use a Rangefor( i in (1..5) ) printIt(i)

[1,2,3,4,5].eachWithIndex { v, i -> println "list[$i] => $v" }

// list[0] => 1// list[1] => 2// list[2] => 3// list[3] => 4// list[4] => 5

Groovy : Itérateurs partout

www.proxym-it.com




Les listesdef liste = []liste << "Grails" liste.add "Groovy" println liste //[Grails, Groovy]println liste.size() //2

Les mapsdef map = [:]map.key1 = " Grails " map.put " key2", "Groovy " println map //[key1:Grails, key2:Groovy]println map.key2 //Groovymap.eachWithIndex { it, i -> println "${i} : ${it.key} = ${it.value}"}//0 : key1 = Grails//1 : key2 = Groovy

Groovy : Les listes et les maps

www.proxym-it.com



Spring Spring HibernateHibernateGroovyGroovyQuartzQuartzSitemeshSitemeshJettyJettyAntAntJavaJava


Architecture

www.proxym-it.com




Architecture

www.proxym-it.com



• Grails intègre par défaut le Framework JUnit pour les tests unitaires.

• Grails fait la différence entre : Tests unitaires : des tests qui n’ont aucune dépendance,

notamment vers la base de données, le conteneur de Servlet, les interactions HTTP, les WS s’il y en a.

nécessité d’utilisation des objets mock (bouchons)

Tests d’intégration : des tests qui ont accès à tout l’environnement de l’application.

Tests fonctionnels automatisés de l’IHM, type Selenium


Architecture

www.proxym-it.com



• Grails est basé sur un système des Plugins qui permettent de s’intégrer avec différents Frameworks et librairies, pour couvrir plusieurs domaines :

Sécurité : Acegi Mapping Objet Relationnel : JPA et JDO Web Service : xfire, Spring WS Web Flow : Spring WebFlow RIA : Flex, Ajax, Grails UI, ZK Framework Les traitement en batch : Quartz Cloud Computing : Google App Engine, Cloud Foundry Base de données : NoSQL, CouchDB, Neo4J CMS : cms


Architecture

www.proxym-it.com



• DRY (Ne pas se répéter) : les éléments de l’application ne doivent être que dans un seul endroit.

• Convention over Configuration : ‘Configuration basée sur les Convention’. Les applications utilisent des conventions à la place des fichiers de configuration.

• Architecture orientée modèle : le point d’entrée d’un développement Grails est la description formelle des classes représentant le domaine métier ainsi que leurs dépendances.

• Scaffolding : Prototypage : un mécanisme de génération automatique d’un prototype d’application aux utilisateurs dés la formation des classes de domaine.

• Exploiter la puissance de la JVM : Grails exploite totalement la

richesse et la puissance du monde java.


Principes et Composants

www.proxym-it.com



• Scaffolding consiste à générer le code de l’application à partir de la définition des objets persistants.

• Cette technique est souvent utilisée pour générer les pages CRUD des applications selon le modèle MVC.

• En Grails, il existe deux types de Scaffolding :

Dynamique : les contrôleurs et les vues sont générés en «runtime » (au cours de l’exécution)

Statique : le code source des contrôleurs et des vues sont générés lors du développement.



www.proxym-it.com



L’installation du Grails est toute simple :

- Téléchargement des binaires de Grails - Renseignement de la variable d’environnement GRAILS_HOME

Grails est fourni avec un utilitaire qui permet d’exécuter des instructionsen ligne de commande :

grails create-app demo grails create-domain-class produit grails create-controller produit grails generate-all produit grails create-service produit grails create-tag-lib mon Service grails run-app grails war



www.proxym-it.com





www.proxym-it.com





www.proxym-it.com





www.proxym-it.com





www.proxym-it.com




Application Démo :

- Commencer avec un Scaffolding dynamique

- In-memory base de données

- Un conteneur de servlet fourni

- Un ensemble des targets communs pour la construction :

run-app, test-app, war, etc

- Shell interactive et console

- Fichier du projet IDE

- Etc ...

Demo

www.proxym-it.com




Grails est :

Rapide : il assure une productivité extrême pour les applications webs Java

Dynamique : il est le premier Framework de développement web dynamique pour la JVM

Robuste : il est basé sur Spring, puissant, agile et rapide

Conclusion

www.proxym-it.com



Documents

Présentation du framework Grails