Toujours pour JavaOne, j’avais fait un article pour Solutions logiciels cette fois plus orienté analyse et moins technique. J’ai pris pas mal de plaisir à le faire tant ca fait du bien de temps en temps de prendre un peu de recul sur ce qu’on fait. Un petit aperçu ici (je sais c’est illisible mais c’est un magazine qui parait dans les kiosques !)

Sun a cette année encore conservé sa grand’ messe consacrée à Java : JavaOne, qui n’est jamais que la 14^ème édition (et oui déjà). Généralement, JavaOne est l’occasion pour Sun comme pour d’autres sociétés pour faire les annonces phares de l’année et donner une vue d’ensemble de l’année écoulée et de l’année à venir.

Si on pouvait s’attendre à des annonces retentissantes, la tendance a plutôt été à la déception cette année. Le thème était centré sur l’utilisateur, qu’il soit final ou développeur, d’où le nom JAVA+YOU. Sun a tenu à montrer comment les dernières évolutions de Java étaient tournées vers l’apport de fonctionnalités plus attractives pour l’utilisateur final et la simplification de l’utilisation de la plate-forme pour le développeur. Voici tout de même les annonces qui ont été faites lors des sessions :

OpenSolaris

OpenSolaris (projet Indiana), piloté de façon intensive par Ian Murdock (fondateur de Debian) depuis son arrivé chez Sun (il y a environ un an) est désormais disponible sous forme de binaires notamment en Live CD, comme n’importe quelle distribution Linux. Ce Live CD vient avec le support ZFS (qui est d’après moi, le seul vrai aspect intéressant), le nouveau système de packaging baptisé IPS (Image Packaging System) et DTrace, l’outil de profilage et d’analyse dynamique de performance développé par Sun.

Update 10

Sun a bien entendu parlé de la ‘Preview Release’ de l’attendue Update 10 du JDK. Elle marque un tournant majeur par la modularité du JRE (le consumer JRE) constitué d’un kernel léger qui téléchargera les modules complémentaires au fil des besoins permettant un démarrage plus rapide notamment des applets. Car c’est le grand retour des applets (si, si !). Sun a soigné le plugin Java afin de permettre aux applets une exécution en tâche de fond et surtout, combiné à JavaFX, de pouvoir faire un drag and drop de l’application sur le bureau, puis la remettre dans le navigateur ou encore la conserver hors ligne sur son poste. La démo lors de la session a malheureusement crashé plusieurs fois (soi disant à cause de la taille des tuyaux au Moscone Center) mais cette fonctionnalité était vraiment intéressante et apportait quelque chose de nouveau par rapport à Flex et LiveCycle, que JavaFX (disponible dans l’update 10) cherche à concurrencer.

JavaFX

Sun a massivement misé sur cette plate-forme même si l’annonce date en réalité de JavaOne 2007. De nombreuses sessions étaient disponibles cette année. Neil Young (voudraient-ils copier Apple ?) fut invité sur scène pour montrer comment grâce au support BlueRay et JavaFX de la PlayStation 3 de Sony, il était capable de réaliser une application JavaFX permettant de lire tous ses disques, ses vidéos en HD et même de recevoir les mises à jour des archives depuis internet. L’accent est mis d’ailleurs sur la phénoménale quantité de matériel qu’il est possible de mettre sur un disque BlueRay, Neil Young déroulant une liste de tous ces titres, longue d’une bonne dizaine de mètres ! L’application est bluffante par son ergonomie et son interactivité et constitue un bel exemple de ce qu’il est possible de faire. Sun nous dévoile son planning pour JavaFX :

• Juillet 2008 : JavaFX Desktop SDK Early Access Program
• Automne 2008 : JavaFX Desktop 1.0
• Printemps 2009 : JavaFX mobile et TV 1.0

Java et la mobilité

L’accent le plus fort a sans conteste été mis sur la disponibilité de Java sur les matériels portables. Java a cherché à montrer son adaptabilité sur les terminaux et sa pénétration sur ce marché. Sun a martelé plusieurs discours (Schwartz, Green et Gosling s’y sont mis !) sur le fait que l’information doit être partout, toujours à portée et que Java se doit de permettre de la diffuser. Nombre de démos se sont donc enchaînées sur le sujet à commencer par la démonstration de LiveConnect (celle-là même qui a servi pour la démonstration du plugin java) directement sur le JRE d’un GSM puis via Android. Cette dernière démo cherchait certainement à rassurer les développeurs Java concernant Android et sa compatibilité avec les standards de Sun, Android utilisant sa propre version de Java (Apache Harmony). Mais ces démonstrations étaient des amuse-gueules par rapport à celles présentées lors de la session de James Gosling :

Tout d’abord, Sentilla a démontré une petite carte électronique de la taille d’un timbre poste qui permet de connecter des capteurs et de réaliser des programmes Java embarqués. Cette puce permet de rendre intelligent des objets simples (pervasive computing). Une première démo montre comment, à l’aide de capteurs infrarouges placés aux portes de la salle de session, il a été possible de suivre les personnes entrant et sortant au fil du temps et par session. Une autre démo montre comment rendre intelligentes de grosses balles qui sont lancées dans la salle. Chacune de ces balles embarque des capteurs et leurs mouvements sont traqués par d’autres puces Sentilla réparties dans la salle pour être envoyés vers une application Swing permettant de représenter leur position dans la salle.

Javacard 3.0 a également été démontré à travers un concours de programmation de robots : chaque participant devait réaliser la stratégie de combat de son robot et la charger sur une carte à puce. Celle-ci était ensuite lue par le programme central qui consistait en une application Swing affichant les robots en train de combattre. Cette démonstration, amusante, permet toutefois de comprendre la puissance de ces cartes embarquant Java et pouvant contenir des programmes jusqu’à 1 Go ! Ceci est d’autant plus intéressant quand on sait que JavaCard 3.0 fournit un conteneur de servlets, le protocole HTTP et la pile TCP/IP…

Enfin, dernière démonstration, de loin la plus impressionnante, celle de Pulse, un stylo intelligent réalisé par la société LiveScribe. Il s’agit d’un stylo qui permet d’enregistrer et de synchroniser à la fois l’écriture et la voix. Le concept est difficile à expliquer tant c’est inimaginable mais chaque mouvement du stylo et ce qui est écrit est enregistré dans le stylo via une mini caméra en même temps que le son. Une reconnaissance d’écriture est effectuée. Lors de la relecture des notes, il suffit de cliquer sur son cahier (vraiment !) et le stylo rejoue le son enregistré à ce moment là. Le contenu peut être envoyé sur un PC pour traitement par une application desktop qui permet de faire de la recherche plein texte. De plus le contenu peut être partagé sur internet via une application Flex. On peut voir la démo sur leur site (http://www.livescribe.com).

On a aussi vu le projet WebSynergy, résultant de la collaboration Sun et Liferay et visant à développer de façon conjointe une plate-forme de présentation web incorporant à la fois le portail Liferay , GlassFish, OpenPortal, OpenSSO et d’autres projets. De même, Apple sort (presque) en silence la version 6 de java pour OSX et rien sur le support de Java sur iPhone. JavaOne n’a également pour ainsi dire reçu aucun écho de l’annonce par SpringSource de la mise à disposition de Spring Application Platform, un serveur permettant de faire tourner à la fois des applications J2EE et des applications Spring et se basant sur Spring DM kernel (anciennement Spring OSGi). Enfin, JBoss a organisé un évènement SpeakEasy (soirée privée avec des boissons et de la nourriture à volonté) pour annoncer la sortie de JON (JBoss Operation Network) 2.0, une solution centrale de gestion d’un parc applicatif réparti sur n machines, basé sur Hyperic.

Coté pavillon

Du côté des exposants, on pourra noter que le stand Nokia s’est réduit à sa plus simple expression, tout comme celui d’Adobe (qui s’est fait tout petit pour laisser de la place à JavaFX ?), le haut du pavé étant tenu par Motorola, Intel, AMD et Oracle. Faut-il comprendre quelque chose sur le fait que les panneaux du booth Oracle portent également le logo de BEA ?

Au niveau des démonstrations, Liferay présentait sa nouvelle release de Liferay (5.0), SpringSource sa Spring Application Platform, et des démos GlassFish partout de la part de Sun. En dehors des sentiers battus j’ai pu voir une démonstration intéressante de EAF (Enterprise Application Fabric) de la société Appistry qui propose de rendre ‘gridable’ une application Spring sans rien toucher au code. Côté serveur, EAF joue le rôle d’un container Spring distribué permettant de jouer l’application sur plusieurs serveurs et côté client, l’application est re-’wiré’ pour utiliser l’EAF. La démonstration montrait les temps de réponse mais aussi la capacité de tolérance aux pannes, puisqu’un des serveurs est brutalement coupé lors d’une démonstration de mise à jour massive de la base. Autre plate-forme d’avenir, l’à présent connu TerraCotta qui n’en finit pas de m’épater. Pour les personnes ne connaissant pas encore TerraCotta il s’agit d’une solution Open Source de clustering mais au niveau VM. La solution est complètement transparente pour les applications et permet d’avoir une granularité très fine sur ce qui est répliqué. Les utilisations sont multiples et enthousiasmantes, peut-être plus que JavaSpaces.

Les sessions techniques

Si de nombreuses sessions furent décevantes, quelques-unes méritaient une attention particulière. Côté Java 7, une chose est claire c’est que c’est flou. Seules certaines fonctionnalités sont à peu près certaines d’arriver dans la nouvelle version du JDK (multi-catch, safe re-throw). De plus, ceux-ci qui avaient déjà une indigestion à cause des annotations vont être servis avec l’intégration de la JSR 308 (annotations étendues) dont le but est de réduire le nombre de bugs qui peuvent passer dans du code à cause de vérifications insuffisantes du compilateur. Les annotations aujourd’hui ne sont en effet possibles aujourd’hui que sur les déclarations (de classes, de méthodes, d’attributs, de statements). Le but est d’ajouter des annotations à l’utilisation d’un type, à la déclaration d’une variable locale ou encore sur les casts (si si !). L’ajout de checker pluggables permettra de réduire considérablement le nombre de bugs mais hélas au profit d’ajout de nombreuses annotations. Par ailleurs, mais cela a déjà été couvert lors du précédent dossier Java 7, on retrouvera également l’API Java modules qui permettra de modulariser les applications et résoudre certains problèmes de Classpath, ainsi que la toute nouvelle API NIO2 qui permettra de bénéficier de plus de fonctionnalités natives des systèmes de fichiers comme les permissions, les liens symboliques ou encore les notifications.

JMC

Java Media Component est une API dont le but est de remplacer JMF tout en simplifiant. Cette API est réellement des plus simples et se base sur quatre objets :

• JMediaPlayer : un JComponent qui permet de jouer un media et fournit les boutons de contrôle
• JMediaPane : un JComponent qui permet de jouer un media sans les contrôles
• MediaProvider : un media player de plus bas niveau qui peut rendre des objets graphiques ou passer des données brutes à un autre système de rendu
• Media : une classe permettant de récupérer des informations sur le media en lui-même.

L’API est extrêmement simple à utiliser :

JMediaPlayer mp = new JMediaPlayer (new URI(”movie.mov”));

mp.play();

Mais l’aspect le plus intéressant est qu’une version script de cette API est disponible pour utilisation dans FXScript. Ces classes sont disponibles dans le package javafx.gui. Leur implémentation est basée sur les classes de JMC et supportent les animations, la transparence et les effets. L’effet de reflet sur une vidéo à la Apple est du plus bel… effet !

Java EE

Côté JavaEE, la grande nouveauté est évidemment l’API servlet 3 qui comblera des manques historiques (méthodes login et logout atteignables au niveau de la servlet, enfin me direz-vous mais malheureusement encore en cours de discussion) et ajoutera des fonctionnalités utiles comme :

• le support des servlets asynchrones avec la possibilité de suspendre une requête et de la reprendre (utile surtout dans le cas d’utilisation de Comet),
• la facilité de développement avec l’introduction de nouvelles annotations (@Servlet, @PUT, @GET, @ServletFilter, @ServletContextListener, …)
• la pluggabilité avec la possibilité pour les frameworks d’apporter un fragment de web.xml qui sera ajouté au web.xml de votre application

Et surtout, bien sûr, la fameuse capacité à déployer des EJBs directement au sein des WARs, fonctionnalité d’ores et déjà supportée par GlassFish.

En ce qui concerne JSF 2.0 c’est encore très flou et on en connaît encore que les grands axes :

• faciliter le développement de composants (ce qui n’est pas un mal)
• support AJAX
• le Page Description Language (PDL)
• réduire la complexité de configuration
• permettre une meilleure compatibilité entre les fournisseurs de librairies tierces

Bilan

Finalement cette édition 2008 est plutôt en demi-teinte et si l’excitation était quasi palpable le premier jour (longues files d’attente dans tous les sens pour les sessions) tout est très vite retombé. Sun nous a resservi JavaFX, mais s’il était intéressant de voir comment la technologie a progressé, le manque de support au niveau des IDEs et une syntaxe à la fois nouvelle et illisible (FXScript) n’encouragent pas à l’adoption. Ainsi malgré le martèlement fait au niveau des sessions, une grande majorité du public reste sceptique. 2008 sera peut-être le grand retour de l’applet (ironique, non ?).

Côté JDK et J2EE, aucune grande nouvelle, mais les nombreuses démos de GlassFish V3 (ultra-rapide, léger, modulaire) laissent penser qu’il pourrait bien s’agir là du prochain serveur d’applications Open Source de prédilection, en remplacement de JBoss. OSGi devrait également être amené à s’imposer, prenant de cours la spécification de Java Modules qui ne devrait paraître avec le JDK 7 que courant 2009.

Ouf ! MTC3 est terminé. Ca fait déjà la troisième année que j’organise cet événement est à chaque fois après l’événement je me sens vidé mais en même temps apaisé. Il y a toujours énormément d’angoisse et de choses à régler avant l’instant T et j’ai toujours peur d’avoir zappé quelque chose. Mais ce qui est surtout toujours le plus stressant surtout ici à Luxembourg c’est d’avoir des inscrits. Quelle lutte pour faire comprendre aux gens que le contenu est de qualité et que ca vaut le coup de se déplacer ! La plupart du temps les gens pensent que ca va être très marketing et qu’il n’y aura pas de vrai contenu. Cette année nous avons envoyé plus de 200 courriers papiers et passé au moins le double de coups de fil, envoyé 2 courriers électroniques à plusieurs centaines de personnes. Et force est de constater que nous avons pu obtenir… 19 inscrits ! Woaw cela montre soit qu’il faut vraiment poursuivre l’effort pour faire prendre conscience aux gens que l’Open Source est mature et utilisable, soit que les gens en sont déjà convaincus. Je pencherais pour la première hypothèse. Quoi qu’il en soit voici un petit compte-rendu de cet après-midi. J’ai réalisé une petite introduction très rapide et ai rapidement passé la main à Christophe Lombart. Christophe a eu la difficile tache de résumer en une demi-heure ce que peuvent être les problématiques de gestion de contenu, et comment les adresser. La présentation était d’un bon niveau et Christophe a réussi à délivrer en très peu de temps les messages essentiels. Je pense que ca a été dur pour lui car j’avais dejà demandé de réduire quasiment de moitié sa présentation initiale et malgré cela le temps lui a tout de même un peu manqué. Alain Escaffre a pris la suite et il faut dire qu’il a vraiment joué de malchance avec un freeze complet de son Mac lorsqu’il a connecté le cable vga du projecteur sur sa machine. Il a perdu près de 20 minutes à arriver à projeter quelque chose et a été beaucoup destabiliser par cela. Je pense tout de même que les messages essentiels ont été passé mais la présentation n’a pas réellement fait apparaître à sa juste valeur le produit et la communauté. Bertrand a ensuite pris la parole et franchement sa présentation était terrible ! Tout le monde a été clairement impressionné par sa qualité d’orateur, la clareté de l’exposé et du message. Bertrand a détaillé point à point les buts et la philosophie d’Apache notamment les 4 grands axes :

• une vision partagée : tout le monde a toute l’information et le droit d’apporter son avis via les mailing lists qui sont publiques et archivées
• mises à jour en temps réel : les projets reçoivent un feedback en temps réel de la part des développeurs et des utilisateurs afin de corriger le tir au plus vite. Mais les outils eux-mêmes fournissent également des mises à jour en temps réel notamment via JIRA mais aussi continuum, l’outil d’intégration continue
• des demandes d’aide en temps réel : un tracking permanent est réalisé à travers JIRA
• des archives en self-service : toute la documentation est disponible pour éviter d’avoir à dépendre d’une personne spécifique

Les points étaient particulièrement clairs et limpides et plusieurs personnes m’ont dit (et j’adhère) que cela donnait envie de participer aux projets ou même d’adopter ce mode de travail. Bertrand a ensuite expliqué comment migrer vers ce mode de collaboration et bien sûr cela ne peut se faire que de façon progressive sans quoi on braque l’équipe de développeur et tout est perdu. Enfin, Bertrand a parlé un peu de JackRabbit mais pus intéressant : de Sling. Sling est une couche REST légère qui se pose au-dessus d’une implémentation JCR afin d’exposer le contenu en lecture/écriture de façon très simple et efficace.Les possibilités offertes sont vraiment très intéressantes. Il a d’ailleurs fait de la pub pour un concours de programmation lancé par Day. Encore une fois : excellente présentation parfaitement adaptée à l’auditoire, claire, dans les temps, parfait quoi ! La présentation de Bertrand a suscité pas mal de questions et la reprise après la pause café s’est faite un peu en retard (10 min pas plus ) et Denis Dorval a pris la relève en exposant avec des arguments bien rodés pourquoi aller vers l’Open Source. La démonstration est imparable. Toutefois, Denis a un peu empiété sur notre temps de parole ;p Nous enchaînons Alain et moi avec une démonstration d’un front-end Flex pour Alfresco réalisé suivant deux approches. Il s’agit juste de 2 études de cas très rapides mais juste histoire d’illustrer les possibilités. Nous cédons rapidement la parole à Mike Farman qui présente plutôt en détail les fonctionnalités.Dommage toutefois que le temps lui ai manqué puisqu’il a surtout présenté les fonctionnalités déjà connues et pas du tout parlé de la prochaine version (v3) d’Alfresco. Au final, les présentations étaient encore d’après moi (mais c’est peut-être un peu biaisé) d’excellente qualité et je suis content d’avoir pu à nouveau proposer à Luxembourg un contenu de haut niveau. Dommage toutefois que nous ayons encore du mal à trouver le public. Mais je suis sûr que nous allons parvenir à quelque chose ! Ne desepérons pas (même si j’avoue que cette fois ca a vraiment été dur… )

Si la première moitié des années 90 a marqué l’avènement de la programmation orientée objet, la seconde moitié a, quant à elle, largement été dominée par l’utilisation de la programmation par composants. Peut-être pensez-vous n’avoir jamais programmé par composants et être ainsi passé à côté de tout sans vous en rendre compte. Détrompez-vous si vous avez un jour réalisé des EJB, des composants COM, CCM ou encore .NET. Ces modèles de composants, pas toujours bien réussis avaient en tout cas un point commun : proposer un modèle d’implémentation des interfaces exposées contractuellement en communalisant certaines fonctions qu’elles soient métiers ou techniques (sécurité, transaction, RMI, clustering…).

De la théorie…

Afin de démontrer ce que peut être la programmation par composants en évitant toute polémique ou tout effet de mode, j’ai choisi d’utiliser le modèle de composants Fractal. Il s’agit d’un modèle défini par France Telecom R&D et l’INRIA dès 2000 et qui n’a cessé d’évoluer depuis. Il se présente sous la forme d’une spécification et d’implémentations dans différents langages de programmation comme Java, C, C++, SmallTalk ou les langages de la plate-forme .NET. Fractal est organisé comme un projet du consortium OW2 (anciennement ObjectWeb). Les caractéristiques principales du modèle Fractal sont motivées par l’objectif de pouvoir construire, déployer et administrer des systèmes complexes tels que des intergiciels ou des systèmes d’exploitation. Le modèle est ainsi basé sur les principes suivants :

• composants composites (composants qui contiennent des sous-composants) pour permettre d’avoir une vue uniforme des applications à différents niveaux d’abstraction.
• composants partagés (sous-composants de plusieurs composites englobants) pour permettre de modéliser les ressources et leur partage, tout en préservant l’encapsulation des composants.
• capacités d’introspection pour permettre d’observer l’exécution d’un système.
• capacités de (re)configuration pour permettre de déployer et de configurer dynamiquement un système.

Fractal est conçu pour être extensible et prouve cette capacité à travers la mise en œuvre de l’implémentation du modèle EJB3 pour JoNAS. Un composant Fractal est une entité d’exécution qui possède une ou plusieurs interfaces. Une interface est un point d’accès au composant. Il existe deux catégories d’interfaces : les interfaces serveurs – qui correspondent aux services fournis par le composant -, et les interfaces clients qui correspondent aux services requis par le composant. Un composant Fractal est généralement composé de deux parties : une membrane – qui possède des interfaces fonctionnelles et des interfaces permettant l’introspection et la configuration (dynamique) du composant -, et un contenu qui est constitué d’un ensemble fini de sous-composants. La membrane d’un composant est constituée d’un ensemble de contrôleurs. Les contrôleurs peuvent être considérés comme des méta-objets. Chaque contrôleur a un rôle particulier : un contrôleur peut, par exemple, permettre de suspendre/reprendre l’exécution d’un composant.

Les composants discrets, une fois écrits, doivent être assemblés afin de construire un édifice logiciel. Cet assemblage peut être fait programmatiquement ou plus simplement à l’aide du langage XML de Fractal ADL.

… A la pratique !

Afin de démontrer rapidement et simplement l’utilisation de Fractal, j’ai choisi de reprendre un exemple simple type HelloWorld directement issu des exemples fournis par Fractal. Tout d’abord téléchargez Fractal en téléchargeant le zip fraclet-annotation-2.0 à cette URL : http://forge.objectweb.org/project/showfiles.php?group_id=22. Fraclet fournit un jeu d’annotations Java 5, évitant la création de code spécifique Fractal fastidieux ; il fournit l’ensemble des jars permettant de mettre en œuvre Fractal à savoir l’API, l’implémentation Java de Fractal (dénommée Julia) et Fractal ADL. Créez un nouveau projet Eclipse. Créez un répertoire lib et placez-y les librairies fournies dans fraclet-annotations-2.0 : les jars situés dans externals et ceux situés dans examples/common/lib. Ajoutez ces librairies au classpath du projet. Nous allons créer un composant qui contiendra 2 sous-composants :

Créez d’abord l’interface du composant Service :

@Interface(name="service")public interface Service {  void print();}

L’annotation utilisée comme les suivantes proviennent de fraclet qui permet à l’aide de l’outil Spoon de générer le code final du composant et les descripteurs de composants XML (de Fractal ADL). Ici l’annotation permet de décrire une interface de composant. Créez-en maintenant une implémentation de Service qui sera le sous-composant fractal Server :

@FractalComponentpublic class ServerA implements Service {  @Attribute(value=">>")  private String header ;   

  @Service  private Component ref;   

  @Attribute(argument="msg")  private String message ;   

  public void print() {    NameController nc=null;    try {      nc = (NameController)ref.getFcInterface("name-controller");    } catch (NoSuchInterfaceException e) {      e.printStackTrace();    }    System.out.println(nc.getFcName()+header+message);  }   

  @LifeCycle(on=LifeCycleType.START)  private void init() {    System.out.println("Starting Server A ...");  }}

Cette fois les annotations spécifient que le code correspond à un composant possédant 2 attributs (header et message) et qui utilise une référence à la membrane (ref). Créez maintenant le code du sous-composant Client

@FractalComponent@Provides(interfaces = @Interface(name = "r", signature = Runnable.class))public class Client implements Runnable {   

  @Requires(name = "default")  protected Service service;   

  @LifeCycle  public void init() {    System.out.println("STARTING client component");  }   

  public void run() {    System.out.println("Service says: ");    this.service.print();  }}

Nous avons ici décrit un autre composant Fractal qui fournit une interface nommée r de type Runnable et qui nécessite un service de type Service. Assemblons à présent ces composants en créant un fichier Fractal ADL nommé HelloWorld.fractal et situé à la racine de votre répertoire src.

<?xml version="1.0" encoding="ISO-8859-1" ?><!DOCTYPE definition PUBLIC "-//objectweb.org//DTD Fractal ADL 2.0//EN""classpath://org/objectweb/fractal/adl/xml/basic.dtd">   

<definition name="HelloWorld">        <interface name="r" role="server" signature="java.lang.Runnable"/>   

     <component name="client" definition="Client"/>        <component name="serverA" definition="ServerA('Hi!')"/>  

     <binding client="this.r" server="client.r"/>        <binding client="client.default" server="serverA.service"/></definition>

Ce fichier se lit comme suit : le composant HelloWorld expose une interface r de type Runnable. Il contient deux composants (dont les définitions sont générées dans d’autres fichiers fractal ADL générés par Spoon). L’interface exposée par le composant HelloWorld est connectée à l’interface r du composant client qui est lui-même connecté via son interface default à l’interface nommée service du composant ServerA. Il nous faut maintenant exécuter Spoon puis compiler le code généré afin de l’exécuter. Pour cela vous pouvez utiliser une tâche ant qui devrait ressembler à ceci :

 <taskdef classpathref="classpath" name="spoon"></taskdef> <spoon verbose="true" output="${gen.spooned}" classpathref= "classpath"mce_href="classpath"></spoon>spoonlet="lib/fraclet-annotation.jar"> <sourceset includes="**/*.java"></sourceset> <sourceset file="lib/spoon/AVal.jar"></sourceset> <sourceset file="lib/fraclet-annotation.jar"></sourceset> <javac srcdir="${gen.spooned}" destdir="${build}" source="1.5" classpathref="classpath" ></javac>

Il ne reste plus qu’à exécuter le code à l’aide de Fractal ADL qui masque le code de Bootstrap de Fractal :

<target depends="compile" name="execute"></target><java fork="yes" failonerror="yes" classpathref="classpath"></java><jvmarg line="${run.jvm.parameters}"></jvmarg><arg line="-fractal HelloWorld r"></arg>

Et voici la sortie obtenue :

STARTING client componentStarting Server A ...Service says:serverA>>'Hi!'

L’exercice intéressant à réaliser est de voir à quel point il est alors facile de créer une nouvelle implémentation ServerB de l’interface Service et de recomposer l’application en liant cette fois le client à ServerB au lieu de ServerA dans le fichier de description du composant HelloWorld. Cela illustre d’abord que la reconfiguration d’une application est rendue plus aisée ; mais ce qu’il est intéressant de savoir est que la liaison des composants peut être faite et modifiée programmatiquement et donc dynamiquement permettant ainsi de changer le mode d’implémentation de l’application au runtime ! J’espère avoir pu ici vous donner un aperçu simple de la programmation par composant avec Fractal. Pour plus d’informations, n’hésitez pas à visiter le site http://fractal.objectweb.org.