ingénierie des modèles - fil.univ-lille1.frmarvie/download/meta3.pdf · •raffinement •un...

1Ingénierie des modèles (b) © 2003-2005, Raphaël Marvie

Ingénierie des modèlesb. Exploiter et produire

Raphaël MarvieLIFL - IRCICA

Université de Lille [email protected]

http://www.lifl.fr/~marvie


Menu

IntroductionModel Driven Architecture

• PIM, PAM, POUMTransformations de modèles

• Récupération et innovationsMise en œuvre

• D’un modèle de composants au code JavaConclusion


Introduction


Problème (rappel)

• La logique métier est mélangée avec le codetechnique• Vrai pour toutes les technologies

• L’évolution des applications n’est pas simple• Garder la logique métier• Jeter le code technique

• Nécessite de s’abstraire des technologies


Une solution

• Séparation des préoccupations• Préoccupations métier• Préoccupations techniques

• Modélisation des systèmes• Description abstraite des préoccupations métiers• Réutilisation dans différentes contextes (technologies)

• Comment automatiser l’utilisation (etréutilisation) des modèles abstraits de systèmes


Des modèles aux systèmes

• Passer du modèle contemplatif…• Utilisation informelle (documentation)• Définition manuelle de projections (idl -> java)

• …au modèle productif• Production automatisée de code• Définition de projections standardisées


Model Driven Architecture



• Définition de méta-modèles• Standardisation d’un domaine d’activité• Standardisation des technologies

• Définition d’une méthodologie• Démarche à suivre pour produire une application, dans une

technologie, à partir d’un modèle abstrait

• Il existe différents types de modèles



• PIM: Platform Independant Model• Définit la structure et les fonctions d’un système• Indépendant des détails technologiques

• PSM: Platform Specific Model• Définit la mise en œuvre de la structure et des fonctions

dans une technologie particulière

• PDM: Platform Definition Model• Définit une technologie particulière


WS

Model Once Generate Everywhere

Modèle indépendant detoute technologie

Génération de code pourplusieurs paltes-formes

System PIM

.NetCCM


Un processus logiciel naïf

PSM SystèmeProjectionPIMProjection

Rétro-ingénierieRétro-ingénierie

RaffinementRaffinement


Exemple de processus MDA

• Définition d’une application à base de composants• Définition de la structure de l’application• Raffinement pour spécifier les fonctions

• Mise en œuvre dans un langage orienté objets• Définition des correspondances (projections)• Évaluation des projections

• Production de code• Génération du code Java correspondant au modèle


Méta-modèle simple de composants

Provided

Port

Required

ComponentXXS

Component

Connection

usesprovides

* *

11fromto


D’un PIM de composants (base)…Application

«Component»

Notifier«Component»

Observer«provides»«uses»

obs itf

Structure du système


…A un PIM (raffiné)…Application

«Component»

Notifier«Component»

Observer«provides»«uses»

«Interface»

INotify

+ notify (String)

type

obs itf

Fonctions du système


Méta-modèle simple de Java

Parameter

Method

Attribute

type

attributes

methods

type

JavaXXS

Class

super


…A un PSM pour Java…Application

«Class»

INotify

+ notify (String)

«Class»

Observer

+ provides_itf ()

«Class»

Notifier

+ connect_obs (INotify)+ disconnect_obs ()

- obs

- itf


…Au code Javaclass Observer { private INotify _itf ; INotify provides_itf () { // return this._itf ; }}

class Notifier { private INotify _obs ; void connect_obs (INotify o) { // this._obs = o ; } void disconnect_obs () { // this._obs = null ; }}

class INotify { void notify (String s) { // write code }}


Transformations de modèles


Pourquoi des transformations?

• Raffinement• Un modèle A1 devient un modèle A2• Même méta-modèle pour les deux• [Structure puis fonctions]

• Projection• Un modèle A1 devient un modèle B1• Méta-modèles distincts• [Composants -> Java]

• Représente la base• Production de systèmes dirigée par les modèles• Support de l’interopérabilité entre les systèmes


Définition de transformations

• Transformation = ensemble de règles• Correspondances entre éléments du modèle

source et éléments du modèle cible

• Exemple: projection d’un composant vers Java• Une interface de port devient une classe Java• Un composant devient une classe Java

• Provide devient attribut privé• Provide devient méthode publique provides_* (<Itf>)


Exemple de transformation (*)transformation comp2java rule comp2clss forall Component cc make Class c, jc.name = cc.name linking cc to jc by comp2clss rule itf2clss forall Interface it make Class cl, cl.name = it.name linking it to cl by citf2jclss rule op2meth forall Operation op where itf2class links op.itf to Y make Method me, me.name = op.name, Y.methods += me linking op to me by cop2jmeth

(*) Syntaxe définie et proposée lors de la première soumission de MOF QVT à l’OMG (M. Lawley, R. Marvie et J. Steel)

rule provides2java forall Port p where p.kind == "provides" && citf2jclss links p.type to XX && comp2clss links p.owner to YY make Attribut a, a.name = "_" + p.name, Argument a1, a1.type = XX, Method m, m.name = "provide_" + p.name, m.returntype = a1, YY.method += m, YY.fields += a linking p to a by port2attr linking p to a1 by port2arg linking p to m by port2meth


Modèle de transformations

• Modélisation d’une transformation• Définition d’une transformation• Utilisation des concepts de transformations

• Méta-modèle de transformation• Définit les concepts relatifs aux transformations• Parallèle: syntaxe du langage Java pour écrire des

programmes


Transformation dirigée par les M2

Comp. basedModel

Component Metamodel

MOF

TransformationMetamodel

JavaMetamodel

Comp2javaTrans. Model

Java basedModel


Moyens et standards

• Langages de (méta-)modélisation• MOF, UML, OCL

• Un langage de transformation unifié• MOF 2.0 QVT RFP

• Un standard de sérialisation de modèles• MOF XMI (XML Metadata Interchange)

• Des définition de M2, PDM, Trans• Pour chaque domaine d’activité


Mise en œuvre


Réaliser des transformations

• Exemple Composant -> Java• Utilisation des deux méta-modèles

• Plusieurs mises en œuvres possibles• Utiliser un formalisme de description

• MOF QVT en cours de définition• Utilisation d’XSLT sur des modèles en XMI

• « Coder » la transformation• Langage de programmation• Utilisation de référentiels MOF pour les modèles


Mise en œuvre avec XSLT

• Langage de transformation de documents XML• Projection vers HTML ou XHTML• Application de feuilles de styles XSL

• Une transformation XSLT• Ensemble de pattern à rechercher• Structure des éléments à produire

• Utilisation avec des modèles écrits en XML• Version très light de XMI pour dérouler l’exemple

XSLT: Une transformation

• Une transformation est définie par une feuillede style XSL qui Contient un certain nombre detemplates

<?xml version="1.0"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">



</xsl:stylesheet>


XSLT: Un template

• Un template définit une règle de transformation• Pattern dans le document source• Texte à produire dans le document cible / templates

à appliquer (sous-templates)

<xsl:template match="compmodel"> <javamodel> <xsl:apply-templates /> </javamodel></xsl:template>


XSLT: Accéder aux valeurs

• Un nœud XML• Contient du texte -> récupérer la valeur• Contient un sous-nœud -> récupérer sa valeur

<xsl:template match= "name"> <name> <xsl:value-of select= ". " /> </name></xsl:template>

<xsl:template match= "Port"> <class><name> <xsl:value-of select= "name" /> </name></class></xsl:template>


Modèle de l’application (comp. i)

<?xml version="1.0"?><compmodel>

<basetype> <bname>String</bname> </basetype>

<basetype> <bname>void</bname> </basetype>

<port> <name>INotify</name> <operation> <return>void</return> <name>notify</name> <parameter> <name>msg</name> <type>String</type> </parameter> </operation> </port>


Modèle de l’application (comp. ii)

<component>

<name>Observer</name> <provides> <type>INotify</type> <name>itf</name> </provides> </component>

<component> <name>Notifier</name> <uses> <type>INotify</type> <name>obs</name> </uses> </component>

</compmodel>


Modèle de l’application (java i)

<?xml version="1.0" encoding="UTF-8"?><javamodel>

<class> <name>INotify</name> <method> <return>void</return> <name>notify</name> <parameter> <name>msg</name> <type>String</type> </parameter> </method> </class>

<class> <name>Observer</name> <attribute> <type>INotify</type> <name>_itf</name> </attribute> <method> <name>provide_itf</name> <return>INotify</return> </method> </class>


Modèle de l’application (java ii) <class> <name>Notifier</name> <attribute> <type>INotify</type> <name>_obs</name> </attribute> <method> <name>connect_obs</name> <parameter> <type>INotify</type> <name>obs_</name> </parameter>

<return>void</return> </method>

<method> <name>disconnect_obs</name> <return>void</return> </method> </class>

</javamodel>


Mise en œuvre « codage »

• Référentiels de modèles• Produit à partir des M2• Règles de projections MOF

• Programme• Parcours du référentiel source

(Exemple: pattern visiteur)• Production d’éléments dans

référentiel destination

Référentiel Modèles Comp.

Référentiel Modèles Java

Transformationcodée


Extrait de transformation (python)

def itf2clss (input, output): for itf in input.interface: clss = output.create_jclass () ; clss.name = itf.name ; for op in itf.operation: meth = clss.create_method () ; meth.name = op.name ; meth.type = op.type ; for arg in op.parameter: param = meth.create_parameter () ; param.name = arg.name ; param.type = arg.type ;


Remarques

• XSLT• Peut paraître plus simple à mettre en œuvre• Limité dans les capacités de transformation• Ne permet pas de produire le code

• « Codage »• Plus technique à mettre en œuvre• Aucune limite en terme de transformation• Implique de disposer de référentiels (ModFact)

-> Nécessité de disposer d’un langage adapté


Exercices

• Définir complètement en XSLT latransformation du modèle de Composantsau modèle Java et l’exécuter avec lesupport d’exécution Xalan.

• Faire la même chose avec un script Pythonet l’environnement fourni (référentiel demodèles de composants, référentiel demodèles Java, extrait de transformation).


Conclusion


Conclusion

• Principaux paradigmes de l’ingénierie logicielle• Raffinement de procédures• Composition d’objets• Transformations de modèles

• Ingénierie dirigée par les modèles• Approche innovante et prometteuse• Beaucoup de travail (chantier ~10 ans)

• Une nouvelle évolution de l’ingénierie logicielle• Qui était dans l’air depuis quelque temps


Perspectives

• Définir un méta-modèle de transformations• Comprendre les mécanismes sous-jacents• Définir le standard MOF 2.0 QVT• On y travaille :o)

• Outillage pour processus logiciels « MDA »• Produire un environnement adapté (depuis M2)• Disposer de moteurs de transformations• Définir des méthodologie de spécification de processus• On y travaille aussi :o))


Références

• Les spécifications de l’OMG• UML, MOF, OCL, QVT

• Les travaux des projets ou labos• Triskel (Rennes), Atlas (Nantes)• DSTC (Brisbane, .au)

• Les techniques de compilations• Une transformation est au bout du compte une

forme de compilation…• Un petit coup de Google :o)

ingénierie des modèles - fil.univ-lille1.frmarvie/download/meta3.pdf · •raffinement •un...

Documents