Sémantique d' UML, MOF Laurent Henocque Enseignant Chercheur ESIL/INFO France

Sémantique d' UML, MOF

Laurent Henocquehttp://laurent.henocque.free.fr/

Enseignant Chercheur ESIL/INFO Francehttp://laurent.henocque.perso.esil.univmed.fr/

mis à jour en Octobre 2006

Licence Creative Commons

Cette création est mise à disposition selon le Contrat Paternité-Partage des Conditions Initiales à l'Identique 2.0 France disponible en ligne

http://creativecommons.org/licenses/by-sa/2.0/fr/

ou par courrier postal à Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.

Références Normatives

• L'infrastructure UML • http://www.omg.org/cgi-bin/doc?formal/05-07-05 • La superstructure UML • http://www.omg.org/cgi-bin/doc?formal/05-07-04 • OCL • http://www.omg.org/cgi-bin/doc?ptc/05-06-06

Autres références

• Ce support de cours s'appuie sur des exemples concrets mis à disposition librement sur internet par différentes sources– http://www.rational.com– http://www.visualuml.com– http://uml.free.fr– http://http://www.sparxsystems.com.au/

resources/uml2_tutorial/index.html

Objectifs

• Présenter l'organisation d'UML sur la base de couches d'abstractions successives et illustrer l'utilisation bootstrappée de la méthode

Préambule

• UML est un formalisme de modélisation dont la sémantique et la syntaxe sont formellement décrites

• UML permet de décrire des modèles possédant également cette propriété

• La méthode est "bootstrappée" : un fragment essentiel d'UML (le méta méta modèle) est utilisé pour "auto" décrire la méthode (via un méta modèle)

• Seul le méta méta modèle est dépourvu de justifications autres qu'intuitives

Modélisation = Syntaxe

• Une méthode de modélisation permet de définir des syntaxes

• Une syntaxe décrit un ensemble (infini) de constructions possibles

• Par exemple, un modèle décrira que tous les véhicules ont des roues, éventuellement un moteur, de type diesel ou essence, etc...

Modélisation = Syntaxe sous contraintes

• Par un relatif abus de langage, la documentation UML place sous la rubrique sémantique les règles de bonne formation (well formedness rules) qui s'ajoutent aux descriptions essentiellement graphiques

• Dans ce cadre figurent les contraintes additionnelles portant sur le modèle (dites de bonne formation) : par exemple le fait qu'une voiture de plus de 150 chevaux possède exactement des freins à disque ventilés

4 niveaux de modélisation

Niveau 1 : les instances ou objets

• Les instances sont les objets actuellement réalisés lors de l'exécution d'un programme

• Le rôle du modèle est de définir quelles sont les états possibles et admissibles des objets manipulés par l'application à tout moment

Niveau 1 : les données

• Les instances sont les objets réalisés lors de l'exécution d'un programme, ou stockées dans des bases de données

• Imaginons un système de gestion de données boursières. La base conserve les données numériques associées aux actions

Action("Air France", 3.78€)Action("TF1",7.47€)...

Niveau 2 : le modèle

• C'est la description des classes, de leurs relations, et des contraintes qui servent de "modèle" pour la création d'instances du niveau 1

• L'utilisation d'un modèle permet de contrôler la validité des états du système, et de le documenter

Niveau 2 : le modèle

Record{"Action",

Champ(1,"société",String),

Champ(2,"prix",Num)

}

Action("Air France", 3.78€)

Action("TF1",7.47€)

...

Niveau 3 : le méta modèle

• Le méta modèle définit ce qu'il est possible de modéliser.

• C'est un modèle également, décrit avec un fragment d'UML, dont les classes portent les noms de "Class", "Relation", ...

Niveau 3 : le méta modèle

MetaClass{"Record",MetaAttr("NomClasse",String),MetaAttr("Champs",list<Champ>)}

MetaClass{"Champ",Metaattr("num",int),Metaattr("nom",String),Metaattr("type",Type)}

.

Record{"Action",Champ(1,"nom",String),Champ(2,"prix",Num)

}

Niveau 4 : le méta méta modèle

• Le méta méta modèle est le langage de définition du méta modèle.

• Il est donné sans justification par un ensemble réduit de primitives

• Le langage permettant de décrire le méta modèle doit être auto explicatif : un ensemble minimal de primitives capable de "s'autodécrire".

Niveau 4 : le méta méta modèle

• Par exemple une grammaire BNF :

MM->[MC]*MC->"MetaClass" "{" SC "," [MA]*"}"MA->"MetaAttr" "(" SC "," Ident ")"SC -> "\"" Ident "\""

MetaClass{"Record",MetaAttr("NomClasse",String),MetaAttr("Champs",list<Champ>)}

Niveau 4 : méta méta modèle UML

• Dans le cas d'UML, le méta méta modèle est un fragment minimal des diagrammes de classes, complété par le langage de contraintes (logique) OCL

• Un exemple d'un tel méta méta modèle est le langage MML + OCL

MML : Méta Modeling Language

• On décrit UML avec un fragment de celle-ci• Ce fragment doit avoir des propriétés intéressantes

: • c'est le plus petit fragment possible capable de se

décrire lui-même tout en permettant de décrire UML

• MML est un exemple d'une telle tentative• http://www.cs.york.ac.uk/puml/• http://citeseer.ist.psu.edu/674312.html

Méta méta modèle UML : éléments fondamentaux

classeattributs

role role

multiplicitérelation

héritage

agrégation/composition

Le méta modèle UML

Comprendre la spécification de la méthode UML

Le méta Modèle UML

• Le méta modèle décrit donc ce que l'on peut modéliser.

• Il est documenté par UML et forme le manuel de référence d'UML

• UML n'est assortie de recommandations graphiques que pour la forme : la seule loi est celle définie par le méta modèle, indépendamment des artéfacts graphiques choisis

Fragment du méta modèle UML : les classes

Le Métamodèle = syntaxe des modèles

Organisation du méta modèle : les Packages

Packages fondamentaux de "Foundation"

• Structure statique des modèles

Core : Backbone 1

Core : Backbone 2

Core : Associations 1

Core : Associations 2

Core : Dépendances

Core : Classifieurs

Core : Elements auxiliaires

OCL : Règles de bonne formation

Core Semantics : exemple 1

• [2] No Attributes may have the same name within a Classifier.

• (Unicité des noms d'attributs dans un Classifier)

self.feature->

select(a | a.oclIsKindOf(Attribute))->

forAll(p,q | p.name=q.name implies p=q)

Core Semantics : exemple 2

• No BehavioralFeature of the same kind may match the same signature in a Classifier. (Deux "méthodes" ne peuvent avoir la même signature)

self.feature->forAll(f, g |(((f.oclIsKindOf(Operation) and g.oclIsKindOf(Operation)) or(f.oclIsKindOf(Method) and g.oclIsKindOf(Method)) or(f.oclIsKindOf(Reception) and g.oclIsKindOf(Reception))) andf.oclAsType(BehavioralFeature).matchesSignature(g))implies f = g)

Abstraction

• Une abstraction est une relation de dépendance entre deux éléments ou ensembles d'éléments qui représentent le même concept à deux niveaux d'abstraction, ou selon différents points de vue

• Attributs : mapping• Stéréotypes : «derive», «realize», «refine»,

and «trace»

< un extrait de la documentation >

• In the metamodel, an Abstraction is a Dependency in which there is a mapping between the supplier and the client. Depending on the specific stereotype of Abstraction, the mapping may be formal or informal, and it may be unidirectional or bidirectional.

• If an Abstraction element has more than one client element, the supplier element maps into the set of client elements as a group. For example, an analysis-level class might be split into several design-level classes. The situation is similar if there is more than one supplier element.

Artifact

• Un "Artifact" représente un élément physique d'information utilisé ou produit par le processus du développement logiciel

• Par exemple : les modèles, les sources, les scripts et les fichiers binaires exécutables.

• Un "Artifact" peut constituer l'implémentation d'un composant déployable

Artifact

• Un artifact est un classifier muni d'une agrégation optionnelle avec un ou plusieurs composants

• En tant que Classifieurs, les Artéfacts peuvent avoir des attributs qui représentent leurs propriétés ( par exemple l'attribut “read-only” ou l'opération “check in”).

• Associations : implementation le composant déployable implanté par cet artifact

• Les stereotypes de Artifact sont «file», les sous classes de «file» («executable», «source», «library», et «document»), et «table». Ces stereotypes peuvent être sous classés : (e.g., «jarFile» pour les archives Java).

< un extrait de la documentation >

• It should be noted that sometimes Artifacts may need to be linked to Classifiers directly, without introducing a ‘Component.’

• For instance, in the context of code generation, the resulting Artifacts (source code files) are never deployed as Components.

• In that case, a «derive» Dependency can be used between the Classifier(s) and the generated Artifact.

Association

• Une association définit une relation sémantique entre classifieurs. Ses instances (des "Link"s) sont des ensembles de tuples

• Dans le méta modèle, une association est la déclaration d'une relation sémantique entre deux classifieurs, tels que des classes. Une association a au moins deux extrémités (AssociationEnd), chacune connectée à un classifieur

Association (2)

• Attributs : name• Associations : connection• Stéréotypes : implicit• Contraintes standard : xor (une seule association

est réalisée pour chaque instance associée)• Tagged Values : persistence : le lien survit il à la

disparition de ses extrémités• Features héritables : connection• Features non héritables : name (unique), isRoot,

isLeaf, isAbstract (liés au modèles entier)

AssociationClass

• C'est une association qui est aussi une classe : elle possède ses propres "features".

AssociationEnd : Attributs

• aggregation (none, aggregate,composite), • changeability (changeable, frozen, addOnly), • ordering (unordered, ordered), • isNavigable (true, false), • multiplicity• name• targetScope (instance,classifier)• visibility

AssociationEnd

• Une des extrémités d'une association. Elle est reliée à un classifieur, mais porte aussi les informations associées aux rôles (nom, cardinalités, etc)

• Stéréotypes : association (le défaut), global (la cible est une variable globale), local (la cible est une variable locale), parameter (la cible est un paramètre), self (la cible est l'objet support "this")

AssociationEnd : associations

• qualifier : liste d'attributs de qualification• specification : un ou plusieurs qualifieurs

qui définissent l'interface de programmation minimale qui doit être supportée par la cible quand l'association est traversée

• participant : le classifieur cible• extrémité anonyme de composite :

l'association qui possède ce "end"

Attribute

• Etc ...