Transcript L'outil MDA acceleo

République Algérienne Démocratique et Populaire
Université Dr Tahar Moulay Saida
Faculté de technologie
Département d’Informatique
L'outil MDA acceleo
Préparé par :
Awad Samir
Bouras Bouhaous
1ère année master RISR
2014 - 2015
Table des matières
1.
Introduction ........................................................................... 2
2.
Définition ............................................................................... 2
3.
Générer des classes Java ......................................................... 2
3.1.
La création d'un projet UML .................................................. 2
3.1.1. Créer un package ................................................................ 2
3.1.2. Créer une classe .................................................................. 3
3.1.3. Créer un attribut ................................................................. 3
3.1.4. Ajouter un profil au modèle ................................................ 3
3.1.5. Créer une Association ......................................................... 3
3.1.6. Valider le modèle ................................................................ 3
3.2.
La création du générateur ..................................................... 3
3.2.1. Template ............................................................................. 4
3.2.2. Les éléments de syntaxe ..................................................... 4
3.2.3. Création du fichier d'exécution ........................................... 5
3.2.4. Usage des balises de code utilisateur .................................. 6
4.
Conclusion .............................................................................. 6
Références ..................................................................................... 7
1. Introduction
Acceleo a été conçu pour permettre d'industrialiser le développement
des applications informatiques et il permet de mettre en œuvre simplement
et efficacement l'approche MDA (Model Driven Architecture).
2. Définition
Acceleo est un outil de génération de code sous Eclipse. Il permet de
concevoir des modules de génération de code dans un langage choisi par le
développeur, à partir d'un ou plusieurs modèles, et fournit aussi des modules
de génération de code prêts à être utilisés (UML vers Java, UML vers C#, etc.).
3. Générer des classes Java
3.1. La création d'un projet UML
Pour créer un projet il suffit de faire un clic droit dans l'environnement de
travail et de choisir l’assistant de création d'un nouveau projet «New >
Other > General > Project», ensuite il faut créer un répertoire «model» dans
ce nouveau projet, pour cela effectuer un clic droit sur le projet et
sélectionner l’assistant de création de répertoire «New > Folder». Après la
création du répertoire:
 Effectuer un clic droit sur le répertoire «model».
 Choisir l’assistant de création de modèle EMF «New > Other >
Example EMF Model Creation Wizards > UML Model».
 Dans le champ «Model Object» choisir «Model».
Un modèle vierge a été créé. Il faut maintenant créer le modèle souhaité.
3.1.1.
Créer un package
 Effectuer un clic droit sur l’élément de haut niveau nommé «Model».
 Choisir dans la liste de «New Child» l’élément «packagedElement
Package».
2
3.1.2.
Créer une classe
Maintenant que le package est créé il va falloir lui ajouter une classe, pour
cela effectuer un clic droit sur le package et sélectionner le menu «New Child >
packagedElement Class».
3.1.3.
Créer un attribut
Maintenant pour ajouter un attribut à cette classe effectuer un clic droit sur
la classe et sélectionner le menu «New Child > ownedAttribute Property».
Il faut aussi compléter le type de l’attribut. Un clic sur le champ type ne
propose pas les types primitifs (tel que String). Pour utiliser les types primitifs, il
faut utiliser les profils UML2.
3.1.4.
Ajouter un profil au modèle
Un profil est un mécanisme standard d'extension du langage UML qui
permet de spécialiser un schéma UML selon un domaine particulier.
Pour utiliser les profils UML2 il suffit de faire un clic droit sur l’attribut et de
sélectionner «Load Resource...». Ensuite 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
3.1.5.
Créer une Association
Pour créer une association entre deux classes il faut se placer sur le package,
faire un clic droit, et choisir l’élément «New Child > packagedElement
Association». Ensuite il faut renseigner le champ «memberEnd» de cette
association pour sélectionner les deux attributs.
3.1.6.
Valider le modèle
Pour vérifier que le modèle est correct, effectuer un clic droit sur l’élément
de haut niveau «Model» et sélectionner «Validate».
3.2. La création du générateur
Dans cette deuxième partie, l'objectif est de créer un module capable de
prendre un modèle UML2 en entrée et de créer un ensemble de fichiers Java.
Le principe de fonctionnement d'Acceleo est le suivant: Acceleo utilise un
template pour générer du code à partir d'un modèle. La réalisation d'un
nouveau module de génération passe donc par la création de templates.
3
Figure 1. Principe général d’Acceleo
Dans un premier temps, il faut créer un projet de génération: exécuter
«File > New > Generator Project». Pour créer le fichier du générateur aller à
«File > New > Empty Generator», ceci lance un assistant en deux étapes. Dans
la première étape, il faut renseigner le type du méta-modèle d'entrée. Le
méta-modèle dans notre cas est UML2 qui a pour URI :
http://www.eclipse.org/uml2/2.0.0/UML
3.2.1.
Template
Un template de génération est un patron qui doit délimiter de façon claire le
texte statique généré et les éléments variables. Dans Acceleo le texte variable
commence par <% et se termine par %>.
3.2.2.
Les éléments de syntaxe
a) Les commentaires: Il est possible de commenter les scripts de
génération en insérant des explications d'une ou plusieurs lignes entre
les balises <% - - et - - %>. Par exemple :
<%--Ceci est un commentaire--%>
b) metamodel: Le mot clé «metamodel» permet de définir le méta-modèle
utilisé dans le script de génération. La syntaxe de cette instruction est:
metamodel URIDeMonMetamodèle
Où URIDeMonMetamodèle est l'URI qui identifie le méta modèle utilisé.
Par exemple pour le méta-modèle UML 2.0 on utilise l’URI :
http://www.eclipse.org/uml2/2.0.0/UML
4
c) script: La balise «script» permet d'identifier le script de génération et le
type d'objet sur lequel il s'applique. La syntaxe de cette balise est:
<%script type="monType" name="identifiant" file=" nomFGénéré "
description="maDescription" post="monPost"%>
Résumé des attributs
Nom
Description
type
Type d'objet sur lequel s'applique le script (classe,
attribut ...)
name
Nom du script
file
Nom du fichier à générer
post
Expression à exécuter sur le résultat de l'évaluation
description Commentaire
Statut
Obligatoire
Obligatoire
Optionnel
Optionnel
Optionnel
d) for: L'instruction «for» est l'implémentation d'une boucle. La syntaxe de
cette instruction est:
<%for (maListeDObjets) {%>
instructions exécutées sur chaque élément de maListeDObjets.
<%}%>
e) if: L'instruction «if» permet de tester une condition. La syntaxe de cette
instruction est:
<%if (expressionBooléenne) {%>
instructions exécutées si expressionBooléenne est vraie
<%} else {%>
instructions exécutées sinon
<%}%>
3.2.3.
Création du fichier d'exécution
L'entrée «New > Chain» du menu contextuel du projet permet de lancer
l'assistant de création d’une chaîne d'exécution :
 Sélectionner à nouveau l'URI de UML2.
 Sélectionner le modèle.
 Cocher le générateur.
5
3.2.4.
Usage des balises de code utilisateur
Pour le moment, toutes les modifications apportées à un fichier généré sont
écrasées à la génération suivante. Pour résoudre ce problème, Acceleo possède
un mécanisme de balises permettant de définir des zones destinées à accueillir
du code utilisateur qui ne sera pas écrasé à la génération suivante. Il faut
ajouter ces balises aux bons endroits dans le template afin de pouvoir insérer
du code utilisateur.
Tout le code cible écrit entre les balises identifiées par <%startUserCode%>
et <%endUserCode%> est protégé et n'est pas écrasé à la génération suivante
ce qui permet de personnaliser le code généré.
Le texte sur la même ligne que la balise <%startUserCode%> est un
identifiant pour la zone de code utilisateur, cet identifiant doit être unique
pour garantir la conservation du code manuel d'une génération à une autre.
4. Conclusion
Cet exposé était une courte introduction des possibilités offertes par Acceleo
pour la génération de code. L'utilisation de l'outil Acceleo apporte une certaine
indépendance vis à vis de la plateforme technologique. De plus la maintenance
est facilitée et on obtient une vraie synchronisation entre le code et le modèle.
Ce dernier passe du statut de modèle documentaire à celui de modèle
productif.
6
Références
[1]. « Acceleo»
Disponible sur : http://fr.wikipedia.org/wiki/Acceleo
[2]. « Acceleo : générateur MDA»
Disponible sur : http://www.acceleo.org/pages/introduction/
7