0
Présentation de Grails<br />Un Framework de développement Web agile<br />page 2<br />N. ADOUANI - février 10<br />
Sommaire<br /><ul><li>Introduction
Un peu d’histoire
Architecture, principes et composantes de Grails
Grails et les méthodologies agiles
Démos
Conclusions</li></ul>page 3<br />N. ADOUANI - février 10<br />
Introduction<br />N. ADOUANI - février 10<br />page 4<br />Grails est un Framework de développement <br />Web, type MVC, d...
Objectifs<br />L’objectif de cette présentation est :<br /><ul><li>d’introduire le Framework Grails, son architecture et s...
de faire un rapprochement entre Grails et les méthodologies agiles
montrer des exemples d’intégration de Grails avec les Frameworks AJAX, FLEX, etc…</li></ul>N. ADOUANI - février 10<br />pa...
Un peu d’histoire<br />page 6<br />N. ADOUANI - février 10<br />
Un peu d’histoire<br />N. ADOUANI - février 10<br />page 7<br />Graeme Rocher : le fondateur du projet Grails<br />Guillau...
Un peu d’histoire<br />N. ADOUANI - février 10<br />page 8<br />Grails = Pluriel de « grail » en anglais = Les Graals, d’o...
Grails, plus de détails<br />page 9<br />N. ADOUANI - février 10<br />
L’architecture<br />page 10<br />Le langageGroovy<br />Plugin xfire<br />Plugin CMS<br />Plugin GAE<br />Plugin Flex<br />...
Principes de Grails (1)<br /><ul><li>Convention over configuration
Scaffolding (génération de code)
Tests unitaires
Les plugins</li></ul>N. ADOUANI - février 10<br />page 11<br />
Principes de Grails (2) Convention over configuration<br /><ul><li>Configuration basée sur les conventions (Convention ove...
Il est aussi possible d’utiliser des fichiers de config si le besoin se fait sentir
Exemple: le nom d’une classe persistante est identique au nom de la table correspondante dans une base de données.</li></u...
Principes de Grails (3)Scaffolding<br /><ul><li>Scaffolding ou (échafaudage en français) consiste à générer le code de l’a...
Cette technique est souvent utilisée pour générer les pages CRUD des applications selon le modèle MVC
Il existe deux types de scaffolding en Grails:
Dynamique : les contrôleurs et les vues sont générés en  « runtime » (au cours de l’exécution) =>  la modification du modè...
Statique : le code source des contrôleurs et des vues est généré lors du développement=> la modification du modèle métier ...
Principes de Grails (4)Tests unitaires<br /><ul><li>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 in...
Tests d’intégration: des tests qui ont accès à tout l’environnement de l’application (accès à la base de données, à la ses...
Tests fonctionnels automatisés de l’IHM, type Selenium ou FitNess</li></ul>N. ADOUANI - février 10<br />page 14<br />
Principes de Grails (5)Système de plugins<br /><ul><li>Grails est basé sur un système de Plugins qui permettent de s’intég...
Sécurité: Acegi
Mapping Objet Relationnel: JPA et JDO
Web Service : xfire, Spring WS
Web Flow : SpringWebFlow
Upcoming SlideShare
Loading in...5
×

Grails Un Framework Web Agile

7,930

Published on

Une présentation du Framework agile Grails

Published in: Technology
1 Comment
9 Likes
Statistics
Notes
No Downloads
Views
Total Views
7,930
On Slideshare
0
From Embeds
0
Number of Embeds
4
Actions
Shares
0
Downloads
38
Comments
1
Likes
9
Embeds 0
No embeds

No notes for slide

Transcript of "Grails Un Framework Web Agile"

  1. 1.
  2. 2. Présentation de Grails<br />Un Framework de développement Web agile<br />page 2<br />N. ADOUANI - février 10<br />
  3. 3. Sommaire<br /><ul><li>Introduction
  4. 4. Un peu d’histoire
  5. 5. Architecture, principes et composantes de Grails
  6. 6. Grails et les méthodologies agiles
  7. 7. Démos
  8. 8. Conclusions</li></ul>page 3<br />N. ADOUANI - février 10<br />
  9. 9. Introduction<br />N. ADOUANI - février 10<br />page 4<br />Grails est un Framework de développement <br />Web, type MVC, dit de « haute productivité ». <br />Il est construit autour de technologies qui <br />ont fait leurs preuves dans l’écosystème <br />Java/J2ee tel que Spring, Hibernate, Sitemesh<br />et autres.<br />Il est basé sur le langage dynamique Groovy et sur certains paradigmes du génie logiciel comme « la configuration basée sur les conventions »<br />
  10. 10. Objectifs<br />L’objectif de cette présentation est :<br /><ul><li>d’introduire le Framework Grails, son architecture et ses principes
  11. 11. de faire un rapprochement entre Grails et les méthodologies agiles
  12. 12. montrer des exemples d’intégration de Grails avec les Frameworks AJAX, FLEX, etc…</li></ul>N. ADOUANI - février 10<br />page 5<br />
  13. 13. Un peu d’histoire<br />page 6<br />N. ADOUANI - février 10<br />
  14. 14. Un peu d’histoire<br />N. ADOUANI - février 10<br />page 7<br />Graeme Rocher : le fondateur du projet Grails<br />Guillaume Laforge: le chef du projet Groovy<br />Ils ont créé la société G2One qui a été rachetée par SpringSource en Novembre 2008<br />
  15. 15. Un peu d’histoire<br />N. ADOUANI - février 10<br />page 8<br />Grails = Pluriel de « grail » en anglais = Les Graals, d’où le logo du Framework<br />Grails = Groovy on Rails par analogie au Framework Ruby on Rails<br />
  16. 16. Grails, plus de détails<br />page 9<br />N. ADOUANI - février 10<br />
  17. 17. L’architecture<br />page 10<br />Le langageGroovy<br />Plugin xfire<br />Plugin CMS<br />Plugin GAE<br />Plugin Flex<br />Plugin jQuery<br />Plugin Acegi<br />Plugin Maven<br />Plugin CouchDB<br />Grails<br />Plugin iWebKit<br />Plugin Searchable<br />Plugin RemotePagination<br />Plugin Quartz<br />HSQL db<br />JUnit<br />Jetty<br />Log4j<br />Java EE<br />Spring<br />Hibernate<br />SiteMesh<br />Le langage Java<br />Le java Development Kit (JDK)<br />La Java Virual Machine<br />N. ADOUANI - février 10<br />
  18. 18. Principes de Grails (1)<br /><ul><li>Convention over configuration
  19. 19. Scaffolding (génération de code)
  20. 20. Tests unitaires
  21. 21. Les plugins</li></ul>N. ADOUANI - février 10<br />page 11<br />
  22. 22. Principes de Grails (2) Convention over configuration<br /><ul><li>Configuration basée sur les conventions (Convention over configuration) est le principe selon lequel les applications utilisent des conventions à la place des fichiers de configuration.
  23. 23. Il est aussi possible d’utiliser des fichiers de config si le besoin se fait sentir
  24. 24. Exemple: le nom d’une classe persistante est identique au nom de la table correspondante dans une base de données.</li></ul>N. ADOUANI - février 10<br />page 12<br />
  25. 25. Principes de Grails (3)Scaffolding<br /><ul><li>Scaffolding ou (échafaudage en français) consiste à générer le code de l’application à partir de la définition des objets persistants
  26. 26. Cette technique est souvent utilisée pour générer les pages CRUD des applications selon le modèle MVC
  27. 27. Il existe deux types de scaffolding en Grails:
  28. 28. Dynamique : les contrôleurs et les vues sont générés en  « runtime » (au cours de l’exécution) => la modification du modèle ne demande pas de régénération de code
  29. 29. Statique : le code source des contrôleurs et des vues est généré lors du développement=> la modification du modèle métier nécessite une régénération de code</li></ul>N. ADOUANI - février 10<br />page 13<br />
  30. 30. Principes de Grails (4)Tests unitaires<br /><ul><li>Grails intègre par défaut le Framework JUnit pour les tests unitaires
  31. 31. Grails fait la différence entre:
  32. 32. 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’utiliser des objets mock (bouchons)
  33. 33. Tests d’intégration: des tests qui ont accès à tout l’environnement de l’application (accès à la base de données, à la session, la requete HTTP…
  34. 34. Tests fonctionnels automatisés de l’IHM, type Selenium ou FitNess</li></ul>N. ADOUANI - février 10<br />page 14<br />
  35. 35. Principes de Grails (5)Système de plugins<br /><ul><li>Grails est basé sur un système de Plugins qui permettent de s’intégrer avec différents Frameworks et librairies, pour couvrir multiples domaines:
  36. 36. Sécurité: Acegi
  37. 37. Mapping Objet Relationnel: JPA et JDO
  38. 38. Web Service : xfire, Spring WS
  39. 39. Web Flow : SpringWebFlow
  40. 40. RIA : Flex, frameworks, AJAX, Grails UI, ZK Framework
  41. 41. Les traitements en batch : Quartz
  42. 42. Cloud computing: Google AppEngine, Cloud Foundry
  43. 43. Base de données NoSQL: CouchDB, Neo4J
  44. 44. CMS</li></ul>N. ADOUANI - février 10<br />page 15<br />
  45. 45. PASSONS à la pratique<br />page 16<br />N. ADOUANI - février 10<br />
  46. 46. Groovy, le langage dynamique (1)<br /><ul><li>Groovy est le langage dynamique de référence dans le monde Java
  47. 47. Il offre en plus de la syntaxe Java classique, une syntaxe simplifiée et plus intuitive
  48. 48. Groovy est un langage orienté objet et peut être utilisé comme langage de script
  49. 49. Il est compilé vers du bytecode comme Java et interprété par la JVM</li></ul>N. ADOUANI - février 10<br />page 17<br />
  50. 50. Groovy, le langage dynamique (2)<br />Groovy offre de nouvelles possibilités pour les développeurs:<br />page 18<br />Les GStrings<br />Les maps<br />Les closures<br />Les boucles<br />Les listes<br />N. ADOUANI - février 10<br />
  51. 51. Premiers pas avec Grails<br /><ul><li>L’installation de Grails est toute simple:
  52. 52. Téléchargement des binaires de Grails
  53. 53. Renseignement de la variable d’environnement GRAILS_HOME
  54. 54. Grails est fourni avec un utilitaire qui permet d’exécuter des instructions en ligne de commande
  55. 55. grailscreate-appdemo
  56. 56. grailscreate-domain-class produit
  57. 57. grailscreate-controllerproduit
  58. 58. grailsgenerate-all produit
  59. 59. grailscreate-service produit
  60. 60. grailscreate-tag-lib monService
  61. 61. grailsrun-app
  62. 62. grailswar</li></ul>N. ADOUANI - février 10<br />page 19<br />
  63. 63. Structure d’une application Grails<br />La structure d’une application Grails est sous la forme suivante :<br /><ul><li>grails-app/controller : contient les contrôleurs
  64. 64. grails-add/views : contient les fichiers GSP des vues
  65. 65. grails-app/domain : contient les classes persistantes
  66. 66. src : contient les classes externes
  67. 67. test/unit : contient les tests unitaires
  68. 68. test/integration : contient les tests d’intégration
  69. 69. web-app : contient les ressources statiques de l’application
  70. 70. lib : contient les librairies tierces</li></ul>N. ADOUANI - février 10<br />page 20<br />
  71. 71. GORM, ou la persistance selon Grails (1)<br /><ul><li>GORM et l’acronyme de Grails ORM
  72. 72. C’est la brique de Grails qui gère l’accès aux bases de données et la persistance des classes de domaine.
  73. 73. GORM apporte une abstraction des fonctionnalités offertes par Hibernate
  74. 74. Permet de définir des objets persistants
  75. 75. Support des différents type d’association entre objet (One to One, One to Many, Many to One, Many to Many)
  76. 76. Possibilité de gestion des clés primaires composées ou de type séquence
  77. 77. Injection de méthodes dynamiquement pour requêter les bases de données
  78. 78. Possibilité d’utilisation du langage HQL
  79. 79. Utilisation plus simple de la librairie Criteria</li></ul>N. ADOUANI - février 10<br />page 21<br />
  80. 80. GORM, ou la persistance selon Grails (2)<br />Premier exemple de définition de classe persistante:<br /><ul><li>Classe avec deux propriétés persistantes
  81. 81. hasMany: définit une association one-to-many vers l’entité « Produit »
  82. 82. transients: définit une liste de propriétés non persistantes
  83. 83. constraints: permet de définir les règles de validation d’une instance de « Categorie »
  84. 84. Grails utilise l’ensemble des contraintes pour générer les vues dans le cadre du scaffolding et pour effectuer la validation des formulaires d’ajout et de modification d’une instance de « Categorie »</li></ul>N. ADOUANI - février 10<br />page 22<br />
  85. 85. GORM, ou la persistance selon Grails (3)<br />Deuxième exemple de définition de classe persistante:<br /><ul><li>Classe avec six propriétés persistantes
  86. 86. belongsTo: définit une association d’appartenance à « Categorie »
  87. 87. mapping: définit un ensemble de règles pour personnaliser le mapping avec la base de données
  88. 88. Grails crée par défaut une table avec le nom de la classe persistante, sinon avec la valeur du mapping « table »
  89. 89. Grails crée par défaut les colonnes de la table avec le nom des propriétés.
  90. 90. constraints: permet de définir les règles de validation d’une instance de « Categorie »</li></ul>N. ADOUANI - février 10<br />page 23<br />
  91. 91. GORM, ou la persistance selon Grails (4)<br /><ul><li>GORM injecte dans les classes persistantes, dynamiquement, des méthodes qui permettent de requêter la base de données, ces méthodes sont de différents types
  92. 92. count et countBy: retourne le nombre d’enregistrement d’une requête
  93. 93. findBy et findWhere : récupère un seul enregistrement
  94. 94. findAllBy, findAllWhere, getAll, listOrderBy, list : récupère plusieurs enregistrements
  95. 95. Les requêtes HQL peuvent être exécutées avec les méthodes :
  96. 96. find
  97. 97. findAll
  98. 98. executeQuery
  99. 99. Il existe aussi les méthodes save()et delete()</li></ul>N. ADOUANI - février 10<br />page 24<br />
  100. 100. GORM, ou la persistance selon Grails (5)<br />Exemples de requêtes GORM<br />N. ADOUANI - février 10<br />page 25<br />
  101. 101. Configuration des sources de données<br /><ul><li>Les accès aux données sont préconfigurés dans Grails dans le fichier config/DataSource.groovy
  102. 102. Grails prépare trois environnements différents pour les datasource :
  103. 103. Production
  104. 104. développement
  105. 105. Tests</li></ul>N. ADOUANI - février 10<br />page 26<br />
  106. 106. Les contrôleurs dans Grails<br />N. ADOUANI - février 10<br />page 27<br /><ul><li>Les contrôleurs Grails sont des classes qui se trouvent dans le dossier grails-app/controller
  107. 107. Le nom d’un contrôleur se termine, par convention, par « Controller »
  108. 108. Toute méthode dans un contrôleur est une action qui peut être appelée par l’url suivante: http://serveur/application/controleur/action/params
  109. 109. Les actions d’un contrôleur préparent les données qui seront consommées par la couche vue du modèle MVC</li></li></ul><li>Les vues dans Grails<br /><ul><li>Les vues dans Grails sont des fichiers GSP, acronyme de Groovy Server Pages
  110. 110. Les GSP permettent d’afficher les données récupérées par les contrôleurs
  111. 111. Grails offre un ensemble de taglib pour:
  112. 112. Les formulaires et éléments de formulaires: g:form, g:submit, g:textField…
  113. 113. Les traitements conditionnels et itératifs: g:each, g:collect, g:if, g:else, g:while…
  114. 114. L’affichage et l’inclusion d’autre vues: g:render, g:include
  115. 115. Dans les GSP, certaines variables sont disponibles comme :
  116. 116. request
  117. 117. response
  118. 118. params
  119. 119. flash
  120. 120. out</li></ul>N. ADOUANI - février 10<br />page 28<br />
  121. 121. Les services dans Grails<br /><ul><li>Service = Une classe dans le dossier grails-app/services et dont le nom se termine, par convention, par le mot « Service »
  122. 122. Un service sert à factoriser les traitements métier de l’application, au lieu de les garder dans les contrôleurs
  123. 123. Un service est par défaut transactionnel
  124. 124. Pour chaque service Grails crée un beanspring en mode singleton, dont le nom correspond au nom du service
  125. 125. Les services sont utilisables dans les contrôleurs et les classes du domaine.</li></ul>N. ADOUANI - février 10<br />page 29<br />
  126. 126. Création de taglib<br /><ul><li>La création de taglib personnalisées dans Grails se fait via l’ajout uniquement d’une classe dans grails-app/taglib avec un nom qui se termine par « Taglib »
  127. 127. Les taglibs ne nécessitent ni configuration, ni de fichier TLD</li></ul>N. ADOUANI - février 10<br />page 30<br />
  128. 128. Démos<br />N. ADOUANI - février 10<br />page 31<br />
  129. 129. Démos<br /><ul><li>Création d’une première application Grails (scaffoldstatic et dynamique)
  130. 130. Domaine : Catégorie, Produits (avec ou sans image/uplaod)
  131. 131. CRUD en scaffold dynamique
  132. 132. CRUD en scaffoldstatic de Catégorie
  133. 133. Pagination et tri des colonnes
  134. 134. Transformation de l’application générée en application AJAX
  135. 135. Utilisation des taglib Ajax (remoteLink, submitToRemote, formRemote)
  136. 136. Test le plugin remotePagination sur la page liste Catégorie et liste Produit
  137. 137. Création d’un service REST
  138. 138. Exposition d’un service REST qui offre la liste des categories
  139. 139. Exposition d’un service REST qui offre la liste des produits d’une catégorie</li></ul>N. ADOUANI - février 10<br />page 32<br />
  140. 140. Démos<br /><ul><li>Grails et Flex
  141. 141. Création d’un simple application FLEX (voire AIR)qui utilise les services REST créer précédemment
  142. 142. Liste des catégories
  143. 143. Liste des produits de chaque catégorie
  144. 144. Grails et Ajax (ExtJS)
  145. 145. Transformation des service REST de XML à JSON
  146. 146. Création d’un simple formulaire : choix de catégorie et affichage de la liste des produits correspondants
  147. 147. Grails et iPhone (iWebKit)
  148. 148. Créer une interface de liste catégorie
  149. 149. Une interface liste produit</li></ul>N. ADOUANI - février 10<br />page 33<br />
  150. 150. Grails et les méthodologies agiles<br />N. ADOUANI - février 10<br />page 34<br />
  151. 151. Grails et les méthodes agiles (1)<br /><ul><li>Question 1: Pourquoi choisir Grails pour faire un projet en agile?
  152. 152. Réponse : Les projets agiles ont à 90% une forte contrainte de temps (délais). À ce niveau,
  153. 153. Grails offre une grande rapidité lors du démarrage du projet;
  154. 154. Grace à la simplicité de Grails, les besoins fonctionnels sont développés plus rapidement;
  155. 155. Nouvelles fonctionnalités montrables plus facilement;
  156. 156. Le client peut faire ses feedback au plus tôt.</li></ul>N. ADOUANI - février 10<br />page 35<br />
  157. 157. Grails et les méthodes agiles (2)<br /><ul><li>Question 2: Quel est le niveau de flexibilité de Grails aux changements fonctionnels?
  158. 158. Réponse : Un projet agile par nature est itératif et incrémental, et dispose d’une grande fréquence de changement au niveau des besoins fonctionnels
  159. 159. Avec Grails les fonctionnalités sont rapidement mises en place et donc rapidement mise en question (si elle doivent être mises en question)=> « failfast » très rapide
  160. 160. Laisser tomber un code qui a couté 1 semaine de travail et plus simple que jeter un code qui coute facilement le double</li></ul>N. ADOUANI - février 10<br />page 36<br />
  161. 161. Grails et les méthodes agiles (3)<br /><ul><li>Question 3: Quel est l’apport de Grails à la qualité du code?
  162. 162. Réponse: en agile, la qualité n’est pas négociable, et les tests unitaires ou autres sont obligatoires pour la réussite de la réalisation et l’évolution du projet
  163. 163. Avec Grails, le langage utilisé est le langage dynamique Groovy.=> langage dynamique = les classes ont des comportements qui s’ajoutent en runtime=> le compilateur ne détecte pas toutes les anomalies lors des développements=> d’où la forte nécessité à couvrir le maximum de code, la solution est le TDD = tests unitaires avec une couverture maximale</li></ul>N. ADOUANI - février 10<br />page 37<br />
  164. 164. Conclusion<br /><ul><li>Avantages
  165. 165. Rapidité au démarrage et pendant des développements
  166. 166. Intégration avec presque tous les Frameworks de l’écosystème JAVA/J2EE grâce aux plugins
  167. 167. Permet de faciliter l’adoption des méthodologies agiles
  168. 168. Une très bonne documentation, une communauté très active et beaucoup de livres (en anglais)
  169. 169. Des success stories comme sky.com, linkedin.com
  170. 170. Inconvénients
  171. 171. Maturité pas totalement atteinte au niveau de IDE
  172. 172. Le compilateur Groovy ne détecte pas toute les erreurs de compilation, à cause des méthodes dynamiques => multiplier les tests unitaires et avoir une couverture de code maximale
  173. 173. Des difficultés pour débugguer dans les environnements de développement
  174. 174. La qualité des logs et des traces d’erreurs peuvent encore être améliorés</li></ul>N. ADOUANI - février 10<br />page 38<br />
  175. 175. Merci pour votre attentionDes Questions?<br />N. ADOUANI - février 10<br />page 39<br />
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×