LOG4430 : Architecture logicielle et conception avancée

Présentation au sujet: "LOG4430 : Architecture logicielle et conception avancée"— Transcription de la présentation:

1 LOG4430 : Architecture logicielle et conception avancée
Composition et architectures par composants

2 Composition et architectures par composants
Mise en contexte Introduction aux composants logiciels Le modèle de composants Fractal Lectures à faire

3 1. Contexte Limitations des architecture à objets
Complexité du chargement dynamique Ad hoc Solution partielle des cadre de références et autres plugiciels

4 1. Introduction Contexte : ingénierie du système/intergiciel (middleware) Les entreprises et les organisations construisent maintenant des systèmes d'information globaux intégrant des applications jusqu'ici indépendantes, ainsi que des développements nouveaux. Ce processus d'intégration doit tenir compte des applications dites patrimoniales (en anglais : legacy), qui ont été developpées avant l'avènement des standards ouverts actuels, utilisent des outils « propriétaires », et nécessitent des environnements spécifiques. Une application patrimoniale ne peut être utilisée qu‘à travers une interface specifiée, et ne peut être modifiée. La plupart du temps, l'application doit être reprise telle quelle car le coût de sa réécriture serait prohibitif. Le principe des solutions actuelles est d'adopter une norme commune, non liée a un langage particulier, pour interconnecter différentes applications. La norme spécifie des interfaces et des protocoles d'échange pour la communication entre applications. Les protocoles sont realisees par une couche logicielle qui fonctionne comme un bus d'echanges entre applications: c’est l’ intergiciel (middleware) [

5 1. Introduction Passé (année 1990) : objet
mouvance « à la CORBA:Common Object Request Broker Architecture » CORBA en 5 points: Toutes les méthodes sont virtuelles ; il n'y a ni polymorphisme paramétrique, ni méthode protégée ou privée,… Chaque composant est décrit sous la forme d'une interface écrite en langage IDL Une correspondance a été spécifiée entre le langage IDL et différents langages de programmation Des précompilateurs dédiés permettent de générer automatiquement le squelette de l'interface IDL dans un langage donné (code pour appels distants et traitements de résultats: stub et skeleton) Applications et composants Corba mélangent typages statique et dynamique: les composants sont décrits statiquement par une interface mais les composants qui utilisent celui-ci doivent vérifier dynamiquement que l'interface est effectivement implantée.

6 1. Introduction Besoins Présent : plusieurs tendances configuration
déploiement empaquetage (packaging) assemblage dynamicité gestion des interactions et des dépendances Présent : plusieurs tendances composant, aspect, MDE, réflexivité

7 1. Introduction Composant vs objet plus haut niveau abstraction
meilleure encapsulation, protection, autonomie programmation + systématique + vérifiable communications plus explicites port, interface, connecteur connectables schéma de connexion (ADL) : « plan » applicatif séparation « métier » - technique meilleure converture du cycle de vie conception, implémentation, packaging, déploiement, exécution

8 1. Introduction Définition composant
1ère apparition terme [McIlroy 68] 30 ans + tard : Sun EJB, OMG CCM, MS .NET/COM+, … recensement [Szyperski 02] : 11 définitions +/- ≡ A component is a unit of composition with contractually specified interfaces and context dependencies only. A software component can be deployed independently and is subject to composition by third parties. [Szyperski 97]

9 1. Introduction Nombreux modèles de composant (20+)
construits au-dessus Java, C, C++ EJB, Java Beans, CCM, COM+, JMX, OSGi, SCA, CCA, SF, SOM Fractal, K-Component, Comet, Kilim, OpenCOM, FuseJ, Jiazzi, SOFA, ArticBeans, Draco, Wcomp, Rubus, PACC-Pin, OLAN, Newton, COSMOS, Java/A, HK2, Koala, PECOS, Knit, nesC, saveCCM, CAmkES Technologies utilisant les modèles de composants: Bonobo, Carbon, Plexus, Spring, Avalon Au niveau analyse/conception : UML2

10 1. Introduction Conséquence de la multiplicité des modèles
multiplicité du vocabulaire composant, bean, bundle interface/liaison, port/connecteur, facette, puits, source requis/fourni, client/serveur, export/import, service/référence conteneur, membrane, services techniques, contrôleur Framework (cadriciel), serveur d’applications grande variabilité dans les propriétés attachées aux notions exemples Fractal : composant, interface, liaison, client/serveur CCM : composant, facette, port, puits, source UML 2 : composant, fragment, port, interface OSGi : bundle, package importé/exporté, service/référence un même terme peut avoir des acceptations ≠ selon les modèles qualifier les notions (« connecteur au sens … ») pas toujours facile de définir les équivalences

11 1. Introduction 1ère grande catégorie de modèle de composants
Triptyque : composant, interface, liaison un composant fourni et/ou requiert une ou plusieurs interfaces une liaison est un chemin de communication entre une interface requise et une interface fournie composant liaison interface requise fournie

12 1. Introduction 2ème grande catégorie de modèle de composants
triptyque : composant, port, connecteur un composant fourni et/ou requiert une ou plusieurs ports un connecteur implémente un schéma de communication entre des composants (client/serveur, diffusion, etc.) un composant est relié à un connecteur via un ou plusieurs ports connecteur  liaison avec comportement on peut considérer connecteur = composant (de communication) composant, interface, liaison composant connecteur

13 1. Introduction Classification des modèles pour système/intergiciel
Application Middleware application : EJB, CCM, .NET/COM+, SCA, Spring middleware : Fractal, JMX, OpenCOM, OSGi middleware componentisé pour applications à base de composants JonasALaCarte : Fractal + EJB [Abdellatif 05] OSGi + EJB [Desertot 05]

14 1. Introduction Quelques « poncifs » à propos des composants
COTS (Commercial Off The Shelf) Les composants peuvent être réutilisés Réduction des coûts de fabrication et de maintenance mais quid de la contractualisation ? « Programming in the large » vs « programming in the small » (objet) vrai d’un certain point de vue mais nouveaux points à traiter (liés au non fonctionnel par ex.)

15 2. Le modèle Fractal FT R&D, INRIA open source http://fractal.ow2.org
Historique fin 2000 : premières réflexions autour de Fractal 06/2002 1ère version stable API implémentation de référence (Julia) 1ère version de l’ADL 01/2004 définition de l’ADL v2 (ADL extensible) implémentation disponible 03/2004

16 2. Le modèle Fractal ingénierie des systèmes et du middleware
suffisamment général pour être appliqué à tout autre domaine grain fin (wrt EJB ou CCM) proche d’un modèle de classe léger (surcoût faible par rapport aux objets) indépendant des langages de programmation vision homogène des couches (OS, middleware, services, applications) Fractal everywhere dans le but de faciliter et d’unifier conception, développement, déploiement, administration

17 2. Le modèle Fractal ouvert et adaptable
les services extra-fonctionnels peuvent être personnalisés il n’y a pas une seule “forme” de composants Fractal 2 usages possibles avec Fractal framework de composants pour construire des applications/systèmes on utilise la forme “standard” des composants Fractal framework de frameworks de composants on construit d’autres “formes” de composants avec introspection minimale et aggregation simple (à la COM) avec contrôleurs de liaison et de cycle de vie (à la OSGi) avec hiérarchie à 2 niveaux et liaison (à la SCA) avec des liaisons multicast (à la CCA) avec des contrôleurs d’attribut (à la MBean) avec des contrôleurs de persistance et de transaction (à la EJB) … on développe des applications avec ces autres “formes”

18 2. Le modèle Fractal Différent plateformes
3 en Java Julia implémentation de référence AOKell aspects + componentisation des membranes ProActive composants actifs pour les grilles 2 en C (Think, Cecilia), 1 en C++ (Plasma), 1 en SmallTalk (FracTalk), 1 pour .NET (FractNet) ≠ implémentations pour ≠ besoins

19 2. Le modèle Fractal Exemple de middleware/applications développées avec Fractal comanche : serveur Web Speedo : persistance données Sun JDO [Chassande 05] GoTM : moniteur transactionnel [Rouvoy 04] Joram Dream : serveur JMS Scalagent [Quéma 05] JonasALaCarte : serveur Java EE [Abdelatif 05] Petals : ESB JBI [ EBMWebsourcing / OW2 ] FraSCAti : plate-forme SCA [ INRIA / ANR SCOrWare ] FractalGUI : conception d’applications Fractal FractalExplorer : console d’administration applications Fractal serveur données répliquées + cohérence Li & Hudak [Loiret 03]

20 Définition d’un composant Fractal
une entité au moment de l’exécution Structure récursive Capacités réflexive There is a lot of component models, EJB, OSGi...and of course a lot of component definitions. In the Fractal world, a component is an runtime entity with recursive structure and reflexive capabilities. A component is composed of a content and a membrane and has access points named interfaces. 20

21 Définition d’un composant Fractal
Un composant a 2 dimensions métier contrôle les propriétés extra-fonctionnelles mise en œuvre par une membrane composée d’un ensemble de contrôleurs par ex. : sécurité, transaction, persistance, arrêt/démarrage, nommage contrôleur accessible par une interface dite de contrôle rôle d’un framework Fractal (Julia, AOKell, …) fournir un cadre pour développer des applications Fractal des contrôleurs et des membranes

22 Interfaces Interface fournie (ou serveur):
Points d’accès au services fournis par le composant. (convention: dessinées à gauche) Interface requise (ou client): Points d’accès pour recevoir des services par d’autres composants. (convention: dessinées à droite) Interface de contrôle: Points d’accès pour des fonctionnalités ne faisant pas partie du service fourni (ex: cycle de vie, propriétés récursives) 22

23 Membrane et contenu Membrane Contenu
Contient les interfaces (fonctionnelles et contrôle) Composé de contrôleurs qui implémentent des interfaces de contrôle. Chaque contrôleur a sa propre tâche. Permets l’introspection et la configuration du composant Contenu Composé d’un nombre fini de composants (sous composants) 23

24 Sous composants Un composant peut contenir des sous composants… (composant composite) Gère les sous composant à l’aide de l’interface ContentController (CC). A l’absence de cette interface: composant primitif – boîte noire 24

25 http://fractal. ow2. org/fractal-distribution/fractal-concepts-doc
25

26 En résumé

27 Composant partagés Un composant peut être ajouté à des composant différents (composant parent) Un composant partagé accède à la liste des parents à l’aide de l’interface de contôle SuperController (SC). 27

28 Composant partagés 28

29 Autres interfaces de contrôle
NameController (NC) LifeCycle (LC) Etats d’un composant: Démarré ou Arrêté AttributeControlles (AC) NC: Le nom du composant est géré par l’interface de contrôle NameController. AC: Contrôle les attributs d’un composant. Generalement pas representé graphiquement. 29

30 En résumé Interfaces de contrôle prédéfinies dans Fractal
Convention de nommage : suffixe -controller Pour les composants primitifs binding-controller gestion d'une liaison (créer/supprimer) lifecycle-controller démarrer/arrêter le composant name-controller nommer du composant super-controller le composite auquel  le composant + pour les composants composites content-controller gérer le contenu d'un composite (ajouter/retirer des sous-composants)

31 En résumé Interface : obligatoire vs facultative
combinaison avec métier/contrôle et client/serveur ok Interface : interne vs externe externe : en façade d'un composant ou d'un composite interne : pendant d'une itf externe pour un composite combinaison avec métier /contrôle ok combinaison avec client/serveur ok Interface : simple vs multiple (collection) cardinalité de la liaison référence ou collection de références combinaison avec métier seulement its internes

32 Liaisons Des sous composants dans un même composant peuvent être reliés par des liaisons (bindings) Binding: une liaison orienté de l’interface requise vers l’interface fournie. La liaison appartient au contenu du composant de l’interface requise Controller par l’interface de contrôle BindingController (BC) BC: Permet de construire ou detruire une liaison 32

33 Règles de liaison Une liaison est une connexion d’une interface requise vers une interface fournie Une liaison ne peut pas passer à travers d’une membrane Les composant relié par la liaison doivent être dans le même composant parent. 33

34 Liaisons Valide? 34

35 Liaisons Valide? Non! Pourquoi?
35

36 Liaisons Valide? 36

37 Liaisons Valide? Oui! Pourquoi?
37

38 Liaisons Valide? 38

39 Liaisons Valide? Non! Pourquoi?
39

40 Liaisons Valide? 40

41 Liaisons Valide? Non! Pourquoi?
Pourquoi essayer de faire quelque chose comme ca? Mais comment alors faire un lien entre un sous composants et l’interface que son parent offre? 41

42 Liaisons Visibilité: pour indiquer si l’interface est sur la face interne ou externe de la membrane En pratique les interfaces internes, ainsi que les connections entre interfaces internes et externes, sont créées automatiquement En pratique 42

43 Interface interne Interfaces internes
43

44 Connexions Connexions créées automatiquement
44

45 Liaisons Entre CC et interface requise
45

46 Liaisons Entre interface requise et fournie du même composant
46

47 En résumé 2 formes primitive composite
au sein d’un même espace d’adressage invocation méthode locale composite ≠ sémantiques d’invocation possible par ex. invocation distante normale export import

48 Définition d’interfaces
Interface: nom, visibilité, et type Nom: getFcInterface(in string interfaceName) Visibilité (concerne les composant composite): externe ou interne Type: Nom Rôle: fournie ou requise Cardinalité: combien d’interfaces de ce type le composant peut avoir Contingence: indique si la fonctionnalité de l’interface est garantie quand le composant est actif Signature (pour Julia, la signature est le nom de la classe java de l’Interface). signature :is the name of the language interface type corresponding to this component interface.. In Julia which is a Java implementation of Fractal, the signature is the name of a Java interface's class. En pratique l’interface fractal n’est pas une interface Java: Julia: Une interface Fractal est un objets Java qui implemente une inteface Java permettant d’acceder au nom, type etc… 48

49 Accès au interfaces Requise: BC
49

50 Accès au interfaces Externe: interface de contrôle Component (C)
50

51 Accès au interfaces Interne: CC
51

52 Créer un composant créer une instance à partir d’une définition de composant ≡ new en POO 2 solutions avec une fabrique (aka Bootstrap Component) à partir d’un gabarit (template)

53 Créer un composant Instanciation avec le Bootstrap Component
composant prédéfini par Fractal peut instancier n’importe quel composant informations nécessaires son type son implémentation une forme de membrane new

54 Créer un composant Instanciation à partir d’un gabarit
utiliser l’existant (template) 1 composant ou 1 assemblage de +sieurs composants pour en faire une « copie » Avantage moins de manipulation pour instancier de grands assemblages new

55 Développer avec Fractal
Développer des applications Fractal en Java 3 outils complémentaires Fraclet modèle de programmation à base d'annotations Fractal ADL langage de description d'architecture (ADL) basé XML Fractal API ensemble d’interfaces Java pour l'introspection la reconfiguration la création/modification dynamique de composants et d'assemblage de composants Fractal

56 Fraclet Modèle de programmation Java pour Fractal à base d’annotations
Java 5 ou Java 1.4 XDoclet annotations d'éléments de code (classe, méthode, attribut) apporte aux éléments une signification en lien avec les concepts Fractal phase de pré-compilation génération du code source associé aux annotations indépendant des plates-formes (Julia, AOKell)

57 Fraclet Principales annotations @Component @Requires
s’applique à une classe implémentant un composant 2 attributs optionnels name : le nom du composant provides : les services fournis par le composant @Requires s’applique à un attribut (field) : la référence du service requis (de type T) attribut de type T pour SINGLETON attribut de type Map<String,T> pour COLLECTION indique que l’attribut correspond à une interface cliente 3 attributs optionnels name : le nom de l'interface cardinality : Cardinality.SINGLETON (par défaut) ou COLLECTION contingency : Contingency.MANDATORY (par défaut) ou OPTIONAL

58 Java API - Type Tout type hérite de Type
Sa seule méthode permet de savoir si deux types sont compatibles public interface Type { boolean isFcSubTypeOf (Type type); } 58

59 Java API - InterfaceType
Décrit le type d’interface Fractal public interface InterfaceType extends org.objectweb.fractal.api.Type { String getFcItfName (); String getFcItfSignature (); boolean isFcClientItf (); //role: CLIENT (true) or SERVER (false) boolean isFcOptionalItf (); //contingency : OPTIONAL (true) or // MANDATORY (false) boolean isFcCollectionItf (); //cardinality : COLLECTION (true) or // SINGLETON (false) } 59

60 Java API - ComponentType
Un ensemble de InterfaceType public interface ComponentType extends org.objectweb.fractal.api.Type { InterfaceType[] getFcInterfaceTypes (); InterfaceType getFcInterfaceType (String name) throws NoSuchInterfaceException; } 1 method returns all interface types that are part of the component type. 2nd returns the type of a specific Fractal interface identified by its name. 60

61 Java API - TypeFactory Définie les méthodes qu’une Factory doit avoir
public interface TypeFactory { InterfaceType createFcItfType ( String name, String signature, boolean isClient, boolean isOptional, boolean isCollection) throws org.objectweb.fractal.api.factory.InstantiationException; ComponentType createFcType (InterfaceType[] interfaceTypes) throws } Type factories have also a type which defines the methods that a type factorie must provide. createFcItfType and a createFcType methods to create respectively interface and component types. 61

62 Java API - Interface Interface Java implémentée par tout interface Fractal public interface Interface { Component getFcItfOwner (); String getFcItfName (); Type getFcItfType (); boolean isFcInternalItf (); } Java interface which is implemented by all Fractal interfaces. In practice julia creates a java object for each Fractal interface that implement the Interface java interface and the java interface of the signature. The implementation of java interface of the signature is delegate to the java class associated to the component that holds the Fractal interface. 62

63 Java API – Interfaces de contrôle
Component AttributeController BindingController ContentController LifeCycleController NameController SuperController 63

64 Java API – Factory public interface GenericFactory { Component newFcInstance (Type type, Object controllerDesc, Object contentDesc) throws InstantiationException; } public interface Factory { Type getFcInstanceType (); Object getFcControllerDesc (); Object getFcContentDesc (); Component newFcInstance () throws InstantiationException; 64

65 Hello World! - Fraclet et Fractal ADL
To facilitate the Fractal programming, Fraclet and Fractal ADL tools will be used. Our application will just display a '->Helloworld !' message on the console. It is composed of : a server component that provides an interface 's' to print messages on the console. It can be parameterized via a "header" attribute to configure the header printed in front of each message. A client component provides an interface 'r' which displays the message '->Helloworld !'. To do this the client component uses the interface 's' of the component server to print some messages. Finally a client-server composite component which contains our client and server components. To display our message we will call the interface 'r' of the root component. "r" interface has a java.lang.Runnable as signature. It is not mandatory but it is usefull when we want to launch the application with the Fractal ADL launcher. 65

66 Hello World! – avec Fraclet et Fractal ADL
Créer les composants primitifs Créer des interfaces Java qui vont être associées avec les interfaces Fractal (Service.java) Créer une class Java qui va contenir la logique du composant (ClientImpl.java et ServerImpl.java) Insérer les annotations avec Fraclet Encapsuler les composant primitifs dans un composant composite (décrit avec Fractal ADL) (ClientServerImpl.fractal) Appeler Fractal ADL Factory pour instancier l’architecture 66

67 Hello World! – avec Fraclet et Fractal ADL
Créer un nouveau projet Java Dans un paquetage helloworld créer les trois classes suivants: Interface Service Classe ServerImpl Classe ClientImpl Ainsi que le fichier ClientServerImpl.fractal 67

68 Hello World! – avec Fraclet et Fractal ADL
L’interface Java - Service 68

69 Hello World! – avec Fraclet et Fractal ADL
L’implémentation de l’interface côté Serveur As you can see it is just pure Java. Now we would like to transform it to a Fractal component. To do so we need to add extra information. We can add these information with Fractal annotations. The annotations are parsed by a tool named Fraclet that will create automatically Fractal ADL definitions for our primitive components. Fractal ADL is an architecture description language. The architecture of our application is described by a collection of Fractal ADL files. These files are just xml files with a .fractal file extension and conform to Fractal ADL DTD. @Component indicates that we want to create a new primitive component definition which will have as Java content the annotated Java class. Fractal definitions have a name. By default the name given to the Fractal ADL definition of our component is the same that the class so here "helloworld.ServerImpl". provides = "s", signature = helloworld.Service.class) indicates that our component provides a Fractal interface with a name 's' and a Java signature helloworld.Service. @Attribute(value="->") indicates that our component has an attribute. The Fraclet tool generates automatically the attribute control interface for the annoted attributes. The implementation of the control interface is also generated. The default name of the Java signature of the attribute control interface is the name of the class + AttributeController, in our case helloworld.ServerImplAttributeController. 69

70 Hello World! – avec Fraclet et Fractal ADL
L’implémentation de l’interface côté Client The client component class has a required Fractal interface with a signature helloworld.Service and a name 's'. In Java, required interfaces are implemented as fields. When you annotate the field private Service service; Fraclet will process the annotation and inject some code to implement the BindingController interface and will provide methods (bindFc, unbindFc, lookupFc, listFc) allowing the association between the Fractal interface and the associated Java field. The Java type of the field must be a Java interface compatible with the signature of the provided interface that will be connected to. In our case, as we will use the interface 's' of the server component having a signature of type Service, our private private field service has the same Service type. 70

71 Hello World! – avec Fraclet et Fractal ADL
ClientServerImpl.fractal: Now we can assemble our client and server components in a root component Fraclet tool is used in order to create primitive components. The composite components description requires using Fractal ADL tool. A Fractal definition of a component can be seen as its description. Let's note that the the Fractal ADL factory which creates the instance of the components, try to find ADL definitions in the classpath. It is that why the full definition name is helloworld.ClientServerImpl. This name specifies that the ClientServerImpl can be found in the helloworld Java package. L1: This describes an empty component. L2: We indicate that our root component has a provided interface named 'r' with a signature java.lang.Runnable. You don't need to declare control, and internal interfaces. They will be created automatically. Let's note that by default the cardinality and contingency of an interface is "singleton" and "mandatory", respectively. Other values can be specified like this: <interface name="..." role="...." signature="..." cardinality="collection" contingency="optional"/> We can't specify the visibility of a Fractal interface with Fractal ADL, by default the visibility is external. The internal interfaces of the composite component are automatically created. You can't provide a Java content for the composite component in Fractal ADL. The root component has two subcomponents that will be named 'client' and 'server'. We don't have to describe these components as their fractal ADL definitions have been created by Fraclet from the annotations. We just have to make a link to the .fractal files that contain the definition of the components that we want to add. We now have to describe the bindings of the assembly. First the binding between the subcomponents. A binding needs client and server interfaces : <binding client="..." server="..."/> A component is referenced by its name, and a interface too. In our case we want to bind the client interface 's' of the component named client to the server interface 's' of the component named server <binding client="client.s" server="server.s"/> Now we want to bind the interface 'r' of the root component to the interface 'r' of the subcomponent named client. The root component can't be referenced by its name because it is the component we are defining , we can reference it by using the name this. <binding client="this.r" server="client.r"/> 71

72 Hello World! – avec Fraclet et Fractal ADL
Placer les fichiers suivants dans le dossier du projet: Build.xml Build.properties Cliquer droit sur le fichier build.xml > « Run as » > « Ant build … » (seconde option) 72

73 Hello World! – avec Fraclet et Fractal ADL
Dans l’onglet « Environnement » créer une nouvelle variable « FRACTAL_HOME » dont la valeur est le chemin vers le dossier fractal-libraries distribution Exécuter! 73

74 F4E Pour développer avec Fractal et Eclipse:
Télécharger le plug-in pour Eclipse F4E: 74

75 4. Lectures à faire Flâner parmi les «Transparents de cours » Lire et faire le TP « Fractal »