Table des Matières

DESS ISI - 2000-2001
LOG 10 - Langages et modèles à objets
Responsable: Mireille Blay Fornarino
Modèle à objets et sérialisation:
Sérialisation Java,
CORBA et le passage par valeur,
MOF et XMI.
Olivier Chamla([email protected])
François Chastanet([email protected])
Modèles à Objet et Sérialisation
Olivier Chamla & François Chastanet
Table des Matières
TABLE DES MATIERES .................................................................................................................................... 2
1.
SERIALISATION JAVA ............................................................................................................................. 3
1.1.
1.2.
1.3.
2.
CORBA ET LE PASSAGE PAR VALEUR ............................................................................................... 4
2.1.
2.2.
2.3.
3.
INTRODUCTION ........................................................................................................................................ 3
MECANISMES ........................................................................................................................................... 3
PROSPECTIVES ......................................................................................................................................... 3
INTRODUCTION ........................................................................................................................................ 4
MECANISME ............................................................................................................................................. 4
PROSPECTIVES ......................................................................................................................................... 4
MOF ET XMI ................................................................................................................................................ 5
3.1. INTRODUCTION ........................................................................................................................................ 5
3.1.1.
Qu’est-ce que MOF ? ...................................................................................................................... 5
3.1.2.
Qu’est-ce que XMI ? ....................................................................................................................... 5
3.1.3.
Importance de méta modéliser avec MOF, XMI et UML ................................................................ 6
3.2. PROSPECTIVES DE MOF ET XMI .............................................................................................................. 6
3.3. CONCLUSION............................................................................................................................................ 6
4.
CONCLUSION : QUELLES PROSPECTIVES ? ..................................................................................... 7
ANNEXE A : GLOSSAIRE ................................................................................................................................. 8
ANNEXE B : BIBLIOGRAPHIE ........................................................................................................................ 9
ANNEXE C : INDEX .......................................................................................................................................... 10
Chamla, Chastanet
6 Novembre 2000
page 2/10
Modèles à Objet et Sérialisation
Olivier Chamla & François Chastanet
On annonce que les applications distribuées représentent l'avenir de la programmation.
Java permet avec RMI de concevoir des applications avec des objets implantés sur
différents sites. CORBA, défini par le consortium OMG, permet la même chose et
autorise en plus que les objets qui communiquent ne soient pas écrient dans le même
langage. Le problème est que ces deux technologies utilisent des protocoles et des
mécanisme différents ce qui rend difficile la communication entre les applications, mais
on assiste maintenant à un certain rapprochement.
1. Sérialisation Java
1.1. Introduction
Pour faire communiquer des objets distants, JAVA RMI utilise la sérialisation c’est à
dire l’écriture d’un objet en un flux de bits permettant ainsi à cet objet d’être sauvegardé
dans un fichier dans son état actuel ou d’être envoyé sur le réseau. Ce système permet
ainsi le passage par valeur.
L’invocation de méthodes est accomplie en conservant une copie de l’objet distant.
Lorsque la méthode de cette copie est appelée, JAVA envoie la requête de cette copie à
travers le réseau et retourne la valeur obtenue de manière transparente. Un objet distant
peut être transmis comme argument ou comme résultat de méthodes distantes. C’est alors
l’image virtuelle de l’objet qui est transmis d’une machine virtuelle à l’autre.
L’écriture d’un objet quelconque implique l’écriture de tous les objets reliés(à
condition que ces objets puissent être sérialisés). Les références entre les objets forment
un graphe dirigé et il est nécessaire d’éviter de réécrire deux fois un objet accessible par
plusieurs objets de référence ( pour réduire le stockage et assurer l’intégrité du graphe des
pointeurs entre les objets à la relecture)
1.2. Mécanismes
JAVA utilise un algorithme standard pour sérialiser un objet :
1. l’en-tête de la classe
2. Un code décrivant la version de la classe
3. la valeur de chaque variable d’instance
4. Si une variable d’instance est un objet, sérialisation de l’objet en question
5. Les variables « static » et « transient » ne sont pas écrites.
Entre l’écriture et la relecture de l’objet, la classe de l’objet peut avoir évolué. Même
sans informations sur cette évolution, les processus automatiques de JAVA
SERIALIZATION tenteront de préserver l’intégrité de l’information stockée(gestion de
version). Il est possible de raffiner ce processus en spécifiant soi-même les protocoles de
sérialisation et déserialisation.
1.3. Prospectives
Il y a un rapprochement possible entre RMI et CORBA. En effet une projection
OMG IDL / JAVA est standardisé. Des objets RMI et CORBA peuvent dialoguer.
Chamla, Chastanet
6 Novembre 2000
page 3/10
Modèles à Objet et Sérialisation
Olivier Chamla & François Chastanet
Les mécanismes de sérialisation donnent un aperçu de la structure d’un objet inconnu
dont une base de donnée pourrait faire usage.
La sérialisation est souvent utilisée pour sauvegarder l’état d’une application.
Malheureusement les objets sérialisés sont fragiles, et sont sensibles aux changements que
l’on peut apporter à la structure d’une classe(par exemple si on rajoute un attribut). Donc
XML, apporte une alternative : c’est un fichier ASCII, humainement lisible et éditable,
qui est capable de contenir les données d’un objet. Donc si le logiciel « plante », cela
peut-être un moyen de récupérer ses données facilement, plutôt que d’avoir à utiliser des
méthodes sur les objets pour récupérer ces données. (cf. http://casbah.org/Scarab/xmlserialization.html)
2. CORBA et le passage par valeur
2.1. Introduction
Jusqu'à la sortie de la norme 3.0, CORBA n'autorisait qu'un passage par référence,
pour l'appel de méthodes sur des objets distants. Le passage par valeur (spécifiée depuis
fin 98) est utile lorsque la première vocation de l'objet est l'encapsulation de données, ou
qu'une application veuille explicitement faire une copie de l'objet. Le passage par valeur
n'était pas possible avec CORBA mais avec RMI car RMI est un solution entièrement
Java alors que CORBA est indépendant du langage.
En effet , le problème est que des langages cibles de CORBA (comme C++) n'autorise
pas le chargement dynamique des classes à l'exécution . La solution CORBA consiste à ne
passer que l'état de l'objet et pas l'implémentation, qui doit exister en local.
2.2. Mécanisme
Si on veut invoquer une méthode sur un objet distant, le code d'implémentation de cet
objet est sérialisé et transporté par le réseau jusqu'au client qui crée l'objet en recopiant
l'état de l'objet distant, puis la méthode est exécutée localement.
Une fois le passage(sérialisation+transport) fini et que l'objet a été instancié chez le
client, il n'y a plus de relation entre l'objet distant et l'objet local.
Si l'implémentation locale n'est pas valide par rapport à l'implémentation distante,
celle-ci est téléchargée.
-
Il y a deux sortes de "Value Type":
Concret (stateful): Les informations qui sont contenues par le serveur sont sérialisées
Abstrait (stateless): équivalent aux classes abstraites, l'avantage est que le code est
exécuté sur le client.
2.3. Prospectives
Les spécifications du passage par valeur ajoute à CORBA la possibilité de définir des
objets qui peuvent être passés par valeur plutôt que par référence. L'approche
Chamla, Chastanet
6 Novembre 2000
page 4/10
Modèles à Objet et Sérialisation
Olivier Chamla & François Chastanet
traditionnelle qui consiste à cacher l'implémentation derrière une interface à distance peut
être revu par une approche plus dynamique.
ORBacus (une implémentation de CORBA) permet le passage par valeur.
En utilisant le passage par valeur, CORBA se rapproche de Java RMI qui l'utilise
depuis toujours. Ainsi Sun et l'OMG ont définis un mapping JAVA vers IDL qui permet à
un client C++ d'invoquer des méthodes sur un serveur RMI. (cf. Java RMI/IIOP).
3. MOF et XMI
3.1. Introduction
Pour la conception d’un logiciel, souvent les entreprises utilisent plusieurs outils. Le
problème est donc d’échanger les informations entre tous ces outils, il faut donc un format
unique d’échange de données.
3.1.1. Qu’est-ce que MOF ?
Le MOF(Modelling Object Facility) est une spécification OMG pour établir un
« canevas générique pour représenter de la méta-information dans un contexte
d’application ».
En 1999, on peut lire : « Cette spécification améliore la gestion et l’interopérabilité de
la meta-information dans les environnements objet distribués en général et dans les
environnements de développement distribués en particulier. Le MOF définit aussi un
meta-meta-modèle simple mais pourvu d’une sémantique suffisante pour décrire des
meta-modèles dans de nombreux domaines, à commencer par celui de l’analyse et de la
conception objet. »
Les instances de MOF sont donc des méta-modèles, UML en est un exemple(il permet
de générer des modèles de conception) ou CWM(Common Warehouse Model), EJB, etc.
Les instances du méta-modèle UML sont des modèles(classes). Et tout le monde sait que
les instances d’une classe sont des objets.
3.1.2. Qu’est-ce que XMI ?
Le but principal de XMI(eXtensible markup language Metadata Interchange) est de
permettre l’échange facile de metadonnées entre des outils de modélisation(basé sur
l'OMG UML) et de dépôts de metadonnées (basé sur OMG MOF) dans les
environnements distribués hétérogènes. XMI intègre trois clés de l'industrie:
XML - un standard W3C,
UML - un standard OMG,
MOF - un standard OMG
XMI est la nouvelle façon standard industrielle de faire ceci, ce qui évite de créer une
multitude de formats propriétaires pour chaque outil spécifique à un vendeur. De plus,
XMI est destiné à être un format "stream". Il peut être entreposé dans un système de
Chamla, Chastanet
6 Novembre 2000
page 5/10
Modèles à Objet et Sérialisation
Olivier Chamla & François Chastanet
fichier traditionnel ou peut être transféré à travers Internet à partir d'une base de données
ou d'un dépôt(cf. repository, warehouse).
3.1.3. Importance de méta modéliser avec MOF, XMI et UML
XMI facilite l’alignement avec d’autres standards qui utilise une architecture métamodèle.
Le format XMI inclut la définition de la structure ainsi que l’information elle-même,
l’avantage de ceci est l’évolutivité, la flexibilité et c’est facilement analysable
syntaxiquement. Les outils, même s’ils n’implémentent pas toutes les fonctions décrites
dans le document, peuvent ne traiter que celles qu’ils ont besoin ou qu’ils savent traiter.
l’inconvénient est la place que le document prend rapidement. Une moitié de solution
à ce problème est la possibilité en XMI d’encoder seulement les parties d’un modèle qui
aurait été modifiées.(cf. [XMI] §6.9 Transmitting Metadata Differences). (AVOIR)
Pour éviter des pertes de données entre les différents outils qui importeront un fichier
XMI, et pour faciliter l’évolution de ces outils, XMI est pourvu d’une balise d’extension
pour les données spécifiques à un produit. L’analyseur syntaxique n’aura pas besoin de
lire ces données, sauf s’il y est habilité.
3.2. Prospectives de MOF et XMI
XMI est basé sur les standards XML, UML, et MOF ce qui le rend des plus
utilisables. Ceci pourrait donner l'exemple à beaucoup d'applications qui utilisent leurs
propres formats de stockage, et utiliser un format commun, pourquoi pas en utilisant
XML. Tout ceci, afin d'éviter les interminables import-export entre applications.
XMI permet de simplifier nettement le développement d'applications destinées à
pouvoir partager des informations. (6 applications peuvent être entièrement reliées par 12
ponts, en utilisant XMI).
XMI permet la génération très simple de rapport, puisqu'il est possible de le
transformer en document HTML à l'aide de fichier XSL (comme tous fichiers XML).
XMI permet d'échanger des données, mais également des structures de données,
indépendamment des architectures matérielles => Sérialisation portable.
3.3. Conclusion
Unisys, IBM, Oracle and Platinum ont déjà commencé à prototyper l’intégration de
XMI dans leurs produits respectifs.
UREP repository démontre l’interopérabilité des modèles entre des outils produits par
différents vendeurs.
Chamla, Chastanet
6 Novembre 2000
page 6/10
Modèles à Objet et Sérialisation
Olivier Chamla & François Chastanet
4. Conclusion : Quelles prospectives ?
Les applications distribuées, que l'on annonce déjà omniprésente dans les années à
venir, bénéficient de la recherche et des spécification des grands entreprises comme Sun
et des grands consortium comme l'OMG. En effet leurs efforts permettent à tous les
utilisateurs de partager des objets définis dans des langages différents. Le nouveau
passage par valeur en CORBA et les rapprochements avec RMI permettent de profiter
encore davantage de ces "ponts" puisque on peut même faire communiquer des objets
CORBA et des objets RMI.
Pour conclure on peut dire que XML est un langage qui permet beaucoup
d’interopérabilité, et XMI qui est un sous-ensemble de XML en est un très bon exemple.
Tout ceci va permettre une facile évolutivité pour les logiciels de demain.
Chamla, Chastanet
6 Novembre 2000
page 7/10
Modèles à Objet et Sérialisation
Olivier Chamla & François Chastanet
Annexe A : Glossaire
XML : eXtensible Markup Language(Langage Extensible de Balisage) du w3c Consortium est un
format universel pour des documents et des données structurés. XML est un Métalangage, qui va
permettre d'inventer à volonté de nouvelles balises pour isoler toutes les informations élémentaires
(titre d'ouvrage, prix d'article, numéro de sécurité sociale, référence de pièce…), ou agrégats
d'informations élémentaires, que peut contenir une page Web. (ex : Une API XML pour la
sérialisation).
XSL : eXtensible Stylesheet Language, est un langage permettant de spécifier une feuille de style. Il
permet la transformation d’un document XML, l’utilisation la plus courante est de le transformer en
document HTML.
Métalangage : est un langage de langage, c’est-à-dire un langage qui permet de générer d’autres
langages.
XMI : cf. Qu’est-ce que XMI ?
MOF : cf. Qu’est-ce que MOF ?
CORBA : la montée du travail distribué, dans des environnements de plus en plus hétérogènes,
demande de nouvelles solutions pour assurer l'interopérabilité des applications sur différentes platesformes. C'est un défi technique majeur, que l'OMG a relevé avec CORBA.
OMG : (Object Management Group) est un groupe de travail créé par de nombreux partenaires de
l'industrie informatique. Son objet est de promouvoir l'utilisation combinée des techniques objet et de
l'informatique répartie. Pour cela, elle définit des normes et des architectures, que des entreprises de
logiciels se chargent d'implémenter. Pour en savoir plus sur CORBA.
RMI : Remote Method Invocation permet de faire communiquer des programmes java par le réseau.
DOM : une fois le document XML analysé et transformé en un arbre d’objets java, DOM est une
interface qui permet d’accéder à ces objets. Pour en savoir plus sur DOM.
UML : Unified Modeling Language ou Langage de Modélisation Unifiée – permet de modéliser
graphiquement une application.
Chamla, Chastanet
6 Novembre 2000
page 8/10
Modèles à Objet et Sérialisation
Olivier Chamla & François Chastanet
Annexe B : Bibliographie
Nous avons utilisé :
Sérialisation :
 http://www-sop.inria.fr/koala/XML/serialization/
 http://www.javasoft.com/products/jdk/1.1/docs/guide/serialization/
 http://wdvl.com/Authoring/Languages/XML/Java/serialization.html
CORBA :
 http://www.omg.org/
 http://corbaweb.lifl.fr/
MOF et XMI :
 http://cgi.omg.org/cgi-bin/doc?ad/98-10-05 (On peut trouver dans ce document tout
ce qui concerne l’utilisation de XMI, sa production, son analyse, ses attributs, ses
DTDs, …)
 http://www-4.ibm.com/software/ad/standards/xmi.html
Chamla, Chastanet
6 Novembre 2000
page 9/10
Modèles à Objet et Sérialisation
Olivier Chamla & François Chastanet
Annexe C : Index
C
CORBA .......................................................................................................................................................................... 4
ORBacus .................................................................................................................................................................... 4
passage par valeur ...................................................................................................................................................... 4
J
JAVA ............................................................................................................................................................................. 3
RMI ............................................................................................................................................................................ 3
RMI/IIOP ................................................................................................................................................................... 4
Sérialisation ................................................................................................................................................................ 3
M
MOF ............................................................................................................................................................................... 5
X
XMI ................................................................................................................................................................................ 5
XML............................................................................................................................................................................... 5
Chamla, Chastanet
6 Novembre 2000
page 10/10