Your SlideShare is downloading. ×
ENIB 2013-2014 - CAI Web #3: Groovy
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Saving this for later?

Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime - even offline.

Text the download link to your phone

Standard text messaging rates apply

ENIB 2013-2014 - CAI Web #3: Groovy

134
views

Published on

Published in: Technology

0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
134
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
5
Comments
0
Likes
1
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Conception d'Applications Interactives : Applications Web et JEE Séance #3 Groovy
  • 2. Introduction à Groovy
  • 3. Origine James Strachan to Bob McWhirter in 2003: Wouldn’t it be “groovy” if we could have native syntax for lists, maps and regexs in Java like in most scripting languages? Wouldn’t it be “groovy” if we could have duck typing in Java? Wouldn’t it be “groovy” if we had closures and properties in Java?
  • 4. Groovy Langage de POO destiné à la plate-forme Java ● Inspiré de Python, Ruby et Smalltalk ● Syntaxe très proche de Java ● Compilé ○ soit à la volée dynamiquement ○ soit classiquement vers bytecode
  • 5. Groovy Langage de POO destiné à la plate-forme Java ● Typages statique et dynamique ● Support natif pour listes, maps, et expressions régulières ● Fermetures ou clôtures (closures) ● Surcharge des opérateurs http://groovy.codehaus.org/
  • 6. Intégration avec Java ○ Groovy génère du bytecode Java pour la JVM ■ Same strings, same regex S ■ Same APIs — JDK, collections, 3rd party, etc. ■ Same security model, same threading model ■ Same OO concepts ○ Compilation croisée ■ Compilateur groovyc pour Java et Groovy ■ Interopérabilité et mixité parfaite
  • 7. Objectifs de Groovy ● Faciliter la vie du développeur Java ○ Un sur-ensemble de Java ○ Très facile à apprendre ● Aussi rapide et sur que Java ○ Avec validation de typage et compilation statiques ● Expressif, concis et légible
  • 8. Un programme en Java public class HelloWorld { private String name; public void setName(String name) { this.name = name; } public String getName() { return name; } public String greet() { return quot;Hello quot;+ name; } public static void main(String[] args) { HelloWorld helloWorld = new HelloWorld(); helloWorld.setName("Groovy"); System.out.println(helloWorld.greet()); } }
  • 9. Un programme en Groovy public class HelloWorld { private String name; public void setName(String name) { this.name = name; } public String getName() { return name; } public String greet() { return quot;Hello quot;+ name; } public static void main(String[] args) { HelloWorld helloWorld = new HelloWorld(); helloWorld.setName("Groovy"); System.out.println(helloWorld.greet()); } }
  • 10. Le même programme bien récrit en Groovy class HelloWorld { String name def greet() { "Hello $name" } } def helloWorld = new HelloWorld(name: "Groovy") println helloWorld.greet()
  • 11. Le développeur Java, déjà un développeur Groovy ● Code Java valable Code Groovy valable ○ Dans 90% des cas ● Courbe d'apprentissage très douce
  • 12. Déclaration de classes ● Même aspect qu'une déclaration Java ○ Le modificateur par défaut est publique class HelloWorld { String name String greet() { "Hello $name" } }
  • 13. Plein de choses optionnelles ● Les points-virgules en fin de ligntye ● Le typage des variables et méthodes ● Les mots clés return et public ● Les parenthèses dans les appels aux méthodes
  • 14. Typage optionnel ● Possibilité d'utiliser le typage statique ○ Comme dans Java ● Possibilité d'utiliser le typage dynamique ○ en remplaçant le type par le mot clé def ● Pas besoin de def pour les paramètres formelles ○ pour les des méthodes ou closures def helloWorld = new HelloWorld(name: "Groovy")
  • 15. Appel aux méthodes ● Dans les appels aux méthodes avec des paramètres on peut omettre les parenthèses def a = "Toto" print(a) print a method(a, b) method a, b move(from:"ici", to:"là bas") move from:"ici", to:"là bas" list.each({ println it }) list.each(){ println it } list.each { println it }
  • 16. Scripts ● Script : du code Groovy non enfermé dans une déclaration de classe ○ Pas besoin d'une méthode main class HelloWorld { String name String greet() { "Hello $name" } } def helloWorld = new HelloWorld(name: "Groovy") println helloWorld.greet()
  • 17. Propriétés ● Les propriétés d'une classe sont déclarées comme attributs de la classe ○ Des getters et setters sont générés lors de la compilation/interprétation class Beer { String name String brewery String country double alcohol }
  • 18. Opérateurs
  • 19. Chaînes de caractères ● Exemples 'literal String' '''literal multiline String''' def lang = 'Groovy' "GString for $lang" "$lang has ${lang.size()} chars" """multiline GString with late eval at ${-> new Date()}""" text = "Hello text[0] text[0..4] text[0..<4] text[-1] text[-6..-1] World!" // returns "H" // returns "Hello" // returns "Hell" // returns "!" (last char) // "World!"(last 6 to last char)
  • 20. Gammes de valeurs ● Exemples assert (0..10).contains(5) assert (0.0..10.0).containsWithinBounds(3.5) for (item in 0..10) { println item } for (item in 10..0) { println item } (0..<10).each { println it }
  • 21. Listes et maps ● Listes et maps sont des éléments de première classe dans Groovy ○ Syntaxe adaptée, simplification // Une liste vide def a=[] //Ajoutons des élements a.add("toto") a.add("titi") //Listons les contenus print a //Résultat : [toto, titi]
  • 22. Manipulation des listes [1,2,3,4] == (1..4) [1,2,3] + [1] == [1,2,3,1] [1,2,3] << 1 == [1,2,3,1] [1,2,3,1] - [1] == [2,3] [1,2,3] * 2 == [1,2,3,1,2,3] [1,[2,3]].flatten() == [1,2,3] [1,2,3].reverse() == [3,2,1] [1,2,3].disjoint([4,5,6]) == true [1,2,3].intersect([4,3,1]) == [3,1] [1,2,3].collect{ it+3 } == [4,5,6] [1,2,3,1].unique().size() == 3 [1,2,3,1].count(1) == 2 [1,2,3,4].min() == 1 [1,2,3,4].max() == 4 [1,2,3,4].sum() == 10 [4,2,1,3].sort() == [1, 2, 3, 4] [4,2,1,3].findAll{it%2 == 0} == [4,2] [['a', 'b'], [1, 2]].transpose() == [['a', 1], ['b', 2]]
  • 23. Manipulation des listes def anims = ['cat','kangaroo','koala'] assert anims[2] == 'koala' assert anims[0..1,2] == ['cat','kangaroo','koala'] def kanims = anims[1..2] assert anims.findAll{it =~ /k.*/} == kanims assert anims.find{ it =~ /k.*/} == kanims[0] assert anims.grep(~/k.*/) == kanims assert anims.join(' ') == 'cat kangaroo koala' anims.remove(1) assert anims == ['cat','koala'] anims.each { println it } Des indexes négatives indiquent la fin de la liste def list = [0,1,2] assert list[-1] == 2 assert list[-1..0] == list.reverse() assert list == [list.head()] + list.tail()
  • 24. Maps Syntaxe semblable à celle des listes def map = [a:0, b:1] def empty = [:] Pour récupérer une valeur on peut : ● mettre la clé entre crochets ● mettre la clé comme une propriété de la map ● utiliser la méthode get assert map['a'] == 0 assert map.b == 1 map['a'] = 'x' map.b = 'y' assert map == [a:'x', b:'y'] assert map.c == null assert map.get('c', 2) == 2 assert map.c == 2
  • 25. Manipulation des maps Des méthodes d'itération permettent de parcourir la map en s'appliquant à chaque couple clé/valeur map.each { entry -> println entry.key println entry.value } map.each { key, value -> println "$key $value" } for (entry in map) { println "$entry.key $entry.value" } assert map.every { it.value.size() == 1 } assert map.any { it.key % 4 == 0 }
  • 26. Closures (fermetures) ● Des fonctions qui capturent des références à l'environnement dans lequel ils s'exécutent ○ Des objets de première classe en Groovy a = [1,2,3] a.each({ x -> println x * x }) a.each { x -> println x * x } a.each { println it * it } def squareIt = { println it * it } a.each(squareIt) a.each squareIt
  • 27. Closures (fermetures) ● Paramètres dans une closure
  • 28. Comment apprendre Groovy ? Je ne vais pas passer une heure à vos passer des slides ● Méthode peu efficace Tentons quelque chose de nouveau ● Approche pratique Essayons les Groovy Koans ! Groovy Koans ? Kesaco ?
  • 29. Koans Une nouvelle façon d'apprendre un langage ● Des petits cas pratiques ○ Sous la forme de suites de tests unitaires ● Chaque cas orienté pour un concept ○ Et un ensemble de tests qui ne passent pas ● Objectif : réparer les tests pour qu'ils passent ○ Et apprendre le langage en passant Méthode d'apprentissage différente et éfficace !
  • 30. Groovy Koans : Learn Groovy with the Koans http://groovykoans.org/
  • 31. C'est l'heure des Groovy Koans !