TP 2-1 Le système de composants Fractal et son implémentation de

TP 2-1
Le système de composants Fractal et son implémentation de référence Julia.
1 Introduction
Les composants permettent la construction de logiciels à partir de l'assemblage d'entités
logicielles réutilisables. Le but est d'obtenir des entités logicielles composables, déployables
et configurables tout en conservant la performance et la légèreté des applications. Il existe de
nombreux modèles basés sur les composants tels que COM, EJB, CCM, .NET (destinés à des
domaines d'applications spécifiques). Le système de composants Fractal est quant à lui plus
universel.
2 Présentation
2.1 Le système de composants Fractal
Fractal est un modèle de composants extensible pour construire, déployer et administrer
des systèmes logiciels complexes (intergiciels, systèmes d'exploitation par exemple). Il
a été défini par l'INRIA et France Telecom R&D. Ce système de composants définit
donc un framework pour la construction d'applications à partir de composants en
permettant de créer des compositions.
Il existe une spécification de ce modèle de composants ainsi que de nombreuses
implémentations en différents langages (Java, C, C++, SmallTalk, langages .NET). A ce
modèle de composants est ajouté un langage de description d'architecture, Fractal ADL,
basé sur une syntaxe XML extensible.
Les principales caractéristiques de ce modèle de composants sont :
- les composants composites (composants contenant des sous-composants),
- les composants partagés (sous-composants de plusieurs composites),
- la capacité d'introspection,
- les capacités de configuration et reconfiguration.
Le modèle Fractal est extensible. Il permet la personnalisation des capacités de contrôle
des composants de l'application. Les fonctionnalités décrivant les capacités des
composants sont décrites au sein d'entités nommées contrôleurs.
On peut distinguer différents rôles avec le développement d'applications Fractal :
- les développeurs de composants applicatifs s'intéressent à la construction
d'applications et de systèmes à l'aide du modèle de composants Fractal. Ils utilisent
l'API Fractal et construisent les applications à l'aide du langage de description
d'architecture Fratal ADL.
- les développeurs de contrôleurs s'intéressent à la personnalisation du contrôle offerts
aux composants. Ils développent de nouveaux contrôles afin d'adapter les applications à
différents contextes d'exécution (par exemple avec des ressources plus ou moins
contraintes).
- les développeurs de plates-formes fournissent un environnement permettant
d'exécuter des applications et des systèmes écrits à l'aide de composants Fractal. Un
développeur de plate-forme fournit une implémentation des spécifications Fractal dans
un langage de programmation et des mécanismes pour personnaliser le contrôle.

Le développement avec le modèle Fractal permet l'écriture de composants et des
liaisons pour la communication entre composants.
2.2 Composant Fractal
Un composant Fractal est une entité d'exécution définie par une ou plusieurs interfaces.
Une interface implémente un type d'interface spécifiant ses fonctionnalités. Deux
catégories d'interfaces sont présentes :
- les interfaces décrivant les services fournis par le composant, appelées interfaces
serveurs,
- les interfaces décrivant les services requis par le composant, appelées interfaces
clients.
De plus, un composant Fractal est défini en deux parties :
- une partie possédant des interfaces fonctionnelles et des interfaces pour l'introspection
et la configuration, appelée membrane,
- l'autre constituée d'un ensemble fini de sous-composants, appelée contenu.
Les interfaces de la membrane d'un composant peuvent être internes (accessibles par ses
sous-composants) ou externes (accessibles depuis l'extérieur du composant).
Le modèle Fractal fournit deux moyens de spécifier l'architecture de l'application :
- l'imbrication de sous-composants au sein de composants composites,
- la liaison, permettant aux composants de communiquer, qui peut être soit primitive,
soit composite.
Lorsqu'un lien est établi entre une interface serveur d'un composant et une interface
client d'un second composant, il s'agit d'une liaison primitive. Une liaison composite est
quant à elle représentée par un chemin complexe entre deux interfaces et est composée
d'un ensemble de composants de liaisons reliés entre eux par des liaisons primitives.
La spécification Fractal définit un certain nombre de niveaux de contrôles pour la
définition d'un composant :
- la membrane du composant défini peut ne posséder aucun contrôleur (les capacités
d'introspection et d'intercession ne sont donc pas présentes),
- au second niveau de contrôle suivant, une interface Component est fournie et donne
accès aux interfaces clients et serveurs du composant,
- au niveau de contrôleur supérieur, le composant possède des interfaces réifiant sa
structure interne et permettant de contrôler son exécution.
Plusieurs types de contrôleurs sont définis dans la spécification du modèle Fractal :
- les contrôleurs d'attributs du composant,
- les contrôleurs de liaisons (gestion des liaisons primitives entre deux interfaces de
composants),
- les contrôleurs de contenu (gestion des sous-composants d'un composant composite),
- les contrôleurs de cycle de vie (gestion des phases comportementales d'un composant:
démarrer ou arrêter l'exécution d'un composant par exemple).
De plus, des contrôleurs spécifiques peuvent être implémentés pour étendre ou
spécialiser les capacités d'un composant.

2.3 Le langage de description d'architecture : Fractal ADL
2.4 Julia : l'implémentation de référence Java de Fractal
Julia est l'implémentation de référence du modèle de composants Fractal pour des
applications Java. Il s'agit d'un canevas logiciel pour programmer les membranes de
composants Fractal. Son but est de simplifier le développement d'applications Fractal à
travers la génération de classes de support. Un ensemble de contrôleurs est fourni, ainsi que
des mécanismes d'optimisation pour la configuration des composants (en allant de la
configuration entièrement statique et donc performante à la configuration dynamique et moins
performante).
Une application Fractal est conçue à partir d'un ensemble de classes qui implémentent la
logique applicative des composants, une ou plusieurs classes de coordination et une classe
primaire, nommée bootstrap (pour le démarrage de l'application).
Les classes de support sont nécessaires aux classes Java qui implémentent la logique
applicative pour se conformer au système de composants Fractal. Les classes de coordination,
quant à elle, interagissent avec l'API Fractal pour la création des types de composants, la
création et la configuration des instances de composants afin de construire l'application. Le
langage de description d'architecture Fractal ADL permet de simplifier l'écriture des classes
de coordination.
Avec Julia, un composant Fractal est donc défini à partir de plusieurs objets Java :
- les objets implémentant le contenu du composant, qui sont soit des sous-composants (si le
composant est un composite), soit des objets Java (si il s'agit d'un composant primitif),
- les objets implémentant les contrôles du composant,
- les objets référençant les interfaces du composant (lui permettant de posséder des références
vers d'autres composants).
Ces objets sont définis grâce à des fabriques de composants (factory en Anglais).
3 Installation et pré-requis
4 Programme exemple
4.1 Description
4.2 Manipulation
4.3 Résultats

5 Autres implémentations
6 Conclusion