MDA : Un Tutoriel - RZO Web Page

MDA : Un Tutoriel
Introduction pratique au D´eveloppement orient´e Mod`ele
Pierre Parrend, Mars 2005
1 Sommaire
Table des mati`eres
1 Sommaire 1
2 Introduction 2
2.1 A qui s’adresse ce tutoriel . . . . . . . . . . . . . . . . . . . . . . 2
2.2 Principe................................ 2
2.3 Organisation du tutoriel . . . . . . . . . . . . . . . . . . . . . . . 4
3 Du Mod`ele au Code 5
3.1 Installer Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.1.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.1.2 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.2 Installer EMF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.3 Mon premier programe avec EMF . . . . . . . . . . . . . . . . . 6
3.3.1 Comment ca marche ? . . . . . . . . . . . . . . . . . . . . 6
3.3.2 L’exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.3.3 Bilan.............................. 7
4 Une autre approche de la cr´eation de mod`eles : les diagrammes
UML 8
4.1 Installer Poseidon . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2 Mon premier programme avec Poseidon . . . . . . . . . . . . . . 8
4.2.1 La mod´elisation UML . . . . . . . . . . . . . . . . . . . . 8
4.2.2 R´ealisation d’un mod`ele complet . . . . . . . . . . . . . . 9
4.2.3 R´ealisation d’un programme ex´ecutable . . . . . . . . . . 10
4.2.4 Bilan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5 La Transformation de Mod`eles 11
5.1 Le Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
5.2 Transformation de mod`eles eCore . . . . . . . . . . . . . . . . . . 11
5.3 Transformation de mod`eles avec ATL . . . . . . . . . . . . . . . . 11
6 Bilan 12
6.1 Les transformations r´ealis´ees . . . . . . . . . . . . . . . . . . . . 12
6.1.1 Les Formats . . . . . . . . . . . . . . . . . . . . . . . . . . 12
6.1.2 Les Outils . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
6.2 Outils utilis´es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
7 Glossaire 14
1

2 Introduction
2.1 A qui s’adresse ce tutoriel
Ce tutoriel a pour vocation d’ˆetre une introduction `a MDA (Model Driven
Architecture) par la pratique. Il vise `a donner une bonne connaissance des outils
utilis´es dans un processus MDA, afin de permettre de mieux comprendre les
probl`ematiques de conception.
Toute personne int´eress´ee par MDA trouvera donc un point d’entr´ee dans
cette m´ethode nouvelle de conception de logiciels : d´eveloppeurs, ´etudiants, mais
aussi concepteurs qui ont besoin de savoir quels sont les outils disponibles en
appui des concepts.
Ce tutoriel n’aborde pas ces probl`ematiques de conception. Ni les aspects,
nombreux, sp´ecifiques `a tel ou tel domaine d’application. Et par cons´equent
passe sous silence des ´etapes telles que la conception des mod`eles, la cr´eation
de langage sp´ecifique `a un domaine.
Il s’agit de montrer ce qui est possible de faire avec MDA, et certains des
outils existants.
Le d´eveloppeur qui a besoin de ces outils pourra travailler en exploitant les
diff´erentes transformations propos´ees.
Le concepteur qui voudra mettre en place un processus MDA pour des appli-
cations de taille cons´equente pourra utiliser les informations pr´esentes comme
point de d´epart, qui sera utilement compl´et´e par l’approfondissement du proces-
sus de conception, tel qu’il est pr´esent´e par exemple sur le site web du ’Model-
Driven Software Development’ :
http ://www.mdsd.info
2.2 Principe
Ce tutoriel est une introduction `a MDA dans le cadre d’un d´eveloppement
en langage Java.
Les Outils utilis´es ne sont pas les seuls existants, mais offrent un environne-
ment de d´eveloppement complet et ´evolutif. Ils permettent de supporter l’en-
semble de la chaˆıne de transformation MDA :
– mod´elisation UML,
– transformation interm´ediaires,
– g´en´eration de code.
Cette suite de transformations est illustr´ee par l’image suivante :
2

La mod´elisation C’est une ´etape pr´ealable. Elle se fait en utilisant les outils
conceptuels d’UML (Unified Modeling Language). Elle aboutit `a un ensemble
de mod`eles de la future application, repr´esent´es par des diagrammes de classes.
A partir de ces diagrammes de classes UML, des mod`eles manipulables sont
g´en´er´es (au format XMI).
L’int´egration Plusieurs mod`eles sont utilis´es pour la cr´eation d’une applica-
tion. Typiquement, il s’agit de mod`eles repr´esentant des fonctionnalit´es diff´erentes.
Ils sont assembl´es en un seul mod`ele, qui repr´esente l’application, et sont `a partir
de l`a manipulables comme un unique mod`ele.
La transformation A partir de mod`eles g´en´eriques, il s’agit de pr´eciser ce
que sera l’application : format de donn´ees, r´ealisation des fonctionnalit´es. Le(s)
mod`ele(s) de l’application sont donc compl´et´es, affin´es.
Typiquement, il s’agit `a ce niveau de transformer un m´eta-mod`ele (mod`ele
de mod`ele, qui indique les contraites que doit respecter l’application), en mod`ele
fonctionnel, dot´es de services particuliers.
Il peut ´egalement s’agir de transformer un mod`ele fonctionnel ind´ependant
de l’application (PIM - Platform Independant Model) en mod`ele prennant en
compte les contraintes de d´eploiement (PSM - Platform Specific Model).
La g´en´eration de code Lorsque le mod`ele est complet, le code est g´en´er´e.
L’application peut alors ˆetre d´eploy´ee.
Dans la pratique, le code g´en´er´e doit ˆetre compl´et´e : l’impl´ementation des
diff´erentes m´ethodes, par exemple, n’est pas explicit´ee dans le mod`ele.
3

En cas d’extension ult´erieure du mod`ele, il est indispensable de disposer
d’un environnement de d´eveloppement qui conserve le code ajout´e. Si ce n’est
pas le cas, le d´eveloppement incr´emental est rendu beaucoup plus laborieux, et
la cr´eation de grandes applications est compromise.
Le stockage et l’acc`es Les mod`eles peuvent ˆetre r´eutilis´es pour le d´eveloppement
d’autres applications, mais ils sont ´egalement accessibles par les applications
elles-mˆeme. La sp´ecification MOF (Metadata Object Facility) permet de d´efinir
des bases de donn´ees de mod`eles accessibles de mani`ere transparente par les
applications.
2.3 Organisation du tutoriel
Le tutoriel est organis´e comme suit :
Comment passer d’un mod`ele UML `a un code ex´ecutable ? Deux
solution sont abord´ees :
1. G´en´eration de code par la plate-forme Eclipse. Le mod`ele est alors exprim´e
sous forme de Java annot´e. Le code peut ˆetre compl´et´e parall`element au
mod`ele, `a l’int´erieur de Eclipse : la reg´en´eration ne provoque pas la perte
des modifications manuelles.
2. G´en´eration de code par la plate-forme Pos´eidon. Le mod`ele UML est
repr´esent´e sous forme graphique. Par contre, la g´en´eration de code ´ecrase
les versions pr´eexistantes.
Comment transformer des mod`eles ? De mˆeme, deux solutions sont abord´ees :
Transformation de mod`eles MOF Eclipse (format ecore),
Transformation de mod`eles quelconques. On utilise pour cel`a la plate-forme
ATL (Atlas transformation Language), disponible sous forme de plugg-in Eclipse.
4

3 Du Mod`ele au Code
La premi`ere partie du tutoriel est une introduction `a la g´en´eration auto-
matique de code `a partir d’un mod`ele. Nous nous pla¸cons dans le cadre de la
plate-forme Eclipse.
Les ´etapes de la manipulation sont :
1. La premi`ere ´etape consiste `a cr´eer un mod`ele UML.
2. Ce diagramme UML doit ˆetre traduit en Java annot´e pour ˆetre compris
par Eclipse. Nous verrons comment faire la traduction.
3. Ensuite, un mod`ele de type MOF est g´en´er´e, `a partir de Java Annot´e. Le
format eCore est l’impl´ementation Eclipse de la sp´ecification MOF.
4. Le mod`ele existant peut ˆetre enrichi.
5. Le code java est g´en´er´e `a partir des objets eCore enrichis.
6. Une fois les classes g´en´er´ees, il est souvent indispensable d’impl´ementer
les fonctionnalit´es de ces classes. Les m´ethodes et variables peuvent ˆetre
compl´et´ees, mais le mod`ele lui-mˆeme ne peut pas ˆetre modifi´e (afin de
permettre la reg´en´eration de code sans perte de donn´ees).
7. Si l’on a besoin de reg´en´erer le code - souvent apr`es avoir enrichi le mod`ele
- les ajouts manuels sont conserv´es.
Cette m´ethode permet donc un d´eveloppement incr´emental.
3.1 Installer Eclipse
3.1.1 Installation
T´el´echargez la plate-forme de d´eveloppement int´egr´e Eclipse depuis l’adresse
suivante :
http ://www.eclipse.org/downloads/index.php
Installez-la.
3.1.2 Prise en main
Vous pouvez cr´eer un programme ’Hello World’ pour vous aclimater `a Eclipse.
Pour cel`a :
1. Cr´eez un nouveau projet Java (Fichier >Nouveau >Autres ; S´electionnez
Projet Java ; suivez le wizard),
2. Cr´eez une classe Java, avec une m´ethode main() (Fichier >Nouveau >Classe
Java ; suivez le Wizard),
3. Modifier le code pour afficher la phrase voulue,
4. Ex´ecutez votre programme (Ex´ecutez >Ex´ecutez en tant que >Application
Java).
5