• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Grails Un Framework Web Agile
 

Grails Un Framework Web Agile

on

  • 8,750 views

Une présentation du Framework agile Grails

Une présentation du Framework agile Grails

Statistics

Views

Total Views
8,750
Views on SlideShare
8,240
Embed Views
510

Actions

Likes
8
Downloads
0
Comments
1

2 Embeds 510

http://www.nabiladouani.fr 473
http://www.slideshare.net 37

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

CC Attribution-NoDerivs LicenseCC Attribution-NoDerivs License

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel

11 of 1 previous next

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Grails Un Framework Web Agile Grails Un Framework Web Agile Presentation Transcript

    • Présentation de Grails
      Un Framework de développement Web agile
      page 2
      N. ADOUANI - février 10
    • Sommaire
      • Introduction
      • Un peu d’histoire
      • Architecture, principes et composantes de Grails
      • Grails et les méthodologies agiles
      • Démos
      • Conclusions
      page 3
      N. ADOUANI - février 10
    • Introduction
      N. ADOUANI - février 10
      page 4
      Grails est un Framework de développement
      Web, type MVC, dit de « haute productivité ».
      Il est construit autour de technologies qui
      ont fait leurs preuves dans l’écosystème
      Java/J2ee tel que Spring, Hibernate, Sitemesh
      et autres.
      Il est basé sur le langage dynamique Groovy et sur certains paradigmes du génie logiciel comme « la configuration basée sur les conventions »
    • Objectifs
      L’objectif de cette présentation est :
      • d’introduire le Framework Grails, son architecture et ses principes
      • 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…
      N. ADOUANI - février 10
      page 5
    • Un peu d’histoire
      page 6
      N. ADOUANI - février 10
    • Un peu d’histoire
      N. ADOUANI - février 10
      page 7
      Graeme Rocher : le fondateur du projet Grails
      Guillaume Laforge: le chef du projet Groovy
      Ils ont créé la société G2One qui a été rachetée par SpringSource en Novembre 2008
    • Un peu d’histoire
      N. ADOUANI - février 10
      page 8
      Grails = Pluriel de « grail » en anglais = Les Graals, d’où le logo du Framework
      Grails = Groovy on Rails par analogie au Framework Ruby on Rails
    • Grails, plus de détails
      page 9
      N. ADOUANI - février 10
    • L’architecture
      page 10
      Le langageGroovy
      Plugin xfire
      Plugin CMS
      Plugin GAE
      Plugin Flex
      Plugin jQuery
      Plugin Acegi
      Plugin Maven
      Plugin CouchDB
      Grails
      Plugin iWebKit
      Plugin Searchable
      Plugin RemotePagination
      Plugin Quartz
      HSQL db
      JUnit
      Jetty
      Log4j
      Java EE
      Spring
      Hibernate
      SiteMesh
      Le langage Java
      Le java Development Kit (JDK)
      La Java Virual Machine
      N. ADOUANI - février 10
    • Principes de Grails (1)
      • Convention over configuration
      • Scaffolding (génération de code)
      • Tests unitaires
      • Les plugins
      N. ADOUANI - février 10
      page 11
    • Principes de Grails (2) Convention over configuration
      • 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.
      • 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.
      N. ADOUANI - février 10
      page 12
    • Principes de Grails (3)Scaffolding
      • Scaffolding ou (échafaudage en français) 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
      • 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èle ne demande pas de régénération de code
      • 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
      N. ADOUANI - février 10
      page 13
    • Principes de Grails (4)Tests unitaires
      • 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’utiliser des objets mock (bouchons)
      • 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…
      • Tests fonctionnels automatisés de l’IHM, type Selenium ou FitNess
      N. ADOUANI - février 10
      page 14
    • Principes de Grails (5)Système de plugins
      • 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:
      • Sécurité: Acegi
      • Mapping Objet Relationnel: JPA et JDO
      • Web Service : xfire, Spring WS
      • Web Flow : SpringWebFlow
      • RIA : Flex, frameworks, AJAX, Grails UI, ZK Framework
      • Les traitements en batch : Quartz
      • Cloud computing: Google AppEngine, Cloud Foundry
      • Base de données NoSQL: CouchDB, Neo4J
      • CMS
      N. ADOUANI - février 10
      page 15
    • PASSONS à la pratique
      page 16
      N. ADOUANI - février 10
    • Groovy, le langage dynamique (1)
      • Groovy est le langage dynamique de référence dans le monde Java
      • Il offre en plus de la syntaxe Java classique, une syntaxe simplifiée et plus intuitive
      • Groovy est un langage orienté objet et peut être utilisé comme langage de script
      • Il est compilé vers du bytecode comme Java et interprété par la JVM
      N. ADOUANI - février 10
      page 17
    • Groovy, le langage dynamique (2)
      Groovy offre de nouvelles possibilités pour les développeurs:
      page 18
      Les GStrings
      Les maps
      Les closures
      Les boucles
      Les listes
      N. ADOUANI - février 10
    • Premiers pas avec Grails
      • L’installation de 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
      • grailscreate-appdemo
      • grailscreate-domain-class produit
      • grailscreate-controllerproduit
      • grailsgenerate-all produit
      • grailscreate-service produit
      • grailscreate-tag-lib monService
      • grailsrun-app
      • grailswar
      N. ADOUANI - février 10
      page 19
    • Structure d’une application Grails
      La structure d’une application Grails est sous la forme suivante :
      • grails-app/controller : contient les contrôleurs
      • grails-add/views : contient les fichiers GSP des vues
      • grails-app/domain : contient les classes persistantes
      • src : contient les classes externes
      • test/unit : contient les tests unitaires
      • test/integration : contient les tests d’intégration
      • web-app : contient les ressources statiques de l’application
      • lib : contient les librairies tierces
      N. ADOUANI - février 10
      page 20
    • GORM, ou la persistance selon Grails (1)
      • GORM et l’acronyme de Grails ORM
      • C’est la brique de Grails qui gère l’accès aux bases de données et la persistance des classes de domaine.
      • GORM apporte une abstraction des fonctionnalités offertes par Hibernate
      • Permet de définir des objets persistants
      • Support des différents type d’association entre objet (One to One, One to Many, Many to One, Many to Many)
      • Possibilité de gestion des clés primaires composées ou de type séquence
      • Injection de méthodes dynamiquement pour requêter les bases de données
      • Possibilité d’utilisation du langage HQL
      • Utilisation plus simple de la librairie Criteria
      N. ADOUANI - février 10
      page 21
    • GORM, ou la persistance selon Grails (2)
      Premier exemple de définition de classe persistante:
      • Classe avec deux propriétés persistantes
      • hasMany: définit une association one-to-many vers l’entité « Produit »
      • transients: définit une liste de propriétés non persistantes
      • constraints: permet de définir les règles de validation d’une instance de « Categorie »
      • 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 »
      N. ADOUANI - février 10
      page 22
    • GORM, ou la persistance selon Grails (3)
      Deuxième exemple de définition de classe persistante:
      • Classe avec six propriétés persistantes
      • belongsTo: définit une association d’appartenance à « Categorie »
      • mapping: définit un ensemble de règles pour personnaliser le mapping avec la base de données
      • Grails crée par défaut une table avec le nom de la classe persistante, sinon avec la valeur du mapping « table »
      • Grails crée par défaut les colonnes de la table avec le nom des propriétés.
      • constraints: permet de définir les règles de validation d’une instance de « Categorie »
      N. ADOUANI - février 10
      page 23
    • GORM, ou la persistance selon Grails (4)
      • 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
      • count et countBy: retourne le nombre d’enregistrement d’une requête
      • findBy et findWhere : récupère un seul enregistrement
      • findAllBy, findAllWhere, getAll, listOrderBy, list : récupère plusieurs enregistrements
      • Les requêtes HQL peuvent être exécutées avec les méthodes :
      • find
      • findAll
      • executeQuery
      • Il existe aussi les méthodes save()et delete()
      N. ADOUANI - février 10
      page 24
    • GORM, ou la persistance selon Grails (5)
      Exemples de requêtes GORM
      N. ADOUANI - février 10
      page 25
    • Configuration des sources de données
      • Les accès aux données sont préconfigurés dans Grails dans le fichier config/DataSource.groovy
      • Grails prépare trois environnements différents pour les datasource :
      • Production
      • développement
      • Tests
      N. ADOUANI - février 10
      page 26
    • Les contrôleurs dans Grails
      N. ADOUANI - février 10
      page 27
      • Les contrôleurs Grails sont des classes qui se trouvent dans le dossier grails-app/controller
      • Le nom d’un contrôleur se termine, par convention, par « Controller »
      • 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
      • Les actions d’un contrôleur préparent les données qui seront consommées par la couche vue du modèle MVC
    • Les vues dans Grails
      • Les vues dans Grails sont des fichiers GSP, acronyme de Groovy Server Pages
      • Les GSP permettent d’afficher les données récupérées par les contrôleurs
      • Grails offre un ensemble de taglib pour:
      • Les formulaires et éléments de formulaires: g:form, g:submit, g:textField…
      • Les traitements conditionnels et itératifs: g:each, g:collect, g:if, g:else, g:while…
      • L’affichage et l’inclusion d’autre vues: g:render, g:include
      • Dans les GSP, certaines variables sont disponibles comme :
      • request
      • response
      • params
      • flash
      • out
      N. ADOUANI - février 10
      page 28
    • Les services dans Grails
      • Service = Une classe dans le dossier grails-app/services et dont le nom se termine, par convention, par le mot « Service »
      • Un service sert à factoriser les traitements métier de l’application, au lieu de les garder dans les contrôleurs
      • Un service est par défaut transactionnel
      • Pour chaque service Grails crée un beanspring en mode singleton, dont le nom correspond au nom du service
      • Les services sont utilisables dans les contrôleurs et les classes du domaine.
      N. ADOUANI - février 10
      page 29
    • Création de taglib
      • 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 »
      • Les taglibs ne nécessitent ni configuration, ni de fichier TLD
      N. ADOUANI - février 10
      page 30
    • Démos
      N. ADOUANI - février 10
      page 31
    • Démos
      • Création d’une première application Grails (scaffoldstatic et dynamique)
      • Domaine : Catégorie, Produits (avec ou sans image/uplaod)
      • CRUD en scaffold dynamique
      • CRUD en scaffoldstatic de Catégorie
      • Pagination et tri des colonnes
      • Transformation de l’application générée en application AJAX
      • Utilisation des taglib Ajax (remoteLink, submitToRemote, formRemote)
      • Test le plugin remotePagination sur la page liste Catégorie et liste Produit
      • Création d’un service REST
      • Exposition d’un service REST qui offre la liste des categories
      • Exposition d’un service REST qui offre la liste des produits d’une catégorie
      N. ADOUANI - février 10
      page 32
    • Démos
      • Grails et Flex
      • Création d’un simple application FLEX (voire AIR)qui utilise les services REST créer précédemment
      • Liste des catégories
      • Liste des produits de chaque catégorie
      • Grails et Ajax (ExtJS)
      • Transformation des service REST de XML à JSON
      • Création d’un simple formulaire : choix de catégorie et affichage de la liste des produits correspondants
      • Grails et iPhone (iWebKit)
      • Créer une interface de liste catégorie
      • Une interface liste produit
      N. ADOUANI - février 10
      page 33
    • Grails et les méthodologies agiles
      N. ADOUANI - février 10
      page 34
    • Grails et les méthodes agiles (1)
      • Question 1: Pourquoi choisir Grails pour faire un projet en agile?
      • Réponse : Les projets agiles ont à 90% une forte contrainte de temps (délais). À ce niveau,
      • Grails offre une grande rapidité lors du démarrage du projet;
      • Grace à la simplicité de Grails, les besoins fonctionnels sont développés plus rapidement;
      • Nouvelles fonctionnalités montrables plus facilement;
      • Le client peut faire ses feedback au plus tôt.
      N. ADOUANI - février 10
      page 35
    • Grails et les méthodes agiles (2)
      • Question 2: Quel est le niveau de flexibilité de Grails aux changements fonctionnels?
      • 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
      • 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
      • Laisser tomber un code qui a couté 1 semaine de travail et plus simple que jeter un code qui coute facilement le double
      N. ADOUANI - février 10
      page 36
    • Grails et les méthodes agiles (3)
      • Question 3: Quel est l’apport de Grails à la qualité du code?
      • 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
      • 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
      N. ADOUANI - février 10
      page 37
    • Conclusion
      • Avantages
      • Rapidité au démarrage et pendant des développements
      • Intégration avec presque tous les Frameworks de l’écosystème JAVA/J2EE grâce aux plugins
      • Permet de faciliter l’adoption des méthodologies agiles
      • Une très bonne documentation, une communauté très active et beaucoup de livres (en anglais)
      • Des success stories comme sky.com, linkedin.com
      • Inconvénients
      • Maturité pas totalement atteinte au niveau de IDE
      • 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
      • Des difficultés pour débugguer dans les environnements de développement
      • La qualité des logs et des traces d’erreurs peuvent encore être améliorés
      N. ADOUANI - février 10
      page 38
    • Merci pour votre attentionDes Questions?
      N. ADOUANI - février 10
      page 39