Chapitre 3 : Approche MDA et Validation des modèles
L'Approche MDA (Model-Driven Architecture) est une méthode qui utilise des modèles comme
base principale pour le développement logiciel. Ses principes clés incluent :
1. Séparation des préoccupations : Représentation de l'architecture via des modèles abstraits,
indépendants des technologies.
2. Automatisation : Génération automatique de code ou d'applications à partir des modèles.
3. Interopérabilité : Assurer la cohérence entre les composants logiciels construits avec différentes
technologies.
4. Portabilité : Faciliter le transfert des applications sur diverses plateformes sans nécessiter une refonte
du code.
Les modèles MDA
1. PIM (Platform Independent Model) :
Spécifie l'application indépendamment de la technologie.
Concerne la partie métier de l'application.
2. PSM (Platform Specific Model) :
Spécifie l'application pour une plate-forme technologique donnée.
3. CIM : Computation Independent Model
Spécification du système, point de vue extérieur de l'utilisateur
4. PDM : Plateform Deployment Model
Modèle d'une plate-forme de déploiement
Avantages MDA :
1. capitalisation du code métier
2. indépendance des plates-formes (migration, . . . ),
3. Génération de code
Les relations entre les modèles MDA
1
L'architecture de MOF1.4 : Les étapes du développement MDA:
Les techniques de base associées à l’IDM dans le cadre de MDA
Techniques de modélisation :
1. Soit en spécifiant un nouveau type de modèle,
2. Soit en utilisant UML ou une extension d’UML via un profil.
3. Sérialisation des modèles (XMI).
Techniques de vérification de modèles :
1. Utilisation de l'OCL (Object Constraint Language).
Techniques de transformation :
1. M2M (Modèle vers Modèle) : Transformation de PIM vers PSM.
2. M2T (Modèle vers Texte) : Transformation de modèles en texte, par exemple, UML vers
SQL ou UML vers Java.
Partie 2 : Validation des modèles avec OCL
Objectif de la validation des modèles :
La validation et la vérification sont essentielles dans l'Ingénierie Dirigée par les Modèles (MDE).
Elles garantissent que les modèles sont corrects, cohérents et respectent les exigences fonctionnelles
et non fonctionnelles.
Validation formelle avec des contraintes OCL
L’OCL (Object Constraint Language) est un langage de spécification utilisé pour définir des contraintes
sur les modèles.
2
Ces contraintes peuvent être des règles de cohérence ou d'intégrité, validées pour s'assurer que le
modèle respecte certains critères.
Caractéristiques du langage OCL
Langage de contraintes pour UML.
Forme simple, non ambiguë, avec une grammaire précise.
Spécifie des informations non couvertes par UML.
Standardisé par l’OMG (v2.0).
Utilisable pour tout type de modèles (ex : Ecore).
Applicable à tous les niveaux (modèle, méta-modèle).
Utilisation de l'OCL
Langage déclaratif : Les contraintes ne sont pas opérationnelles.
Sans effet de bord : Les instances ne sont pas modifiées par les contraintes.
Une expression OCL décrit une contrainte à respecter, pas une implémentation d’opération.
OCL peut s'appliquer à la plupart des diagrammes UML.
Applications des contraintes OCL :
Description des invariants de classe.
Préciser les pré-conditions et post-conditions des opérations.
Imposer des contraintes sur la valeur retournée par une méthode.
Initialisation d’un attribut.
Règles de dérivation des attributs (préciser la valeur d’un attribut dérivé).
Expression des gardes dans les diagrammes dynamiques.
Spécification du corps d’une opération.
Notion de contexte
Chaque contrainte OCL est liée à un contexte spécifique, l'élément auquel la contrainte est attachée.
Syntaxe : context monContexte <stéréotype> nomContrainte : Expression de la contrainte
Le contexte peut être utilisé dans une expression avec le mot-clé self.
Exemple :
context Compte : l’expression OCL s’applique à la classe Compte, c’est-`a-dire à toutes les instances de cette classe
context Compte::getSolde() : Real l’expression OCL s’applique à la méthode getSolde()
context Compte::créditer(somme : Real) l’expression OCL s’applique à la méthode créditer
context Compte:solde : Real l’expression OCL s’applique à l’attribut solde
Invariants
Un invariant exprime une contrainte qui doit être respectée en permanence pour un objet ou un groupe d'objets.
3
Syntaxe :
<stéréotype> : inv
Exemples :
Pré-conditions et Post-conditions
Pré-condition : Vérifie les valeurs d’entrée avant l'exécution de l’opération.
Post-condition : Spécifie les effets après l'exécution de l’opération.
Exemples :
L'âge à attribuer doit être valide et supérieur ou égal à l'âge actuel.
La somme doit être positive et le solde est mis à jour.La méthode
retourne la valeur de somme.
Opérateurs :
@pre : Accède à la valeur avant l'opération.
result : Accède au résultat de l’opération.
Retour d’une opération
Spécifie le corps d’une opération
Définit directement le résultat d’une opération
<stéréotype> : body
Exemple:
4
Valeur initiale et dérivée d’un attribut
Spécifier la valeur initiale ou dérivé d’un attribut
<stéréotype> : init derive
Exemple:
MME S
Définition de variables et d’opérationsBAIEB- COURS ID
Opérateurs conditionnels :
Les contraintes conditionnelles sont utilisées pour exprimer des relations entre différentes contraintes.
Syntaxe :if expr1 then expr2 else expr3 endif
Types énumérés
5
Types Collection en OCL
Set :Un ensemble non ordonné d’éléments uniques.Exemple : { 1, 4, 3, 5 }
OrderedSet :Un ensemble ordonné d’éléments uniques.Exemple : { 1, 3, 4, 5 }
Bag :Semblable à un Set, mais permet les doublons.Exemple : { 1, 4, 1, 3, 5, 4 }
Sequence :Un Bag dont les éléments sont ordonnés.Exemple : { 1, 1, 3, 4, 4, 5 }
Opérations Prédéfinies sur les Objets
oclIsKindOf(type) :Vrai si l’objet est du type type ou de l’un de ses sous-types.
oclIsTypeOf(type) :Vrai si l’objet est du type type.
oclAsType(type) :L’objet est "casté" en type type.
Exemple avec Héritage :
Dans B : self.oclIsKindOf(ClasseB) et self.oclIsKindOf(ClasseA) sont vrais.
Dans A : self.oclIsKindOf(ClasseB) est faux.
Accès aux objets et navigation en OCL :
Accès aux attributs et opérations :self.attribut et self.operation pour accéder à l'attribut et
l'opération.
Navigation dans les associations : Vous pouvez naviguer dans les associations avec le nom de
la classe ou le nom du rôle.
Opérations sur les collections en OCL :
size() : Nombre d'éléments dans la collection.
count(obj) : Nombre d'occurrences d'un objet dans la collection.
sum() : Somme de tous les éléments de la collection.
exists(uneExpression) : Vrai si au moins un élément satisfait l'expression.
isEmpty() / notEmpty() : Vérifie si la collection est vide ou non.
includes(obj)/excludes(obj) : vrai si la collection inclut/n’inclut pas l’objet obj
includesAll(ens)/excludesAll(ens) : la collection contient tous/ne contient aucun des éléments
AllInstances() : retourne toutes les instances de la classe référencée
forAll(elem :T|uneExpression) : vaut vrai si et seulement si uneExpression est vraie pour tous les
éléments de la collection.
6
union : Retourne l’union de deux collections
intersection : Retourne l’intersection de deux collections
select : filtre les éléments selon une contrainte.
reject : exclut les éléments selon une contrainte.
--> collection->operation() : Utilisation de la syntaxe pour appliquer une opération à une collection.
