�ݺ�ߣ

Page • © PROXYM-IT www.proxym-it.com

Demo Principes et composants Architecture Un peu d’histoire Introduction Conclusion Plan Mohamed Braham - 2010 Groovy www.proxym-it.com Page • © 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © PROXYM-IT

Mohamed Braham - 2010 Du Java à Groovy Etape 4 : Utiliser l’interpolation de variables Groovy supporte l’interpolation de variable à travers GString def 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © 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 • © 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) == 15 assert c.addAllJava(1,2,3,4,5) == 15 Groovy : Varargs en action www.proxym-it.com Page • © 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 • © 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 • © 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 • © PROXYM-IT

Mohamed Braham - 2010 def printIt = { println it } // 3 ways to iterate from 1 to 5 [1,2,3,4,5].each printIt 1.upto 5, printIt (1..5).each printIt // compare to a regular loop for( i in [1,2,3,4,5] ) printIt(i) // same thing but use a Range for( 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 • © PROXYM-IT

Mohamed Braham - 2010 Les listes def liste = [] liste << "Grails" liste.add "Groovy" println liste //[Grails, Groovy] println liste.size() //2 Les maps def map = [:] map.key1 = " Grails " map.put " key2", "Groovy " println map //[key1:Grails, key2:Groovy] println map.key2 //Groovy map.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 • © 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 • © 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 • © 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 • © 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 • © 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 instructions en 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 • © 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 • © 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 • © PROXYM-IT

�ݺ�ߣ

Présentation du framework Grails

More Related Content

Présentation du framework Grails