Acceleo 2.6 : Tutoriel utilisateur

Acceleo 2.6 : Tutoriel utilisateurPage 1/69

Acceleo 2.6 : Tutoriel utilisateurPage 2/69ACCELEOTutoriel utilisateurCe manuel est la propriété exclusive de ses auteurs et a été concédé par ces derniers au profit de la sociétéOBEO, SARL au capital de 45.000 € dont le siège social est sis 2 rue Robert Schuman, 44400 Rezé, inscriteau Registre du Commerce et des sociétés de NANTES sous le numéro 485.129.860.Ce manuel est protégé au titre des dispositions légales et réglementaires régissant les droits de propriétéintellectuelle. Il traite d’un produit logiciel dénommé ACCELEO, actuellement distribué sous licence opensource EPL par la société OBEO. Ce manuel a été fait avec la plus grande attention. Toutefois, des erreursont pu se glisser dans la version de ce manuel. OBEO ne peut être, en aucun cas, tenue pour responsabledes suites que ces erreurs pourraient entraîner.La distribution de ce manuel n’est pas libre. Ce manuel peut-être téléchargé gratuitement aprèsenregistrement sur le site de la société OBEO, et peut-être consulté dans le cadre d'une utilisationcommerciale ou non de la technologie ACCELEO. Cependant, la copie, la traduction et la redistribution de cedocument sur support électronique ou sur papier nécessite une autorisation de la part de OBEO.Nous rappelons à votre attention que les dispositions légales régissant les conditions d’utilisation et dedistribution de ce manuel sont regroupées au sein du Code de la Propriété Intellectuelle, notamment dansson Titre II – Droits des auteurs (Articles L121-1 à L123-12).Nous nous réservons le droit de modifier sans avis préalable ce manuel ou le produit.Merci de respecter ces dispositions.________________« OBEO », « ACCELEO », ainsi que les logos OBEO et ACCELEO associés à ce manuel sont déposés parOBEO SARL en France et/ou dans d'autres pays du monde.Tous les autres noms, titres, dessins, et logos sont la propriété exclusive de leurs auteurs respectifs et sontprotégés au titre des droits de propriété intellectuelle.Ce manuel a été rédigé avec les outils suivants : OpenOfficeAuteurs : Jonathan MUSSET, Etienne JULIOT, Stéphane LACRAMPEavec la participation de : Goulwen LE FUR, Julien DUPONT, Guillaume RAIMBAULT, Nathalie LEPINE,William PIERS et Cédric BRUN© Copyright 2006-2008 Obeo. Tous droits réservés

Acceleo 2.6 : Tutoriel utilisateurPage 3/69Sommaire1 - Introduction.......................................................................................................................51.1 - Connaissances minimales requises..........................................................................51.2 - Ensemble des documentations Acceleo...................................................................52 - Installation.........................................................................................................................63 - Démarrage rapide.............................................................................................................73.1 - Importer un projet dans Eclipse................................................................................73.2 - Lancer la chaîne de génération .............................................................................104 - Modélisation....................................................................................................................114.1 - Définition..................................................................................................................114.2 - Les modeleurs.........................................................................................................114.2.1 - Le métamodèle UML2 avec le modeleur EMF................................................124.2.1.1 - La création d'un projet..............................................................................124.2.1.2 - Création d’un modèle UML 2.1.................................................................154.2.1.2.a - Créer un package..............................................................................164.2.1.2.b - Créer une classe...............................................................................174.2.1.2.c - Créer un attribut.................................................................................174.2.1.2.d - Ajouter un profil au modèle...............................................................174.2.1.2.e - Créer une Association.......................................................................194.2.1.2.f - Valider le modèle................................................................................214.2.2 - A partir de l’exemple........................................................................................214.2.2.1 - Importer un projet dans Eclipse................................................................224.2.2.2 - Création d’un projet “ Dynamic Web Project ”..........................................244.2.2.3 - Le modèle WebLog_fr.uml.......................................................................274.2.2.4 - Création d’un modèle...............................................................................285 - Initialisation du projet......................................................................................................315.1 - Import des modules de générations........................................................................315.2 - Les fichiers de générations.....................................................................................325.2.1 - Pré-visualisation des résultats.........................................................................335.2.1.1 - Synchronisation code modèle..................................................................355.3 - Création de la chaîne de génération ......................................................................355.3.1 - Créer une chaîne de génération à partir de l’assistant..................................365.3.2 - Créer une chaîne de génération sans l’assistant............................................415.3.2.1 - Ajouter un modèle....................................................................................425.3.2.2 - Ajouter un répertoire cible........................................................................43

Acceleo 2.6 : Tutoriel utilisateurPage 4/695.3.2.3 - Ajouter un log............................................................................................445.3.2.4 - Ajouter un méta-modèle...........................................................................455.3.2.5 - Ajouter un fichier de génération ..............................................................456 - Génération......................................................................................................................476.1 - Lancer une chaîne de génération...........................................................................476.2 - Importer un serveur Tomcat....................................................................................486.2.1 - Importer les librairies Tomcat..........................................................................516.3 - Tester l’application..................................................................................................527 - Paramétrage...................................................................................................................557.1 - Les chaînes de générations....................................................................................557.1.1 - Modifier une chaîne de génération .................................................................557.2 - Les “ logs ”...............................................................................................................567.3 - Les fichiers “ Properties ”........................................................................................577.3.1 - Création du fichier “ properties“ ......................................................................578 - Gestion des évolutions...................................................................................................608.1 - Développements manuels.......................................................................................608.1.1 - Ajouter du code dans les servlets....................................................................608.2 - Évolutions fonctionnelles.........................................................................................618.2.1 - Modification du modèle d'entrée......................................................................618.2.1.1 - Modification d’un attribut...........................................................................618.2.1.2 - Ajout d’une Classe....................................................................................638.2.1.3 - Suppression d’une classe.........................................................................638.2.1.4 - Renommer une classe..............................................................................648.2.1.5 - Ajout / modification d’une relation (association / héritage)......................648.3 - Les fichiers “ lost ”...................................................................................................658.4 - Acceleo Traceability................................................................................................669 - Utilisation avancée..........................................................................................................679.1 - Lancer une chaîne de génération automatiquement à partir d’Eclipse..................6710 - Environnements complémentaires...............................................................................6810.1 - La gestion de versions..........................................................................................6810.1.1 - Partager un nouveau projet...........................................................................6810.1.2 - Partager ses modifications............................................................................6910.1.3 - Récupérer les modifications d'une tierce personne......................................69

1 - IntroductionAcceleo 2.6 : Tutoriel utilisateurPage 5/69Ce document est un tutoriel détaillé permettant aux utilisateurs la prise en main du générateur de codeAcceleo, initié par la société Obeo.Les fonctionnalités abordées permettront une mise en oeuvre efficace de modules de génération au sein deprojets, ainsi que la gestion du cycle de vie des projets industrialisés avec Acceleo.Ce générateur de code est dédié aux personnes qui veulent tirer profit des technologies MDA pour accroîtrela productivité de leurs développements informatiques. Il permet de générer des fichiers à partir de modèlesUML, MOF, EMF...Il s'agit d'un plugin caractérisé par :• Son intégration complète à l'environnement Eclipse et au framework EMF• La gestion de la synchronisation entre le code et le modèle• La génération incrémentale• La simplicité d'adaptation à tout type de cible technique• La facilité de mise au point et de maintenabilité des templates• La coloration syntaxique, la complétion, la détection d'erreurs1.1 - Connaissances minimales requisesCe présent guide ne se veut pas être une formation pour l'ensemble des problématiques couvertes par leMDA et Acceleo en particulier. Ainsi, la lecture de ce guide requiert les connaissances suivantes :• Java• modélisation (par exemple : UML)• utilisation d'EclipseLa connaissance des concepts suivants sera également un plus, mais ne sera pas indispensable à la lecturede cette documentation :• méta-modèles• méta-modèle UML2• développement de plugins Eclipse• MDA ou MDD1.2 - Ensemble des documentations AcceleoCe tutoriel s'inscrit dans un ensemble de documentations proposées par la société Obeo. Chaquedocumentation aborde une facette différente de la maîtrise d'Acceleo :• référence : inventaire et explication de chaque service et chaque élément de syntaxe• guide utilisateur : documentation des fonctionnalités d'Acceleo• tutoriel architecte : guide pour la création et la personnalisation de modules de génération

2 - InstallationAcceleo 2.6 : Tutoriel utilisateurPage 6/69Pour installer Acceleo, vous devez commencer par télécharger et installer la plateforme Eclipse 3.2.12, EMF2.2.2, et UML2 2.0.3. Vous devez ensuite télécharger et installer Acceleo 2.5.Plusieurs procédures existent pour l'installation d'Acceleo sur chaque poste utilisateur. Chaque procédure ases spécificités, en fonction du contexte de déploiement de la plateforme Eclipse.Le mode d'installation conseillé est l'installation à partir du site de mise à jour http://www.acceleo.org/update/.Chaque type d'installation est détaillé pas à pas dans le guide d'utilisateur.

3 - Démarrage rapideAcceleo 2.6 : Tutoriel utilisateurPage 7/69Cette partie du tutoriel s’adresse aux personnes qui veulent exécuter directement l’exemple que l’on trouvesur le site d’Acceleo : http://www.acceleo.org/pages/telechargement-modules-d-exemple/fr.Enregistrer le contenu de l’archive dans un répertoire choisi.L’archive doit contenir trois répertoires:• free.demo.weblog• free.uml2.gen.java• free.uml14.gen.java3.1 - Importer un projet dans EclipseIl faut importer “ free.demo.weblog ” dans Eclipse :– Cliquer sur “ Import... ” (cf: Figure 1).– Sélectionner ensuite l’assistant d’import de projet “ Existing Project Into WorkSpace ” (cf: Figure 2).– Cliquer sur “ Next ”.Figure 1: Importer un projet(1) Figure 2: Importer un projet (2)

Acceleo 2.6 : Tutoriel utilisateurPage 8/69– Cliquer sur “ Browse... ” (cf: Figure 3) afin d’ouvrir une fenêtre contenant tous les dossiers présents sur ledisque.– Sélectionner l’emplacement du répertoire qui contient “ free.demo.weblog ”(cf: Figure 4).– Cliquer sur “ OK ”.Figure 3: Importer un projet (3)Figure 4: Importer un projet (4)“ free.demo.weblog ” est ajouté à la liste (cf: Figure 5). Une fois que la liste contient tous les dossierssouhaités cliquer sur “ Finish ” pour ajouter le projet à Eclipse.Figure 5: Importer un projet (5)Le projet “ free.demo.weblog ” est un “ Dynamic Web Project ” (cf: 4.2.2.2 Création d’un projet “ DynamicWeb Project ”).Refaire la même manipulation que précédemment pour importer le projet “ free.uml2.gen.java ”.

Acceleo 2.6 : Tutoriel utilisateurPage 9/69Il est à noter que le répertoire “ src ” est vide (cf: Figure 6). La génération va remplir ce répertoire.Figure 6: Arborescence desdeux projets

Acceleo 2.6 : Tutoriel utilisateurPage 10/693.2 - Lancer la chaîne de générationUne fois que les deux projets sont importés, il faut sélectionner l'action de lancement de la chaîne degénération “ free.demo.weblog>weblog.chain>Launch ” (cf: Figure 7).Figure 7: Lancer lachaîne de générationFigure 8: Les fichiersgénérésAprès avoir cliqué sur “ Launch ” le répertoire “ src ” contient trois packages contenant des fichiers java quisont le résultat de la génération (cf: Figure 8).

Acceleo 2.6 : Tutoriel utilisateurPage 11/694 - ModélisationL'outil Acceleo permet différentes possibilités de modélisation :– UML1.x– UML2– Ecore– DSL– Autres (Merise, SADT, OMT, outil propriétaire...)4.1 - DéfinitionVoici un rappel de quelques définitions propres à UML qui pourront être utiles à lacompréhension du tutoriel.Profile:Un profile est un mécanisme standard d'extension du langage UML qui permet de spécialiser un schémaUML selon un domaine particulier.Il représente un ensemble cohérent de stéréotypes, tag-value et contraintes.Attention : on n'ajoute pas de méta-classes mais des annotations aux méta-classes UML existantes.Des profiles standards existent: le profil CORBA (OMG), le profil EJB 1.0 (JCP),...Stéréotypes:Le concept de stéréotype permet de classer (annoter) des éléments et se comporte comme un nouvelélément d'un méta-modèle.Un stéréotype est un “ GeneralizableElement ”.La relation d'héritage est donc possible pour les stéréotypes.De même il est possible de définir des stéréotypes abstraits pour éviter des répétitions quand desstéréotypes ont des propriétés communes.Tag-value:Le concept de tag-value permet d'ajouter des informations sur des classes. Un tag-value peut être considérécomme un nouveau méta-attribut.Contraintes:Le concept de contrainte est utilisé pour exprimer des relations entre les stéréotypes et les tag-values.4.2 - Les modeleursDe nombreux modeleurs sont compatibles avec Acceleo. Ce générateur repose sur EMF, il est doncnativement compatible avec les outils créés autour de ce framework. On peut nommer RSM, Together,

Acceleo 2.6 : Tutoriel utilisateurPage 12/69Omondo.Les modeleurs ne sont pas tous intégrés à Eclipse, mais beaucoup d'entre eux proposent un export de typeXMI pour se rendre compatible avec les autres outils.Acceleo a été testé avec succès pour des outils exportant des modèles UML 1.4 en XMI 1.x : Poseidon,Objecteering, Sparx, ArgoUML...Pour pouvoir lire un XMI différent de EMF il faut faire un clic droit sur le fichier XMI et choisir “ Convert XMI ”.La procédure est toujours la même:Soit le modeleur est intégré à Eclipse et Acceleo peut utiliser directement les fichiers XMI, soit le modeleurest externe et dans ce cas il faut exporter le XMI dans un répertoire du workspace et rafraîchir le dossierdans Eclipse.Voici un exemple de modèle cinématique dans un DSM créé à partir de GMF :Figure 9: modèle de cinématique dans un DSMCe modèle est directement compatible avec Acceleo car il est basé sur EMF.4.2.1 - Le métamodèle UML2 avec le modeleur EMFAcceleo utilise l'éditeur de EMF pour représenter des modèles décrit en UML2. Ce modeleur est présentdans la section “ Example EMF Model Creation Wizards ”.Il faut avoir créé un projet pour pouvoir créer un modèle UML2.4.2.1.1 - La création d'un projetPour créer un projet il suffit de faire un clic droit dans l'environnement de travail et de choisir l’assistant decréation d'un nouveau projet simple “ New>Other>General>Project ” (cf: Figure11).

Acceleo 2.6 : Tutoriel utilisateurPage 13/69Figure 11: Création d'unprojet (1)Figure 10: Création d'un projet (2)– Remplir le champ “ Project Name ” avec le nom “ fr.obeo.pim.demo.tutorial ”.– Cliquer sur “ Finish ” pour ajouter le projet à Eclipse (cf: figure 12).Figure 12: Création d'un projet (3)

Acceleo 2.6 : Tutoriel utilisateurPage 14/69Il faut maintenant créer un répertoire “ model ” (cf: Figure 14) dans ce nouveau projet.Pour cela :– Faire un clic droit sur le projet et sélectionner l’assistant de création de répertoire “ New>Folder ”(cf: Figure 13).Figure 13: Création d'un répertoireFigure 14: Nommage du répertoire– Remplir le champ “ Folder name ”– Cliquer sur “ Finish ” pour ajouter le répertoire à Eclipse. Un répertoire vide apparaît dans le projet.

Acceleo 2.6 : Tutoriel utilisateurPage 15/694.2.1.2 - Création d’un modèle UML 2.1Pour créer un modèle UML 2.1 il faut :– Effectuer un clic droit sur le répertoire “ model ”– Choisir l’assistant de création de modèle EMF “ New>Other>Example EMF Model CreationWizards>UML Model ” (cf: Figure 15).– Cliquer sur “ Next ”.– Nommer le modèle “ Tutorial.uml ” dans le champ “ File name ” (cf:Figure 16).– Cliquer sur “ Next ”.Figure 15: Création d'un modèleFigure 16: Nommage du modèle– Dans le champ “ Model Object ” choisir “ Model ” (cf: Figure 17).– Cliquer sur “ Finish ” pour ajouter le modèle à EclipseFigure 17: Choix du modèleUn modèle vierge à été créé. Il faut maintenant créer le modèle souhaité.

Acceleo 2.6 : Tutoriel utilisateurPage 16/694.2.1.2.a - Créer un packageLa première étape consiste à créer un package. Pour cela :– Effectuer un clic droit sur l’élément de haut niveau nommé “ Model ”– Choisir dans la liste de “ Child ” l’élément “ Package ” (cf: Figure 18)Figure 18: Création d'un packageLes propriétés de l’élément “ Package ” se trouve dans la vue “ Properties ”. Si cette vue n’est pas affichéefaire un clic droit “ ShowProperties View ” (cf: Figure 19).Figure 19:Afficher la vuepropriété

Acceleo 2.6 : Tutoriel utilisateurPage 17/69La saisie du champ “ name ” est obligatoire. Saisir “ monPremierPackage ” dans celui-ci. (cf: figure 20).Figure 20: Propriété nameUn clic sur l’élément du modèle permet d’afficher dans la vue “ Properties ” les propriétés de l’objet.4.2.1.2.b - Créer une classeMaintenant que le package est créé il va falloir lui ajouter une classe. Pour cela réitérer les opérationssuivantes:– Clic droit sur le package “ MonPremierPackage ”, sélectionner le menu " New Child>Class ”– Remplir le champ “ name ” avec le nom “ MaClasse ”4.2.1.2.c - Créer un attributMaintenant pour ajouter un attribut à cette classe réitérer les opérations suivantes:– Clic droit sur la classe “ MaClasse ”, sélectionner le menu ” New Child>Property ”– Remplir le champ “ name ” avec le nom “ monAttribut ”.Il faut aussi compléter le type de l’attribut “ monAttribut ” : String. Un clic sur le champ type ne propose pasles types primitifs (tel que String). Pour utiliser les types primitifs, il faut utiliser les profils UML2.4.2.1.2.d - Ajouter un profil au modèlePour utiliser les profils UML2 il suffit de faire un clic droit sur “ monAttribut ” et de sélectionner “ LoadRessource... ” (cf: Figure 21)Figure 21: Ajouter un profil(1)

Acceleo 2.6 : Tutoriel utilisateurPage 18/69Ensuite il faut saisir l’URI pour obtenir le profil contenant les types primitifs (Entier, Chaîne de caractère,Booléen...):pathmap://UML_PROFILES/Standard.profile.uml et cliquer sur “ OK ” (cf: Figure 22)Figure 22: Ajouter un profil (2)De nouveaux profils sont alors ajoutés au modèle. (cf: Figure 23).Figure 23: Nouveau profilPour que “ monAttribut ” soit de type String il suffit, dans la vue “ Properties ”, de cliquer sur l’onglet “ Type ”et de choisir “ String ”. (cf: Figure 24)Figure 24: Choisir le type StringPour compléter le modèle, ajouter une seconde classe “ MaSecondeClasse ” (cf: 3.2.1.2.b Créer une classe)et un attribut à cette classe “ monSecondAttribut ” (cf: 3.2.1.2.c Créer un attribut).

Acceleo 2.6 : Tutoriel utilisateurPage 19/694.2.1.2.e - Créer une AssociationPour l’attribut “ monSecondAttribut ” utiliser le type “ MaClasse ”. Pour cela, dans le champ “ type ” de la vue“ Properties ” choisir “ MaClasse ” (cf: figure 25). Une association entre les deux classes a été créée.Figure 25: Créer une associationUne seconde façon de créer une association entre deux classes consiste à ajouter une association à la main.Pour cela se placer sur le package, faire un clic droit, et choisir l’élément “ Child>Association ”.La nouvelle association est ajoutée à la fin du modèle (cf: figure 26).Figure 26: Ajouter une association entre deuxclasseIl faut renseigner le champ “ memberEnd ” de cette association dans la vue “ Properties ”.Pour cela cliquer sur le sélectionneur (cf: figure 27).Figure 27: Sélectionneur

Acceleo 2.6 : Tutoriel utilisateurPage 20/69Une fenêtre apparaît.– Sélectionner “ monAttribut ” et cliquer sur “ Add ”– Sélectionner “ monSecondAttribut ” et cliquer sur “ Add ”.– Pour valider cliquer sur “ OK ” (cf: Figure 28).Figure 28: Créer une associationLe champ “ memberEnd ” est maintenant composé des deux attributs.(cf: Figure 29)Figure 29: Champ “ memberEnd ”

Acceleo 2.6 : Tutoriel utilisateurPage 21/694.2.1.2.f - Valider le modèleLe modèle est créé. Pour vérifier que le modèle est correct, effectuer un clic droit sur l’élément de hautniveau “ Model ” et sélectionner “ Validate ” (cf: Figure 30).Figure 31: Validation effectuéeFigure 30: Validation du modèle4.2.2 - A partir de l’exempleCette partie consiste à expliquer le fonctionnement de l’exemple.Un exemple de modèle et de script peut être téléchargé sur le site d’Acceleo à l’adresse suivante :http://www.acceleo.org/pages/telechargement-modules-d-exemple/frEnregistrer le contenu de l’archive dans un répertoire de votre choix.L’archive doit contenir trois répertoires:• free.demo.weblog• free.uml2.gen.java• free.uml14.gen.java

Acceleo 2.6 : Tutoriel utilisateurPage 22/694.2.2.1 - Importer un projet dans EclipseIl faut importer “ free.demo.weblog ” dans Eclipse.– Cliquer sur “ Import... ” (cf: Figure 32)– Sélectionner ensuite l’assistant d’import de projet “ Existing Project Into WorkSpace ” (cf: Figure 33)– Cliquer sur “ Next ” pour importer le projet dans Eclipse.Figure 32: Importer un projet (1)Figure 33: Importer un projet (2)

Acceleo 2.6 : Tutoriel utilisateurPage 23/69– Cliquer sur “ Browse... ” (cf: Figure 34) pour sélectionner l’emplacement du répertoire qui contient“ free.demo.weblog ”.(cf: Figure 35)– Cliquer sur “ OK ”.Figure 34: Importer un projet (3)Figure 35: Importer un projet (4)Le projet “ free.demo.weblog ” est ajouté à la liste (cf: Figure 36). Pour finir cliquer sur “ Finish ”.Le projet est ajouté à Eclipse (cf: Figure 37).Figure 37: Importer un projet(6)Figure 36: Importer un projet (5)Le projet “ free.demo.weblog ” est un projet “ Dynamic Web Project ”.

Acceleo 2.6 : Tutoriel utilisateurPage 24/694.2.2.2 - Création d’un projet “ Dynamic Web Project ”Cette partie explique comment le projet free.demo.weblog a été créé.Cette seconde partie du tutoriel explique comment l’exemple à été créé et comment faire pour le recréer.Il faut auparavant avoir installé Eclipse WTP.Ensuite il faut faire un clic droit dans l'environnement de travail pour sélectionner l’assistant de création deprojet Web dynamique “ New>Other>Web>Dynamic Web Project ” (cf: Figure 38), puis cliquer sur “ Next ”.Figure 39: Création d'un projet (2)Figure 38: Création d'un projet(1)

Acceleo 2.6 : Tutoriel utilisateurPage 25/69– Remplir le champ “ Project Name ” avec le nom souhaité pour le projet et cliquer sur “ Next ”(cf : Figure 40).– Cliquer sur “ Next ” (cf: figure 41).Figure 41: Création d'un projet (4)Figure 40: Création d'un projet (3)Figure 43: Création d'un projet (6)Figure 42: Création d'un projet (5)

Acceleo 2.6 : Tutoriel utilisateurPage 26/69Lorsque la fenêtre “ Open associated Perspective ” (cf: figure 43) apparaît,– cliquer sur “ Yes ” pour avoir une perspective J2EE (cf: Figure 44)ou– sur “ No ” pour garder la perspective Java (cf: Figure 45).Figure 44: Perspective J2EEPour changer de perspective il suffit de cliquer sur l’icône “ Open Perspective ” (cf: Figure 45).Figure 45: Perspective Java

Acceleo 2.6 : Tutoriel utilisateurPage 27/694.2.2.3 - Le modèle WebLog_fr.umlAfin de mieux comprendre le projet Weblog voici une représentation UML du diagramme de classe.La première représentation représente l’IHM du projet WebLog (cf: Figure 46) et la seconde représentel’application métier du projet Weblog (cf: Figure 47).“ Screen ”CreationCompteemail: Stringprenom: Stringnom: Stringlogin: StringmotDePasse: Passwordcreer()creationCompte1connection1“ Screen ”Connectionweblogslogin: StringmotDePasse: PasswordcreerBlogconnecter()creerCompte()login 11“ Screen ”EditionCompteemail: Stringprenom: Stringnom: Stringlogin: StringmotDePasse: Passwordmodifier()editionCompte1visualisationBlogs1visualisationBlogs“ Screen ”VisualisationBlogsblogs: ArticleDeBlogmessage: Stringutilisateur: StringcreerBlog()deconnecter()editerCompte()connecter()recharger()11“ Screen ”CreationBlogscontenu: Stringtitre: StringFigure 46: Diagramme de classe de l'IHM Weblogcreer()“ Entity “Utilisateuremail: Stringauteur*prenom: Stringnom: String1login: StringmotDePasse: PasswordFigure 47: Diagramme de classe de l’application métier Weblog“ Entity “ArticleDeBlogtitre: StringdateDeCreation: Datecontenu: String

Acceleo 2.6 : Tutoriel utilisateurPage 28/694.2.2.4 - Création d’un modèleTout au long de cette partie le modèle de référence sera le modèle “ WebLog_fr.uml ”.“ WebLog_en.uml ” représente le même modèle UML mais en anglais.“ Weblog_en.uml14 ” représente le modèle décrit en UML 1.4 en anglais.Une fois le projet créé (cf : 4.2.1.1 Mon premier projet ou 4.2.2.2 Création d’un projet “ Dynamic WebProject ”), créer un répertoire “ model ” à l'intérieur du projet.Dans ce répertoire faire un clic droit et sélectionner l’assistant de création de modèle EMF :“ New>Other>Example EMF Model Creation Wizards ” (cf: Figure 48).Figure 48: Création d'un modèleCliquer sur “ Next ” puis nommer le modèle.– Dans la section “ Model Object ” choisir “ Model ” (cf: Figure 49).– Cliquer ensuite sur “ Finish ” pour ajouter le modèle à Eclipse.Figure 49: Création d'un modèle (2)

Acceleo 2.6 : Tutoriel utilisateurPage 29/69Une fois le modèle UML 2.1 créé, il faut l'ouvrir, faire un clic droit sur l'élément de haut niveau, et sélectionnerle menu “ New Child ”. Une liste des éléments pouvant être ajoutés apparaît (cf: Figure 50).Figure 50: Les noeuds du modèleLa figure ci-dessous reprend les éléments présentés dans la liste de la figure 50.• Un élément parent : Model Modèle Vierge• Des profiles• Des packages• Des classes• Des propriétés• Des opérations• Des paramètres d’opération

Acceleo 2.6 : Tutoriel utilisateurPage 30/69Un clic droit sur un des éléments permet de voir les “ Child ” qui peuvent lui être associé.Ces éléments sont paramétrables à partir de la vue “ Properties ” (cf: figure 52).Si cette vue n’apparaît pas dans Eclipse, il faut faire un clic droit sur le modèle (dans le “ Reflective Editor ”)et sélectionner le menu “ Show Properties View ” (cf: Figure 51).Figure 51: Afficher la vue PropertiesFigure 52: Vue propertiesLes propriétés ne seront pas décrites dans ce tutoriel cependant quelques points seront abordés.Les cardinalités:• “ Lower ” : Cardinalité minimale• “ Upper ” : Cardinalité maximaleL’infini se représente par “ -1 ”Les types:“ Type ” permet de définir les types des attributsle nom:“ Name ” permet de nommer l’élément. Cette propriété doit absolument être renseignée.L'exemple WebLog n'utilise pas de stéréotypes mais des “ keywords ”. Les trois modèles présents dans lerépertoire “ model ” de Weblog ont été réalisés à partir d'un modeleur qui a remplacé les stéréotypes par des“ keywords ”. Il est tolérable d'assimiler les “ keywords ” à des stéréotypes.

Acceleo 2.6 : Tutoriel utilisateurPage 31/695 - Initialisation du projetLe modèle “ WebLog_fr.uml ” sera utilisé pour cette partie.5.1 - Import des modules de générationsLe modèle de référence étant “ WebLog_fr.uml ” il faut importer le module de génération correspondant à cemodèle. Le module de référence à importer est:• free.uml2.gen.javaCe répertoire se trouve dans l’archive téléchargée dans la partie 3 (cf: 3.2.2).Pour importer ce projet, se référer à la partie 4.2.2.1 Importer un projet dans Eclipse.Les deux projets doivent apparaître dans Eclipse (cf: Figure 53)Figure 53: Les projets dans EclipsePour le reste du tutoriel il est conseillé d’avoir la perspective Acceleo ouverte. Pour cela il suffit de cliquer surl’icône “ Open Perspective ” (cf: Figure 45) et de choisir Acceleo si celui-ci apparaît dans la liste. Sinon il fautcliquer sur “ Other... ”, sélectionner Acceleo, puis cliquer sur “ Ok ” (cf: Figure 54).Figure 54: Perspective Acceleo

Acceleo 2.6 : Tutoriel utilisateurPage 32/695.2 - Les fichiers de générationsLe projet “ free.uml2.gen.java ” contient les fichiers de génération.Ces fichiers se trouvent dans le répertoire “ src ” et possèdent l’extension “ .mt ”.Figure 55: Fichiers de générationCes fichiers sont des scripts de génération qui vont permettre de générer le code souhaité.

Acceleo 2.6 : Tutoriel utilisateurPage 33/695.2.1 - Pré-visualisation des résultatsPour pouvoir faire une pré-visualisation des résultats il faut tout d’abord choisir un script de génération. Pourcela il faut faire un clic droit sur le modèle (ici WebLog_fr.uml) et choisir “ Acceleo>Select Template ”(cf : Figure 56)Figure 56: Sélectionner un générateurIl faut ensuite sélectionner le fichier que l’on veut pré-visualiser. La pré-visualisation s'effectuera avec lefichier “ jdbc.mt ” présent dans “ src>org>acceleo>modules>uml2>gen>java>dao ” (cf: Figure 57)Figure 57: Sélection du fichier à prévisualiser

Acceleo 2.6 : Tutoriel utilisateurPage 34/69Les classes du modèle ayant un “ keywords ” dont la valeur est “ Entity ” se voit apposer une flèche(cf: Figure 58)Figure 58: Classe avec “ keywords ” dont la valeur est "Entity"Pour avoir un aperçu de la génération, sélectionner une des classes qui à une flèche et cliquer sur l’onglet“ Source ” (cf: Figure 58).Le code en noir est le code qui a été généré dynamiquement et qui correspond aux éléments du modèle. Icile code généré correspond à la classe Utilisateur.Le code en violet correspond au code qui a été généré statiquement. (cf: Figure 59).Figure 59: Prévisualisation du code généré

Acceleo 2.6 : Tutoriel utilisateurPage 35/695.2.1.1 - Synchronisation code modèleUne synchronisation est faite entre le modèle et le code généré. Ainsi il est possible de retrouver un élémentdans le code généré à partir du modèle et inversement. Il suffit de double-cliquer sur un élément générédynamiquement (de couleur noire) pour qu’il soit sélectionné dans le modèle (cf: Figure 60).Figure 60: Synchronisation code modèleUn simple clic dans le modèle sélectionne l’élément dans le code généré (cf: Figure 61). Un second clic surle modèle sélectionne la seconde occurrence et ainsi de suite.Figure 61: synchronisation modèle code5.3 - Création de la chaîne de générationIl existe deux façons de créer une chaîne de génération. Soit en utilisant l’assistant soit en le faisant

Acceleo 2.6 : Tutoriel utilisateurPage 36/69manuellement.5.3.1 - Créer une chaîne de génération à partir de l’assistantDans l’exemple, les chaînes de génération (.chain) sont dans le projet “ free.demo.weblog ”. L’emplacementde la chaîne n’a pas d’importance.Pour créer une chaîne de génération, il est conseillé de passer en perspective Acceleo (cf: Figure 45 et 54).Dans l’exemple les chaînes de générations sont déjà créées. Le but du tutoriel est de recréer une chaîne degénération identique à la chaîne de génération “ weblog.chain ”.Pour créer une nouvelle chaîne de génération:– sélectionner le projet “ free.demo.weblog ”– Faire un clic droit et sélectionner “ New>chain ” (cf: Figure 62).Figure 62: Création d'une chaîne de génération

Acceleo 2.6 : Tutoriel utilisateurPage 37/69Sélectionner le méta-modèle approprié. Dans le cas présent il faut choisir le méta-modèle UML2(http://www.eclipse.org/uml2/2.0.0/UML) (cf: Figure 63) puis cliquer sur “ Next ”.Figure 63: Sélection du métamodèleIl faut sélectionner le modèle “ WebLog_fr.uml ” (cf: Figure 64) puis cliquer sur “ Next ”.Figure 64: Sélection du modèle

Acceleo 2.6 : Tutoriel utilisateurPage 38/69Il faut maintenant sélectionner les fichiers de générations souhaités, les trois répertoires “ dto ”, “ dao ”, “ ui ”dans le cas présent (cf Figure: 65) puis cliquer sur “ Next ”.Figure 65: Sélection des scriptsEnfin, il faut choisir l’emplacement et le nom de la chaîne de génération (cf: Figure 66). Cette chaîne seraplacée dans le répertoire “ free.demo.weblog ” et se nommera “ MaWebLog_fr.chain ”Figure 66: Nommage de la chaîne de génération

Acceleo 2.6 : Tutoriel utilisateurPage 39/69Voici la constitution de cette nouvelle chaîne de génération (cf: Figure 67).Figure 67: Constitution d'une chaîne de générationElle liste l'ensemble des ressources manipulées et des actions à réaliser. L'éditeur spécialisé permet devalider les tâches et de guider l'utilisateur. On distingue deux parties dans ces fichiers : la partie desressources et la partie des actions.La partie des ressources, aussi appelée "Repository", contient l'ensemble des ressources utilisées par lesactions. On distingue 5 types de ressources :• Model : les modèles sur lesquels les générateurs vont être appliqués• Folder : les répertoires cibles de génération• Log : les fichiers pour recenser les erreurs de génération• PIM : les méta-modèles de haut niveau décrivant les modèles en entrée des générateurs• Script : les générateurs à appliquerLa partie des actions, aussi appelée "ActionSet", contient l'ensemble des tâches à lancer. On distingue 5types d'actions :• Generate : applique un générateur sur un modèle, et met l'arborescence des fichiers créés dans lerépertoire cible précisé. Le méta-modèle demandé est celui décrivant le modèle en entrée.• Convert Xmi : convertit un fichier XMI exporté d'un modeleur non EMF en un fichier XMI basé sur leméta-modèle UML14 défini pour EMF avec l'URI http://www.obeo.fr/acceleo/uml14. Cet export doit biensûr être compatible XMI 1.x et UML 1.4. Cette action précède généralement une action de génération quis'applique sur le modèle résultant de la conversion.• Backup : sauvegarde toutes les ressources d'un répertoire dans un autre répertoire. Plusieurs niveaux desauvegarde peuvent être définis. La sauvegarde d'un répertoire cible de génération est notamment trèspratique dans une phase de mise au point des scripts. Cependant, cette action ne fait pas toujours bonménage avec les outils de gestion de versions : CVS, SVN... A utiliser avec modération!• Clear : vide le contenu de chaque fichier du répertoire sélectionné et de ses sous-répertoires. Cetteaction ne supprime pas les ressources. Elle a pour objectif d'identifier les générations qui n'ont pasdonnées les résultats attendus (fichiers vides détectés) tout en assurant que les ressources restentsynchronisées avec les outils de gestion de versions (CVS, SVN). Dans ce contexte, la comparaison desressources entre 2 générations est vraiment très fiable et simple. C'est pourquoi, cette action est souventutilisée pour réaliser des tests de non-régression sur les générateurs. Cependant, quand elle est mal

Acceleo 2.6 : Tutoriel utilisateurPage 40/69utilisée, elle est source d'erreur au niveau de la gestion du code utilisateur. Autrement dit, il ne fautjamais faire une action "Clear" sur un fichier qui contient du code manuel.• Remove : Supprime définitivement les fichiers et les répertoires sélectionnés.

Acceleo 2.6 : Tutoriel utilisateurPage 41/695.3.2 - Créer une chaîne de génération sans l’assistantPour créer une chaîne de génération sans l’assistant se placer sur le répertoire “ free.demo.weblog ” et faireun clic droit. Sélectionner “ New>Other>Acceleo>Empty Chain ” (cf: Figure 68).Figure 68: Création d'une chaîne degénération sans assistantCliquer sur “ Next ” et nommer la chaîne “ webLog_fr_sa.chain ” (cf: Figure 69) et cliquer sur “ Finish ” pourajouter la chaîne à Eclipse.Figure 69: Nommage de la chaîne degénérationLa chaîne est créée mais elle est vide. Il va falloir lui ajouter les éléments nécessaires à son fonctionnement.

Acceleo 2.6 : Tutoriel utilisateurPage 42/695.3.2.1 - Ajouter un modèle– Sélectionner la chaîne de génération et effectuer un clic droit.– Sélectionner “ Repository>New Child>Model ” (cf: Figure 70).Figure 70: Sélection du modèle– Saisir l’URI du modèle dans le champ “ Path ” de la vue “ Properties ” :“ /free.demo.weblog/model/WebLog_fr.uml ” (cf Figure 71).Figure 71: URI du modèle

Acceleo 2.6 : Tutoriel utilisateurPage 43/69Cette solution reste fastidieuse et compliquée. Il existe une manière plus simple pour choisir un modèle dansl'espace de travail Eclipse.Pour cela :– Faire un double clic sur le modèle, permet de choisir parmi les modèles disponibles (cf: Figure 72).Figure 72: Double cliquer sur le modèle– Sélectionner le modèle désiré.– Sélectionner le répertoire “ model ”. Cette sélection permet d’afficher les modèles présents dans lerépertoire. Pour sélectionner un modèle il suffit de le cocher et de cliquer sur “ OK ” (cf: Figure 73).Figure 73: Sélectionner un modèle5.3.2.2 - Ajouter un répertoire cible– Sélectionner la chaîne de génération et effectuer un clic droit.– Sélectionner “ Repository>New Child>Folder ”

Acceleo 2.6 : Tutoriel utilisateurPage 44/69– Sélectionner ensuite “ Folder ” et renseigner le champ “ Path ” avec le repertoire cible:“ /free.demo.weblog ”ou– Double cliquer sur “ Folder ”– Choisir l’emplacement souhaité (cf: Figure 74).Figure 74: Sélectionner lerépertoire cible– Cliquer sur “ OK ” pour valider le choix du répertoire cible.5.3.2.3 - Ajouter un log– Sélectionner la chaîne de génération et effectuer un clic droit.– Sélectionner “ Repository>New Child>Log ”– Sélectionner ensuite “ Log ” qui vient d’être ajouté et renseigner le champ “ Path ” par :“ /free.demo.weblog/WebLog_fr.log.txt ”ou– Double cliquer sur le “ Log ” qui vient d’être ajouté à la chaîne de génération– Sélectionner le fichier correspondant à “ Error Log ” (cf: Figure75).Figure 75: Sélectionner le Error Log

Acceleo 2.6 : Tutoriel utilisateurPage 45/695.3.2.4 - Ajouter un méta-modèle– Sélectionner la chaîne de génération et effectuer un clic droit.– Sélectionner “ Repository>New Child>Emf Metamodel ”– Sélectionner ensuite “ Emf Metamodel ” et renseigner le champ “ Path ” par:http://www.eclipse.org/uml2/1.0.0/UMLou– Double cliquer sur le méta-modèle qui vient d’être ajouté– Choisir dans la liste le méta-modèle souhaité (cf: Figure 76).Figure 76: Choisir le méta-modèle souhaité5.3.2.5 - Ajouter un fichier de génération– Sélectionner la chaîne de génération et effectuer un clic droit.– Sélectionner “ Repository>New Child>Generator ”– Renseigner le champ “ Path ” par l’URI du fichier de génération (.mt) souhaité :“ /free.uml2.gen.java/src/org/acceleo/modules/uml2/gen/java/dao/jdbc.mt. ”ou– Double cliquer sur le fichier pour choisir le fichier de génération (.mt) souhaité (cf: Figure 77).Figure 77: Choisir un fichier de génération

Acceleo 2.6 : Tutoriel utilisateurPage 46/69Il est possible d’ajouter autant de “ Generator ” que l’on souhaite comme on peut le voir sur la figure 67page 39.Il faut maintenant remplir la partie “ Action Set ”.– Faire un clic droit sur “ Action Set ” et sélectionner “ New Child>Generate ”.Dans la vue “ Properties ” il y a six champs qu’il faut remplir.Figure 78: Les six champs Property de Action Set• Documentation: Le nom que l’on souhaite. Il est possible pour se repérer de le nommer par le nom dufichier.• Folder: Le nom du projet.• Generator: le chemin du fichier de génération (.mt).• Log: l’adresse du fichier d’erreur (log).• Metamodel: l’URI du métamodèle.• Model: l’adresse du modèle.Pour chaque fichier de génération (.mt) que l’on veut générer il faut créer un “ Generate ” correspondant.Dans le cas présent le “ Generate ” correspondra au fichier “ jdbc.mt ”.Pour les autres fichiers, la manipulation est strictement identique hormis pour la propriété “ Documentation ”puisqu’il s’agit d’un nom choisi par l’utilisateur et différent pour chaque fichier (cf Figure 79).Figure 79: Les six champs de propriétés d'un “ Generate ”

Acceleo 2.6 : Tutoriel utilisateurPage 47/696 - Génération6.1 - Lancer une chaîne de générationMaintenant que les chaînes de génération ont été créées, il est possible de générer les fichiers. Pour cela ilsuffit de faire un clic droit sur la chaîne de génération “ weblog.chain ” et de sélectionner le lanceur de lachaîne de génération “ Launch ” (cf: Figure 80).Figure 80: Lancer lachaîne de générationLe répertoire “ src ” qui jusqu’à présent était vide contient désormais trois packages:• free.demo.weblog/src/org/acceleo/sample/dto• free.demo.weblog/src/org/acceleo/sample/ihm• free.demo.weblog/src/org/acceleo/sample/jdbcCes trois packages contiennent les fichiers java qui ont été générés.L’un des trois packages contient des erreurs (free.demo.weblog/src/org/acceleo/sample/ihm). Les erreursprésentent dans les fichiers java sont des erreurs qui peuvent être résolues en important un serveur Tomcatau projet.

Acceleo 2.6 : Tutoriel utilisateurPage 48/696.2 - Importer un serveur TomcatIl faut au préalable avoir une version du serveur Tomcat installée sur la machine ainsi qu'avoir installer lesplug-ins du projet WTP pour interfacer ce serveur avec Eclipse. Il est possible de télécharger le serveurtomcat à l’adresse suivante:http://tomcat.apache.org/et de récupérer les plug-ins du projet WTP via le site de release simultanée des projets eclipse Callisto ou enallant directement sur le site du projet :http://www.eclipse.org/webtools/main.phpUne fois la version du serveur installée sur la machine il faut l’importer afin qu'Eclipse le reconnaisse.Pour cela, il faut ouvrir la vue “ Servers ”.– Cliquer sur Window>Show View>Other (cf: Figure 81).Figure 81: Importer un Serveur– Sélectionner Server>Servers (cf: Figure 82)Figure 82: SélectionnerServer

Acceleo 2.6 : Tutoriel utilisateurPage 49/69La vue “ Servers ” est ajoutée à Eclipse (cf :Figure 83).Figure 83: La vue Server– Faire un clic droit dans la vue “ Servers ” et sélectionner “ New>Server ” (cf: Figure 84).Figure 84: Selectionner Server– Sélectionner le serveur Apache correspondant à celui installé sur la machine. Dans le cas présent c’estle serveur Tomcat 5.5 qui est installé (cf: Figure 85).Figure 85: Sélection d'un serveur

Acceleo 2.6 : Tutoriel utilisateurPage 50/69– Cliquer sur “ Next ”. Choisir le répertoire d’installation du serveur en cliquant sur “ Browse ” (cf: Figure86).Figure 86: Indiquer le répertoire d'installation– Cliquer sur “ Next ”.– Sélectionner le projet à assimiler au serveur et cliquer sur “ Add > ” (cf: Figure 87).Figure 88: Sélectionner le projetFigure 87: Une fois le projet ajouté– Pour finir cliquer sur “ Finish ”.

Acceleo 2.6 : Tutoriel utilisateurPage 51/696.2.1 - Importer les librairies TomcatMaintenant que le serveur est installé les erreurs apparaissent toujours dans le second package. Poursupprimer ces erreurs il faut importer les librairies du serveur Tomcat. Il suffit de se placer sur le projet, defaire un clic droit, et de sélectionner “ Properties>Java Build Path ” (cf: Figure 89).Figure 89: Ajouter les librairies de Tomcat– Sélectionner “ Add Externals JARs ”, rechercher le répertoire d’installation du serveur Apache SoftwareFoundation/Tomcat 5.5/common/lib, choisir le fichier servlet-api.jar et cliquer sur “ Ouvrir ”(cf: Figure 90).Figure 90: Sélectionner la librairie correspondante

Acceleo 2.6 : Tutoriel utilisateurPage 52/69– Cliquer sur “ OK ” (cf: Figure 91).Figure 91: Ajout des librairies au “ build path ” du projetLa librairie est ajoutée au “ build path ” du projet et les erreurs disparaissent.Le répertoire WebContent a également été modifié. Il contient un répertoire “ jsp ” avec les fichiers JSP, et unrépertoire “ WEB-INF ” avec notamment le fichier web.xml.Figure 92: Contenu desdifférents répertoires6.3 - Tester l’applicationUne fois le serveur installé il est possible de tester l’application.Pour cela il faut tout d’abord lancer le serveur.– Effectuer un clic droit sur le serveur présent dans la vue “ Servers ”.

Acceleo 2.6 : Tutoriel utilisateurPage 53/69– Sélectionner “ Start ” (cf: Figure 93).Figure 93: Lancer le serveur TomcatUne fois le serveur lancé l’icône “ Started ” apparaît dans la vue “ Servers ” (cf: Figure 94).Figure 94: Le serveur est lancéLa vue “ Console ” permet également de voir que le serveur est bien lancé (cf: Figure 95).Figure 95: Vue de la ConsoleEnsuite, il faut ouvrir un navigateur Web et tapez l’URL suivante: http://localhost:8080/free.demo.weblog/Une page de menu apparaît alors à l’écran. Cette page correspond au fichier “ Index.html ” (cf: Figure 96)

Acceleo 2.6 : Tutoriel utilisateurPage 54/69Figure 96: Menu de free.demo.weblogUn clic sur “ Screen CreationCompte ” permet de créer un nouveau compte (cf: Figure 97).Figure 97: Créer un compteLes fonctionnalités ne sont pas implémentées, seule l’IHM est implémentée.

Acceleo 2.6 : Tutoriel utilisateurPage 55/697 - Paramétrage7.1 - Les chaînes de générationsIl a été expliqué en partie 5.3 comment créer une chaîne de génération. Une fois la chaîne de générationcréée il peut arriver que le besoin change et que la chaîne de génération ne réponde plus au besoin.Il n’est alors pas obligatoire de recréer une nouvelle chaîne de génération.Acceleo permet en effet de modifier une chaîne de génération existante.7.1.1 - Modifier une chaîne de générationIl faut double cliquer sur la chaîne de génération à modifier pour l'ouvrir dans la vue d’Eclipse (cf: Figure 98).Figure 98: La chaîne de génération weblog.chainPour modifier un élément il suffit de double cliquer dessus. Par exemple, si l’on souhaite modifier un fichierde génération il faut double cliquer sur le fichier d’extension (.mt) et choisir le nouveau fichier que l’onsouhaite. Pour choisir le nouveau fichier :

Acceleo 2.6 : Tutoriel utilisateurPage 56/69– Désélectionner le fichier actuel en cliquant dessus (cf: Figure 99). Le fichier est alors décochéFigure 99: Déselectionner le fichier– Sélectionner le nouveau fichier souhaité (cf: Figure 100). Le fichier se coche.Figure 100: Sélectionner le nouveau fichierPour valider le changement cliquer sur “ OK ”.7.2 - Les “ logs ”Les “ logs ” permettent, en cas d’erreur lors de l’exécution de la chaîne de génération, de lister les

Acceleo 2.6 : Tutoriel utilisateurPage 57/69évènements qui ont empêché la génération.Le fichier de log spécifié apparaît en cas d'erreur lors de la génération (cf:Figure 101).Figure 101: Fichier d'erreurIl suffit de double cliquer sur ce fichier pour l'ouvrir dans la fenêtre principale d’Eclipse. (cf: Figure 102).Figure 102: Contenu du fichier d'erreurIl est très important de penser à supprimer le fichier d’erreur avant de relancer la chaîne de génération. Eneffet cela permet de voir si la génération se déroule normalement ou si il y a encore des anomalies.7.3 - Les fichiers “ Properties ”Lors de l'analyse, il a été notifié que les packages des différentes classes Java étaient paramétrées enfonction du script. Bien que modulaire, la modification de la politique de nommage des packages au seind'une entreprise implique la reprise de tous les générateurs de classes Java.Acceleo incorpore un mécanisme de fichiers « properties » afin de pouvoir paramétrer les générations, parexemple pour le nom des répertoires, ou des packages où les fichiers sont générés.Ce mécanisme va être mis en oeuvre pour paramétrer le nom des packages dans le projet Weblog.7.3.1 - Création du fichier “ properties“– Créer un nouveau package “ org.acceleo.modules.uml2.utils ” dans le répertoire “ src ” du projet“ free.demo.weblog ”.– Effectuer un clic droit sur ce nouveau package et sélectionner le menu “ New > File ”.– Dans l'assistant de création de fichier entrer le nom “ config.properties ”(cf: Figure 103).

Acceleo 2.6 : Tutoriel utilisateurPage 58/69Figure 103: Créer le fichierconfig.properties– Le nouveau fichier “ config.properties ” est créé dans le nouveau package utilitaire du projet(cf : Figure 104).Figure 104: le fichier "properties"Ajouter dans ce fichier les clés :package.format=com.enterpriseproject.name=sample

Acceleo 2.6 : Tutoriel utilisateurPage 59/69Lancer la chaîne “ weblog.chain ”. Les fichiers sont maintenant générés dans le package“ com.enterprise.weblog ” à la place de “ org.acceleo.sample ”(cf figure 105).Figure 105: Packages paramétrés à la générationSi un jour, il est décidé de changer le standard de nommage des packages, il suffit de rajouter un fichier“ new_config.properties ” à côté du fichier “ weblog.chain ” et d'y mettre une nouvelle valeur pour la clé“ project.name ”, par exemple “ web.weblog ” (en supposant que la gamme de produit est “ web ” pour leweblog). Lors de la régénération, le nom des packages inclura bien la nouvelle gamme du produit (cf figure106).Figure 106: nouveau fichier "properties" permet denouveau nom de packages

Acceleo 2.6 : Tutoriel utilisateurPage 60/698 - Gestion des évolutions8.1 - Développements manuels8.1.1 - Ajouter du code dans les servletsIl est possible d'ajouter du code dans le source générée. Les portions de code qu’il est possible d'ajouter setrouve entre balises ://Start of user codeet//End of user codePar exemple, pour ajouter du code dans la méthode init (HttpServletRequest req, HttpServletResponse resp)du fichier free.demo.weblog/src/org/acceleo/sample/ihm/CreationCompteServlet.java, il faut procéder ainsi :Dans les balises réservées à l’utilisateur on peut saisir ://Start of user code initif (nom.equals("Julien")){returnCode = PAGE_CONNECTION;}//End of user codePuis, il faut générer à nouveau l’application en lançant la chaîne de lancement.Pour cela :– Redémarrer le serveur.– Faire un clic droit sur le serveur– Sélectionner “ Restart>Start ” (cf: Figure 107).Figure 107: Relancer le serveur– Réactualiser la page courante du navigateur Web. L’action est prise en compte.Si on relance la chaîne de génération le code est gardé.On peut refaire la même manipulation en ajoutant du code hors des balises “ Start of user code ”.

Acceleo 2.6 : Tutoriel utilisateurPage 61/69La modification est prise en compte au nouveau lancement du serveur, cependant le code qui a été ajoutéhors des balises sera supprimé à la prochaine génération.Il est donc primordial de ne pas écrire de code hors des balises réservées à cette effet.8.2 - Évolutions fonctionnelles8.2.1 - Modification du modèle d'entréeDes modifications peuvent bien sûr être apportées au modèle d’entrée.8.2.1.1 - Modification d’un attributIl est possible de modifier un attribut. Pour cela :– Prendre l’attribut “ login ” de la classe “ Utilisateur ” du package “ blog ” dans le package “ metier ”(cf: Figure 108).Figure 108: Le modèle– changer sa propriété “ name ” dans la vue “ Properties ”. Remplacer la propriété “ name ” de valeur“ login ” par “ identifiant ”.L’exemple va porter sur le fichier généré /free.demo.weblog/src/org/acceleo/sample/dto/UtilisateurDto.java.

Acceleo 2.6 : Tutoriel utilisateurPage 62/69Avant la modification, les attributs étaient générés ainsi :public class UtilisateurDto implements Serializable {// serialVersionUID is used for serialization.private static final long serialVersionUID = 1L;protected String email;protected String prenom;protected String nom;protected String login;protected String motDePasse;Pour que les modifications soient prises en compte il faut générer à nouveau les fichiers. Il suffit de relancerla chaîne de génération (cf: 6.1 Lancer une chaîne de génération).Les attributs sont désormais générés ainsi :public class UtilisateurDto implements Serializable {// serialVersionUID is used for serialization.private static final long serialVersionUID = 1L;protected String email;protected String prenom;protected String nom;protected String identifiant;protected String motDePasse;Quand on supprime un attribut, il est supprimé des fichiers générés. Par exemple, si on supprime l’attribut“ email ” du modèle, il n'apparaîtra plus dans la déclaration des attributs du fichier java.

Acceleo 2.6 : Tutoriel utilisateurPage 63/698.2.1.2 - Ajout d’une ClasseIl est possible d'ajouter une classe au modèle.– Ajouter une classe dans le package “ blog ”.– La nommer “ Administrateur ”.– Lui ajouter deux attributs de type ”String”, les nommer “ nom ” et “ prenom ”.– Lui ajouter également un “ keywords ” de valeur “ Entity ”. Pour cela faire un “ Copier/Coller ” de celuiprésent dans la classe Utilisateur (cf: Figure 109).Figure 109: Ajout d'une classeMaintenant que la classe a été ajoutée au modèle, il faut sauvegarder le modèle et relancer la chaîne degénération. Il est possible de remarquer que de nouveaux fichiers java aient été créés (cf: Figure 110).Figure 110: De nouveauxfichiers ont été créesSi une classe avec un stéréotype “ Screen ” (keywords “ Screen ”) avait été créée, alors la génération auraitégalement modifiée le fichier web.xml.De même, si la classe n’avait pas été stéréotypée “ Entity ” (keywords “ Entity ”), il n’y aurait pas eu denouveaux fichiers java créés.8.2.1.3 - Suppression d’une classeIl est également possible de supprimer une classe du modèle.

Acceleo 2.6 : Tutoriel utilisateurPage 64/69– Supprimer la classe “ Administrateur. ” Pour cela faire un clic droit sur “ Administrateur ” et sélectionner“ Delete ”.– Sauvegarder le modèle et relancer la chaîne de génération.Les fichiers correspondant à la classe n’ont pas été supprimés. Il faut les supprimer à la main ou utiliser lachaîne de génération weblog.clean.chain. Attention, le code manuellement inséré dans les balises “Start ofuser code” (cf : 8.1.1 rajouter du code dans les servlets) sera supprimé. Cette chaîne de génération n’est àutiliser que si il n’y a pas eu de code ajouté dans les balises.8.2.1.4 - Renommer une classeIl est possible de renommer une classe. La procédure est identique à celle utilisée pour renommer un attribut(cf: 8.2.1.1 Modification d’un attribut).Une fois la classe renommée et le modèle sauvegardé, il faut lancer la chaîne de génération.Le résultat est identique à celui observé lors de la surpression d’une classe (cf: 8.2.1.3 Suppression d’uneclasse), c’est à dire que de nouveaux fichiers java sont créés mais que les anciens sont toujours présentségalement (cf: Figure 111). Dans l’exemple ci-dessous la classe “ Utilisateur ” a été renommée en“ Blogger ”.Figure 111: Les nouveaux fichiers etles anciens8.2.1.5 - Ajout / modification d’une relation (association / héritage)Il est possible d’ajouter ou de modifier une relation (association, héritage). Pour cela il suffit de modifier larelation dans le modèle, sauvegarder cette modification et lancer la chaîne de génération. La modificationeffectuée apparaît dans les fichiers générés.

Acceleo 2.6 : Tutoriel utilisateurPage 65/698.3 - Les fichiers “ lost ”Si une modification dans le fichier de génération ou dans le modèle intervient et que celle-ci implique unemodification du code généré dans les balises “ Start of user code ” alors un fichier (.lost) est généré.Par exemple si l’on supprime un attribut du modèle et que cet attribut est appelé dans les balises “ Start ofuser code ” alors, en relançant la chaîne de génération, l’ancien code est placé dans le fichier d’extension“ .lost ”.Les fichiers “ .lost ” récupèrent le code utilisateur qui n’est plus valide suite à la modification.Figure 112: Exemple de fichier "lost"

Acceleo 2.6 : Tutoriel utilisateurPage 67/699 - Utilisation avancée9.1 - Lancer une chaîne de génération automatiquement à partir d’EclipseIl est possible de lancer une chaîne de génération à partir de l’icône de lancement d’applicationd’Eclipse.– Cliquer sur la liste déroulante de l’onglet “ run ”.– Sélectionner “ Run... ” .– Double cliquer sur “ Chain ”.– Remplir le champ “ Name ” avec le nom souhaité pour nommer l’action de lancement de la chaîne– Sélectionner la chaîne de lancement en cliquant sur Browse (cf: Figure 114).Figure 114: Sélectionner une chaîne delancementIl est possible de sélectionner plusieurs chaînes de lancement.Pour lancer la chaîne de génération, il faut la sélectionner dans la liste déroulante de l’onglet “ Run ”(cf: Figure 115).Figure 115: Lancer la chaîne degénération

10 - Environnements complémentaires10.1 - La gestion de versionsAcceleo 2.6 : Tutoriel utilisateurPage 68/69Pour pouvoir gérer les versions des fichiers, il faut utiliser un outil de gestion de versions tel que CVS ouSVN.Il est possible de trouver le logiciel libre CVS sur http://www.nongnu.org/cvs/ et le logiciel libre SVN sur http://subversion.tigris.org/. Une fois ces logiciels installés, la façon la plus simple de les utiliser est d'installer lesplugins Eclipse qui correspondent. Le plugin Eclipse pour CVS est installé par défaut. Le plugin Eclipse pourSVN, Subclipse, peut se trouver sur http://subclipse.tigris.org/. Une fois un de ces plugins installé, il estpossible de retrouver les fonctions de gestion de version dans le menu “ Team” du pop-up menu.10.1.1 - Partager un nouveau projetSi un projet n'est pas déjà partagé, il est possible de le partager sur un serveur.Pour cela, faire un clic droit sur le projet à partager. Dans le menu “ Team ” cliquer sur “ Share Project... ”.Si plusieurs logiciels de gestion de versions sont installés (CVS est forcément installé), choisir celui à utiliser(cf. figure 116).Figure 116: Choix de l'outil de gestion de versionRemplir les champs nécessaires : le host, le repository, le login et le mot de passe. Cliquer sur “ Finish ”, lesdonnées peuvent alors être récupérées par une tierce personne.