Upload
proxym-it
View
1.521
Download
4
Embed Size (px)
Citation preview
Demo
Principes et composants
Architecture
Un peu d’histoire
Introduction
Conclusion
Plan
Mohamed Braham - 2010
Groovy
www.proxym-it.com
Page 2 • © PROXYM-IT
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
Mohamed Braham - 2010
Introduction
www.proxym-it.com
Page 3 • © PROXYM-IT
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
Page 4 • © PROXYM-IT
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
Mohamed Braham - 2010
Groovy
www.proxym-it.com
Page 5 • © PROXYM-IT
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.
Mohamed Braham - 2010
Groovy
www.proxym-it.com
Page 6 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 7 • © PROXYM-IT
Mohamed Braham - 2010
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() ) }}
Du Java à Groovy : Hello World en Groovy
www.proxym-it.com
Page 8 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 9 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 10 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 11 • © PROXYM-IT
Mohamed Braham - 2010
class HelloWorld { String name
String greet() { return "Hello "+ name }
static void main( args ){ HelloWorld helloWorld = new HelloWorld() helloWorld.setName("Groovy") println( helloWorld.greet() ) }}
Du Java à Groovy : Résultat de l’étape 2
www.proxym-it.com
Page 12 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 13 • © PROXYM-IT
Mohamed Braham - 2010
class HelloWorld { String name
def greet() { return "Hello "+ name }
static def main( args ){ def helloWorld = new HelloWorld() helloWorld.setName("Groovy") println( helloWorld.greet() ) }}
Du Java à Groovy : Résultat de l’étape 3
www.proxym-it.com
Page 14 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 15 • © PROXYM-IT
Mohamed Braham - 2010
class HelloWorld { String name
def greet(){ return "Hello ${name}" }
static def main( args ){ def helloWorld = new HelloWorld() helloWorld.setName("Groovy") println( helloWorld.greet() ) }}
Du Java à Groovy : Résultat de l’étape 4
www.proxym-it.com
Page 16 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 17 • © PROXYM-IT
Mohamed Braham - 2010
class HelloWorld { String name
def greet(){ "Hello ${name}" }
static main( args ){ def helloWorld = new HelloWorld() helloWorld.setName("Groovy") println( helloWorld.greet() ) }}
Du Java à Groovy : Résultat de l’étape 5
www.proxym-it.com
Page 18 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 19 • © PROXYM-IT
Mohamed Braham - 2010
class HelloWorld { String name
def greet(){ "Hello ${name}" }
static main( args ){ def helloWorld = new HelloWorld(name:"Groovy") helloWorld.name = "Groovy" helloWorld["name"] = "Groovy" println( helloWorld.greet() ) }}
Du Java à Groovy : Résultat de l’étape 6
www.proxym-it.com
Page 20 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 21 • © PROXYM-IT
Mohamed Braham - 2010
class HelloWorld {
String name
def greet() { "Hello $name" }
}
def helloWorld = new HelloWorld(name:"Groovy")
println helloWorld.greet()
Du Java à Groovy : Résultat de l’étape 7
www.proxym-it.com
Page 22 • © PROXYM-IT
Mohamed Braham - 2010
Du Java à Groovy : Résultat final
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() ) }}
class HelloWorld {
String name
def greet() { "Hello $name" }
}
def helloWorld = new HelloWorld(name:"Groovy")
println helloWorld.greet()
www.proxym-it.com
Page 23 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 24 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 25 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 26 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 27 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 28 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 29 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 30 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 31 • © PROXYM-IT
Spring Spring HibernateHibernateGroovyGroovyQuartzQuartzSitemeshSitemeshJettyJettyAntAntJavaJava
Mohamed Braham - 2010
Architecture
www.proxym-it.com
Page 32 • © PROXYM-IT
Mohamed Braham - 2010
Architecture
www.proxym-it.com
Page 33 • © PROXYM-IT
• 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
Mohamed Braham - 2010
Architecture
www.proxym-it.com
Page 34 • © PROXYM-IT
• 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
Mohamed Braham - 2010
Architecture
www.proxym-it.com
Page 35 • © PROXYM-IT
• 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.
Mohamed Braham - 2010
Principes et Composants
www.proxym-it.com
Page 36 • © PROXYM-IT
• 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.
Mohamed Braham - 2010
Principes et Composants
www.proxym-it.com
Page 37 • © PROXYM-IT
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
Mohamed Braham - 2010
Principes et Composants
www.proxym-it.com
Page 38 • © PROXYM-IT
Mohamed Braham - 2010
Principes et Composants
www.proxym-it.com
Page 39 • © PROXYM-IT
Mohamed Braham - 2010
Principes et Composants
www.proxym-it.com
Page 40 • © PROXYM-IT
Mohamed Braham - 2010
Principes et Composants
www.proxym-it.com
Page 41 • © PROXYM-IT
Mohamed Braham - 2010
Principes et Composants
www.proxym-it.com
Page 42 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 43 • © PROXYM-IT
Mohamed Braham - 2010
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
Page 44 • © PROXYM-IT