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
Chamla, Chastanet
6 Novembre 2000 page 2/10
Table des Matières
TABLE DES MATIERES .................................................................................................................................... 2
1. SERIALISATION JAVA ............................................................................................................................. 3
1.1. INTRODUCTION ........................................................................................................................................ 3
1.2. MECANISMES ........................................................................................................................................... 3
1.3. PROSPECTIVES ......................................................................................................................................... 3
2. CORBA ET LE PASSAGE PAR VALEUR ............................................................................................... 4
2.1. INTRODUCTION ........................................................................................................................................ 4
2.2. MECANISME ............................................................................................................................................. 4
2.3. PROSPECTIVES ......................................................................................................................................... 4
3. 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

Modèles à Objet et Sérialisation Olivier Chamla & François Chastanet
Chamla, Chastanet
6 Novembre 2000 page 3/10
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.

Modèles à Objet et Sérialisation Olivier Chamla & François Chastanet
Chamla, Chastanet
6 Novembre 2000 page 4/10
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/xml-
serialization.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

Modèles à Objet et Sérialisation Olivier Chamla & François Chastanet
Chamla, Chastanet
6 Novembre 2000 page 5/10
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