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

TP 2-1
Le système de composants Fractal et son implémentation Java
de référence Julia.
Loïc LAGANE
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 congurables 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éciques).
Le système de composants Fractal est quant à lui plus universel.
2
Présentation
2.1
Le système de composants Fractal
Le système de composants Fractal est un modèle de composants extensible permettant de construire,
déployer et administrer des systèmes logiciels complexes. Il a été déni par l'INRIA et France Telecom
R&D. Ce système de composants dénit donc un framework pour la construction d'applications à
partir de composants en permettant de créer des compositions hiérarchiques.
Une application est donc représentée par un composant racine. Ce composant racine est déni par
l'assemblage de sous-composants, pouvant être eux aussi dénis par un assemblage de sous-composants,
jusqu'à atteindre un niveau de composants primitif.
Les compositions sont soit fonctionnelles (connexion de composants par l'intermédiaire de leur interfaces respectives), soit structurelles (création de nouveaux composants, déni à partir de composants
existants).
Il existe une spécication de ce modèle de composants ainsi que de nombreuses implémentations en
dié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. Le
langage Fractal ADL permet de réaliser la composition de composants de manière déclarative, il est
possible de dénir des composants et de composer des instances de ces derniers.
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 conguration et reconguration.
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.
1
2.2
Composant Fractal
Un composant Fractal est une entité d'exécution dénie par une ou plusieurs interfaces.
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éni en deux parties :
• une partie possédant des interfaces fonctionnelles (décrivant le contenu applicatif du composant)
et des interfaces de contrôle (pour l'introspection et la conguration), appelée membrane,
• l'autre constituée d'un ensemble ni 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).
Exemple de composant Fractal (http://fractal.objectweb.org).
Sur l'exemple, les interfaces clientes et serveurs sont respectivement de couleur verte et de couleur
rouge. Les interfaces de contrôles C, LC, BC et CC représentent respectivement le contrôleur pour
l'introspection, le contrôleur de cycle de vie (LifeCycleController, gestion des phases comportementales
du composant - démarrer ou arrêter l'exécution d'un composant par exemple), le contrôleur de liaisons
(BindingController, gestion des liaisons primitives entre deux interfaces de composants), et le contrôleur
de contenu (ContentController, gestion des sous-composants d'un composant composite). L'interface
de contrôle ServiceAttributes permet quant à elle d'accéder aux attributs du composant.
De plus, des contrôleurs spéciques peuvent être implémentés pour étendre ou spécialiser les capacités
d'un composant.
2.3
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 open source LGPL (consortium ObjectWeb) pour programmer les membranes de composants Fractal. Son but est de simplier le développement d'applications Fractal à
2
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 conguration des composants (en allant de la conguration entièrement
statique et donc performante à la conguration dynamique et moins performante).
Une application Fractal est donc 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 conguration des instances
de composants an de construire l'application.
Avec Julia, un composant Fractal est donc déni à partir de plusieurs objets Java :
• les objets implémentant le contenu du composant, qui sont soit des sous-composants (si le com-
posant 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énis grâce à des fabriques de composants (factory en Anglais). Les instances de
composants sont donc créées à partir de ces fabriques. Une fabrique fournit une méthode de création
qui retourne une nouvelle instance du composant à chaque invocation. Cette instance de composant
peut être activée ou désactivée si le contrôleur implémente l'interface LifeCycleController.
3
Installation et pré-requis
Dans le cadre de ce TP, nous utiliserons l'environnement de développement Eclipse. La page d'accueil
du projet Fractal se trouve à l'adresse suivante : http://fractal.objectweb.org/
3.1
L'API Fractal
L'API Fractal est disponible à l'adresse suivante :
http://forge.objectweb.org/project/showles.php?group_id=22&release_id=912
Nous utiliserons la version 2.0.1 dans le cadre de ce TP.
3.2
Julia
Julia, l'implémentation Java du modèle de composants Fractal, est disponible à l'adresse suivante :
http://forge.objectweb.org/project/showles.php?group_id=22&release_id=1848
Nous utiliserons la version 2.5 de Julia.
3.3
Les autres librairies
Les autres librairies requises sont contenues dans le répertoire nommé externals, fourni avec Julia.
Il s'agit des chiers asm-2.0.jar et ow_monolog.jar.
ASM est un framework permettant de générer ou modier dynamiquement des classes au moment du
chargement en manipulant le bytecode Java (avant que les classes ne soient chargées dans la machine
virtuelle Java).
Monolog fournit un système d'achage d'information de debug et de log à l'exécution.
Vous trouverez plus des informations complémentaires aux adresses suivantes : http://asm.objectweb.org
et http://monolog.objectweb.org.
3
4
Premier exemple
4.1
Introduction
Nous allons tester le système de composants Fractal grâce à son implémentation en Java nommée Julia.
Ce premier exemple est un programme de type Hello World est est inspiré par les programmes fournis
à titre d'exemples avec Julia.
4.2
Mise en place
Créez un nouveau projet Java dans l'environnement de développement Eclipse, nous le nommerons
Julia Helloworld par exemple.
• Importez dans le projet les sources du programme, fournies avec le sujet ci-présent, dans ce
nouveau projet.
• Importez ensuite dans votre projet les sources de l'API Fractal, disponibles dans l'archive fractal-
2.0.1.zip. Pour cela demandez à importer dans le projet Eclispe un système de chiers. Parcourez
l'arborescence jusqu'au répertoire nommé src, puis sélectionnez le répertoire appelé org.
4
• Puis importez les sources de Julia dans votre projet, disponibles dans l'archive julia-2.5.zip et
procédez la même façon que pour l'API Fractal. Importez un système de chiers dans le projet
Eclipse situé dans le répertoire src de l'archive.
5
6
• Importez également l'archive asm-2.0.jar, requise par Julia et disponible dans le répertoire ex-
ternals de l'archive julia-2.5.zip. Pour cela demandez à importez un chier archive.
7
• Récupérez ensuite les chiers de conguration Julia, disponibles dans le répertoire nommé etc
fourni avec le sujet. Copiez ce répertoire etc dans le répertoire principal de votre projet. Il s'agit
de chiers de conguration, utilisant une syntaxe de type LISP et contenant un ensemble de
dénitions utilisées par les fabriques sous forme d'alias :
(nomAlias1 dénitionAlias1)
(nomAlias2 dénitionAlias2)
....
(nomAliasN dénitionAliasN)
4.3
Description des sources
Les interfaces à implémenter sont :
• l'interface Main (Main.java),
• l'interface Service (Service.java) décrivant le(s) service(s) fournis.
L'interface ServiceAttributes (ServiceAttributes.java) décrit les méthodes permettant d'accéder aux
attributs du composant.
8
La classe ClientImpl (ClientImpl.java), implémentant le composant client, doit implémenter l'interface
Main pour pouvoir lancer une requête ainsi que l'interface BindingController an de pouvoir eectuer
les liaisons entre composants.
La classe ServerImpl (ServerImpl.java), implémentant le composant serveur, doit implémenter l'interface
Service et également l'interface ServiceAttributes.
La classe principale HelloWorld (HelloWorld.java) représente le programme principal de l'application.
• On récupère tout d'abord le contexte initial et on crée le bootstrap.
Component boot = Fractal.getBootstrapComponent();
• On récupère la fabrique (ou factory) TypeFactory du bootstrap pour la création des autres
composants.
TypeFactory tf = Fractal.getTypeFactory(boot);
• On crée ensuite les type de composants de l'application grâce à une fabrique , à partir d'une
liste d'interfaces. On peut créer un type rType qui sera utilisé pour le composant racine de
l'application. Les interfaces sont nommées, la vue externe peut contenir plusieurs instances
d'une même interface.
ComponentType rType = tf.createFcType(new InterfaceType[] {
tf.createFcItfType("m", "Main", false, false, false)
});
• On récupère la fabrique GenericFactory du bootstrap pour l'instanciation des composants.
GenericFactory cf = Fractal.getGenericFactory(boot);
• L'instanciation d'un composant se fait donc grâce à cette fabrique, à partir d'un des types de
composants dénis précédemment. On peut donc instancier par exemple le composant racine de
l'application comme étant un composant composite de type rType.
rComp = cf.newFcInstance(rType, "composite", null);
• L'assemblage des composants que l'on vient d'instancier se fait soit en imbriquant des sous-
composants au sein de composants composites, soit en créant une liaison entre deux composants.
Pour réaliser cela, on fait appel respectivement aux méthodes addFcSubComponent de l'interface
de contenu du composant (ContentController) et bindFc de l'interface de liaison du composant
(BindingController).
Fractal.getContentController(rComp).addFcSubComponent(cComp);
Fractal.getBindingController(rComp).bindFc("m", cComp.getFcInterface("m"));
• On active ensuite le composant racine de l'application, ce qui lancera également tous les com-
posants de l'application de façon automatique grâce à la méthode startFc du controleur de cycle
de vie du composant racine (LifeCycleController).
Fractal.getLifeCycleController(rComp).startFc();
• Enn, on appelle la méthode main en passant par l'interface fonctionnelle 'm' de notre composant
racine. Notons que la méthode getFcInterface retourne un type Object qui doit être casté par le
type de l'interface décrivant la méthode du service que l'on va appeler.
((Main)rComp.getFcInterface("m")).main(null);
9
Liens entre les composants de l'exemple HelloWorld (http://fractal.objectweb.org).
4.4
Manipulation
Rendez-vous dans le répertoire de votre projet, grâce à une console puis lancez la commande suivante
:
java -cp . -Dfractal.provider=org.objectweb.fractal.julia.Julia
-Djulia.loader=org.objectweb.fractal.julia.loader.DynamicLoader
-Djulia.cong=etc\julia1.cfg,etc/julia2.cfg HelloWorld
Les options -Dxxx correspondent aux paramètres passés à la JVM pour pouvoir utiliser Julia.
4.5
Résultats
La commande précédente permet donc d'acher un petit message du serveur.
Dans notre cas, l'achage s'eectue deux fois puisqu'on a aecter la valeur 2 à l'attribut count du
serveur.
-> hello world
-> hello world
4.6
Question
On désire acher, en plus de l'achage hello world déjà présent :
* bonjour
* bonjour
* bonjour
An de réaliser cela, il faut procéder en plusieurs étapes :
1. Créez une seconde implémentation client que l'on appellera ClientImpl2 par exemple.
2. Ajoutez au composant racine de l'application un sous-composant client et un sous-composant
serveur. Pour cela, créez deux nouveaux composants c2Comp (ClientImpl2 ) et s2Comp (ServImpl ).
Dénissez les attributs header et count du composant s2Comp de manière à réaliser cet achage.
N'oubliez pas d'ajouter une interface fonctionnelle (que l'on appellera m2 par exemple) à la liste
des interfaces du composant racine rComp.
3. Dénissez les liaisons entre les composants racine rComp, le nouveau sous-composant c2Comp
et le nouveau sous-composant s2Comp.
4. Enn, réalisez un appel à la méthode adéquate pour l'achage.
10
4.7
Correction
La correction se trouve dans le répertoire nommé question fourni avec le sujet.
5
Conclusion
Le système de composants Fractal est hiérarchique (il est possible d'inclure des composants au sein
d'autres composants composites ? d'où le nom Fractal), réexif (avec des capacités d'introspection et
d'intercession) et ouvert (possibilité de personnaliser les services des composants par l'intermédiaire
des contrôleurs). Alors que certains modèles de composants sont très liés à leur domaine d'application,
Fractal est quant à lui plus générique et plus exible.
De plus il n'impose pas de technologie particulière, il est indépendant des langages et plate-formes.
Plusieurs implémentations existent : Think (C), Julia, ProActive et AOKell (Java), FracTalk (SmallTalk)
et FracNet (.NET).
Il est donc possible de dénir des classes de composants, des fabriques, de recongurer dynamiquement les instances, d'eectuer de la composition hiérarchique et d'utiliser les propriétés d'instropection.
Il possède un langage de description d'architecture (Fractal ADL) qui permet de réaliser la composition
de manière déclarative (dénir des composants et composer des instances de ces derniers).
Il n'impose pas un nombre xe d'interface de contrôle, elles sont découvertes à l'exécution.
Il existe également Fractal AOP, qui est une extension du modèle Fractal pour la programmation par
aspect.
Par contre, le modèle Fractal ne dénit pas la manière de conditionner un composant an d'eectuer
un paquetage, comme les chiers jar (pour les composants) ou ear (pour les applications) des EJB.
11