La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Séparation des préoccupations.. Module Modèles, Objets et Composants.

Présentations similaires


Présentation au sujet: "Séparation des préoccupations.. Module Modèles, Objets et Composants."— Transcription de la présentation:

1

2 Séparation des préoccupations.. Module Modèles, Objets et Composants

3 Séparation des préoccupations Organisation du cours 2 parties Principes généraux Étude daspectJ

4 Séparation des préoccupations Première partie Vous avez dit préoccupation ? Pourquoi et comment séparer les préoccupations

5 Séparation des préoccupations Quest-ce quune préoccupation ? But particulier, concept, domaine d'intérêt Un logiciel contient : – Des préoccupations métier Effectuer des paiements : débiter un montant d'un compte défini Effectuer des réservations – Des préoccupations système (ou techniques) Traçage, Identification / authentification, Sécurité (confidentialité), Performances, etc

6 Séparation des préoccupations Des applications de plus en plus complexes Volume grandissant (Data, Code) Évolutivité grandissante (reorganisations, compétition, …) Hétérogénéité grandissante (langages, concepts, …) Des objets « pluridisciplinaires » Les objets nont pas à charge que leur travail Les objets « collaborent » pour atteindre un but plus général Souvent ces collaborations peuvent être décrites élégamment en utilisant la POO et en se référant à des design patterns Pourquoi la séparation des préoccupations ?

7 Séparation des préoccupations Un exemple : Tomcat En rouge, les lignes de code concernées par le parsing Bonne modularisation : code concentré en un seul endroit XML parsing Copyright © aspectj.org

8 Séparation des préoccupations URL pattern matching En rouge, les lignes de code pour gérer la correspondance dURLs Bonne modularisation : code concentré en 2 endroits Un exemple : Tomcat Copyright © aspectj.org

9 Séparation des préoccupations Trace Un exemple : Tomcat En rouge, les lignes de code pour tracer lexécution Mauvaise modularisation : le code est mélangé, éparpillé et redondant Copyright © aspectj.org

10 Séparation des préoccupations Pari perdu "Because of the wonderful unifying properties of the object paradigm, the transition from procedural technology to object technology will bring huge conceptual simplification to the software engineering field. Since everything will be considered as an object, we shall observe a dramatic reduction in the number of necessary concepts." All together, circa 1980 Le paradigme Objet promettait la simplification... Application difficile à concevoir, à coder Code difficile à comprendre une structure non explicitée (qui nest pas un objet) la base structurelle est altérée Code difficile à maintenir, à faire évoluer trouver tous les bouts de code impliqués gérer la consistance dun changement Copyrigth © Jean Bezivin, UML03

11 Séparation des préoccupations Évolution des paradigmes pour gérer la réutilisation Technologie procedurale Technologie composant Technologie objet Objects, Classes, Smalltalk, C++,... Procedures, Pascal, C,... Composants, Containers Interfaces in et out, EJB, CCM, … Raffinement Composition par assemblage Séparation des préoccupations Encapsulation et Spécialisation Travail collaboratif Prolifération des concepts Émergence de nouvelles formes de programmation

12 Séparation des préoccupations.. Aspect Oriented Programming (AOP) Projet fondateur du Xerox Alto research Center 2 noms : Cristina Videira Lopes, Gregor Kiczales. Un site :

13 Séparation des préoccupations Objectif Séparer les concepts et minimiser les dépendances entre eux pour éviter ou minimiser les entrelacements de code (couplage faible des classes entre elles) avoir un code plus petit, plus naturel avec moins dimbrications faciliter les modifications, le « debug » par une vision séparée de chaque concept répercuter au minimum la modification dun concept sur les autres réutiliser, enlever, remettre des concepts plus facilement

14 Séparation des préoccupations Vocabulaire cross-cutting? Certaines préoccupations des logiciels affectent ou nécessitent la collaboration dun groupe dobjets. Elles cross-cut (coupent orthogonalement) larchitecture de base des objets aspect? Un aspect est une préoccupation qui cross-cut (coupe) lapplication weaving ? Générer un code comportant à la fois le code de base et les aspects (on parle aussi de « tissage »)

15 Séparation des préoccupations public class Shape implements ShapeI { protected AdjustableLocation loc; protected AdjustableDimension dim; public Shape() { loc = new AdjustableLocation(0, 0); dim = new AdjustableDimension(0, 0); } double get_x() throws RemoteException { return loc.x(); } void set_x(int x) throws RemoteException { loc.set_x(); } double get_y() throws RemoteException { return loc.y(); } void set_y(int y) throws RemoteException { loc.set_y(); } double get_width() throws RemoteException { return dim.width(); } void set_width(int w) throws RemoteException { dim.set_w(); } double get_height() throws RemoteException { return dim.height(); } void set_height(int h) throws RemoteException { dim.set_h(); } void adjustLocation() throws RemoteException { loc.adjust(); } void adjustDimensions() throws RemoteException { dim.adjust(); } interface ShapeI extends Remote { double get_x() throws RemoteException ; void set_x(int x) throws RemoteException ; double get_y() throws RemoteException ; void set_y(int y) throws RemoteException ; double get_width() throws RemoteException ; void set_width(int w) throws RemoteException ; double get_height() throws RemoteException ; void set_height(int h) throws RemoteException ; void adjustLocation() throws RemoteException ; void adjustDimensions() throws RemoteException ; } class AdjustableLocation { protected double x_, y_; public AdjustableLocation(double x, double y) { x_ = x; y_ = y; } synchronized double get_x() { return x_; } synchronized void set_x(int x) {x_ = x;} synchronized double get_y() { return y_; } synchronized void set_y(int y) {y_ = y;} synchronized void adjust() { x_ = longCalculation1(); y_ = longCalculation2(); } class AdjustableDimension { protected double width_=0.0, height_=0.0; public AdjustableDimension(double h, double w) { height_ = h; width_ = w; } synchronized double get_width() { return width_; } synchronized void set_w(int w) {width_ = w;} synchronized double get_height() { return height_; } synchronized void set_h(int h) {height_ = h;} synchronized void adjust() { width_ = longCalculation3(); height_ = longCalculation4(); } Un exemple de code Java

16 Séparation des préoccupations interface ShapeI extends Remote { double get_x() throws RemoteException ; void set_x(int x) throws RemoteException ; double get_y() throws RemoteException ; void set_y(int y) throws RemoteException ; double get_width() throws RemoteException ; void set_width(int w) throws RemoteException ; double get_height() throws RemoteException ; void set_height(int h) throws RemoteException ; void adjustLocation() throws RemoteException ; void adjustDimensions() throws RemoteException ; } Un exemple de code Java

17 Séparation des préoccupations public class Shape implements ShapeI { protected AdjustableLocation loc; protected AdjustableDimension dim; public Shape() { loc = new AdjustableLocation(0, 0); dim = new AdjustableDimension(0, 0); } double get_x() throws RemoteException { return loc.x(); } void set_x(int x) throws RemoteException { loc.set_x(); } double get_y() throws RemoteException { return loc.y(); } void set_y(int y) throws RemoteException { loc.set_y(); } double get_width() throws RemoteException { return dim.width();} void set_width(int w) throws RemoteException { dim.set_w(); } double get_height() throws RemoteException{return dim.height();} void set_height(int h) throws RemoteException {dim.set_h(); } void adjustLocation() throws RemoteException { loc.adjust();} void adjustDimensions() throws RemoteException { dim.adjust();} } Un exemple de code Java

18 Séparation des préoccupations class AdjustableLocation { protected double x_, y_; public AdjustableLocation(double x, double y) { x_ = x; y_ = y; } synchronized double get_x() { return x_; } synchronized void set_x(int x) {x_ = x;} synchronized double get_y() { return y_; } synchronized void set_y(int y) {y_ = y;} synchronized void adjust() { x_ = longCalculation1(); y_ = longCalculation2(); } Un exemple de code Java

19 Séparation des préoccupations class AdjustableDimension { protected double width_=0.0, height_=0.0; public AdjustableDimension(double h, double w) { height_ = h; width_ = w; } synchronized double get_width() { return width_; } synchronized void set_w(int w) {width_ = w;} synchronized double get_height() { return height_; } synchronized void set_h(int h) {height_ = h;} synchronized void adjust() { width_ = longCalculation3(); height_ = longCalculation4(); } Un exemple de code Java

20 Séparation des préoccupations Où sont les aspects ? Synchronisation de Threads et Appels de méthodes à distance 2 notions orthogonales à la définition des classes

21 Séparation des préoccupations public class Shape implements ShapeI { protected AdjustableLocation loc; protected AdjustableDimension dim; public Shape() { loc = new AdjustableLocation(0, 0); dim = new AdjustableDimension(0, 0); } double get_x() throws RemoteException { return loc.x(); } void set_x(int x) throws RemoteException { loc.set_x(); } double get_y() throws RemoteException { return loc.y(); } void set_y(int y) throws RemoteException { loc.set_y(); } double get_width() throws RemoteException { return dim.width(); } void set_width(int w) throws RemoteException { dim.set_w(); } double get_height() throws RemoteException { return dim.height(); } void set_height(int h) throws RemoteException { dim.set_h(); } void adjustLocation() throws RemoteException { loc.adjust(); } void adjustDimensions() throws RemoteException { dim.adjust(); } interface ShapeI extends Remote { double get_x() throws RemoteException ; void set_x(int x) throws RemoteException ; double get_y() throws RemoteException ; void set_y(int y) throws RemoteException ; double get_width() throws RemoteException ; void set_width(int w) throws RemoteException ; double get_height() throws RemoteException ; void set_height(int h) throws RemoteException ; void adjustLocation() throws RemoteException ; void adjustDimensions() throws RemoteException ; } class AdjustableLocation { protected double x_, y_; public AdjustableLocation(double x, double y) { x_ = x; y_ = y; } synchronized double get_x() { return x_; } synchronized void set_x(int x) {x_ = x;} synchronized double get_y() { return y_; } synchronized void set_y(int y) {y_ = y;} synchronized void adjust() { x_ = longCalculation1(); y_ = longCalculation2(); } class AdjustableDimension { protected double width_=0.0, height_=0.0; public AdjustableDimension(double h, double w) { height_ = h; width_ = w; } synchronized double get_width() { return width_; } synchronized void set_w(int w) {width_ = w;} synchronized double get_height() { return height_; } synchronized void set_h(int h) {height_ = h;} synchronized void adjust() { width_ = longCalculation3(); height_ = longCalculation4(); } thread synchronization remote interaction

22 Séparation des préoccupations OOP vs AOP Programme orienté objet Structure et fonctions Appels distants Synchronization Programme avec AOP Classes de lapplication Aspect 1 Aspect 2

23 Séparation des préoccupations Exemples classiques daspects Synchronisation des méthodes entre classes Appels à distance (Java RMI) Persistance Transactions Authentification Qualités de Services (QoS) Performances (Load-balancing, caching, …) Réplication Migration …

24 Séparation des préoccupations Concepts de base Point de jonction (join point) : Les différents types de points de contrôle sur le programme de base (invocation de constructeur, initialisation, appel/réception de méthode, accès à un attribut, …) Coupe (pointcut) : Un ensemble dinstances de points de jonction où on décide de tisser un aspect pointcut trace(): execution(* *.*(..)) « Advice » : Le code à exécuter associé à une coupe Ladvice doit indiquer quand exécuter ce code (avant, après, ou à la place de lexécution des points de jonction contrôlés) after() returning: trace() { System.out.println(...) }

25 Séparation des préoccupations Des outils supportant lAOP... Des approches à la compilation/au chargement/à lexécution Des approches par transformation de code/de linterprète Des approches orientées langage/framework/service AspectJ, JMangler, AspectS, JAC, Noah, Composition Filters, JBoss AOP,...

26 Séparation des préoccupations Approches par transformation de programme Principe du tissage (weaving) Description des classes de lapplication + les aspects à utiliser weaver Code emmêlé tangled code

27 Séparation des préoccupations Exemple de code généré public aspect TraceAspect { private Display display; pointcut trace() : execution(* *.*(..)); after() : trace() { display.print(thisJoinPoint.getSignature()) } Public class A { public void m1() { // code } public void m2() { // code } Public class A { private Display display; public void m1() { // code display.print(this.getClass().getMethod(« m1 », null)); } public void m2() { // code display.print(this.getClass().getMethod(« m2 », null)); } }

28 Séparation des préoccupations Approches par transformation de linterprète Le niveau de base décrit les fonctionnalités de lapplication Le niveau méta décrit la manière dinterpréter le niveau de base Les points de jonctions sont les points où les méta objets exercent un contrôle sur un objet du niveau de base Modification du mécanisme denvoi de messages Réflexion : la capacité dune entité à sauto-représenter et plus généralement à se manipuler elle-même, de la même manière quelle représente et manipule son domaine dapplication premier [Brian Smith] Méta objets Objets de lapplication

29 Séparation des préoccupations Exemple dapproche par transformation dinterprète : Composition Filters (CF) Traite les « aspects » en ajoutant des filtres aux messages associés à un objet ou plusieurs dobjets Filtres en entrée et en sortie qui affectent les messages reçus et envoyés Projet TRESE (Twente Research and Education on Software Engineering) Chair Software Engineering Department of Computer Science University of Twente in The Netherlands. Un nom : Aksit Un site : cronym=intro_aop_cf

30 Séparation des préoccupations Représentation du modèle CF

31 Séparation des préoccupations Exemples de filtres définis Filtre Dispatch : message envoyé à sa cible (exécuté si la cible est inner) si accepté Filtre Wait : pour la synchronisation et les appels concurrents (message mis en attente tant quil n est pas accepté par le filtre) Filtre Meta : pour abstraire les interactions entre objets Filtre Error : pour restreindre laccès à un objet (visibilité dinterface) Filtre Substitution : pour modifier le message (cible, sélecteur de fonction) Filtre Send : pour initier une délégation filterinterface DisplayFilter begin externals display : Display; internals logOn : boolean; methods loggingOn(); logginOff(); print(Message); conditions LoggingEnabled; inputfilters trace : Meta = { LoggingEnabled=>[*]display.print }; onoff : Dispatch = { loggingOn, loggingOff }; end filterinterface DisplayFilter;

32 Séparation des préoccupations Principe de « superimposition » Composition par coopération des méta objets (les filtres)

33 Séparation des préoccupations public class TraceWrapper extends Wrapper { private Display display; public void trace(Interaction i) { proceed(i); display.print(i.getMethod()); } } Exemple dapproche par transformation dinterprète : JAC Projet Jacquard un nom : Pawlak un site : Objet Wrapper interception proceed Niveau « méta » Niveau de base Les méthodes du wrapper encapsulent les méthodes métiers (advices) Un wrapper est associé à une ou plusieurs méthodes indépendamment des classes Les wrappers sont liés/déliés aux objets à lexécution

34 Séparation des préoccupations Composition des wrappers associés à la même coupe Composition par coopération des méta objets (les wrappers) Propriété jac.comp.wrappingOrder du fichier de configuration jac.prop spécifie lordre denchaînement: règles dincompatibilité règles de dépendance …

35 Séparation des préoccupations Exemple dapproche par transformation dinterprète : Noah Une règle r1 par message m dun objet o au plus Si une nouvelle règle r2 associé au message m est appliquée à o alors on fusionne r1 et r2 pour nobtenir quune seule règle (la fusion préserve la commutativité) Projet Rainbow 2 noms : Dery-Pinna, Blay-fornarino un site : Objet Règle dinteraction interception proceed Niveau « méta » Niveau de base Interaction trace(Object obj, Display display) { obj.* -> obj._call() // display.print(_call) }

36 Séparation des préoccupations AOP et composants Un conteneur pour des objets métiers fournit des services techniques (persistance, sécurité, transactions,...) Les composants doivent être configurés pour bénéficier de certains services techniques Ces services sont « hardcodés » dans le code source du conteneur et se passent successivement la main par des fonctions non standardisées (ordre pré-établi) => e n pratique, les préoccupations sont toujours entrelacées (pour le fournisseur de conteneurs mais pas pour lutilisateur) Lorsque lon atteint les limites du conteneur (ces services sont en nombre prédéfini), les fonctionnalités supplémentaires doivent être introduites à la main.

37 Séparation des préoccupations AOP et points de vue Inversion des dépendances = la meilleure manière d'éviter la dispersion des préoccupations Ce n'est plus le programme qui utilise le service mais le service qui utilise le programme Un aspect dit quune classe peut lavoir et non le contraire Un aspect peut concerner plusieurs classes de façons différentes

38 Séparation des préoccupations AOP, méta programmation et réflexivité Dimportantes similarités : Le contrôle fourni par la méta programmation et la réflexivité est plutôt de bas niveau, très puissant et dangereux réservées à des programmeurs avancés Les outils dAOP offrent un plus haut niveau dabstraction et des gardes-fous (points dentrée limités) utilisés par de « simples » programmeurs support de programmation pour prendre en compte le crosscutting

39 Séparation des préoccupations Subject-oriented programming (SOP) Projet Software by Composition group. Software Development Technology department. IBM Thomas J. Watson Research Center, Hawthorne, New York Un nom : Harold Ossher Un site :

40 Séparation des préoccupations Une nouvelle façon de programmer objet Quest ce que la SOP ? SOP basée sur les différents rôles que peut jouer un objet Capture différentes vues dune seule classe (extension à des ensemble de classes) Comment programmer par « sujets » ? En déterminant comment diviser un système en sujets et en écrivant les règles de composition nécessaires Quand utiliser la SOP ? Développement de gros systèmes Intégration et interopérabilité des applications Extensions non planifiées dapplication Applications développées par plusieurs équipes Intégration non planifiée dapplications développées séparément

41 Séparation des préoccupations Scénario de partage de code 2 équipes de développement : L'équipe comptable (paiement) L'équipe des ressources humaines (gestion du personnel) Les 2 équipes développent en parallèle : Une classe Employé permet de gérer les informations sur un employé Une classe liste d'employés permet de gérer les employés Puis une mise en commun du code par utilisation de sujets et de règles de composition

42 Séparation des préoccupations Équipe 1 (paiement) : Classe Employé class employee { private: int employee_id; char employee_name[64]; int position; int salary; char state[3]; char city[64]; public: virtual void print(); virtual int get_employee_id(); virtual void set_employee_id(int);... };

43 Séparation des préoccupations Équipe 2 (personnel) : Classe Employé class employee { private: int employee_id; char empname[64]; char line1[64]; char line2[64]; char state[3]; char city[64]; char zipcode[9]; public: virtual void output(); virtual void generate_report(); // uses output virtual int get_employee_id(); virtual void set_employee_id(int);... };

44 Séparation des préoccupations Équipe 1 (paiement) : Classe Liste d'employés class employee_list { private: employee_list* head; employee_list* next; employee* employee_on_list; public: virtual void print(); virtual employee_list* insert(employee*); virtual employee_list* get_head();... };

45 Séparation des préoccupations Équipe 2 (personnel) : Classe Liste d'employés class employee_list { private: employee_list* head; employee_list* next; employee* employee_on_list; employee_list* prior; public: virtual void print(); virtual employee_list* insert(employee*); virtual employee_list* get_head(); virtual void remove();... };

46 Séparation des préoccupations Mise en commun Définitions de sujets pour chaque équipe L'équipe 1 définit le sujet paiement L'équipe 2 le sujet personnel Et utilisation de règles de composition composition spécifiée dans un fichier de règles (.rul) nouveau sujet créé par composition

47 Séparation des préoccupations Définition de la spécification dun sujet (label) Abstraction du programme : Opérations Signatures des méthodes Classes Les variables dinstances Mapping Classe - Opération Association comportement et classes dimplémentations Une opération implique une partie réalisation (points dentrée dans les implémentations des méthodes)

48 Séparation des préoccupations Définition de la spec du sujet Paiement Subject: Paiement Operations: print(), getXXX(), setXXX(), insert (...), …; Classes: employee with Instance Variables: employee_id, employee_name,...; employee_list with Instance Variables: head, next,...; Mapping: Class Employee, Operation Print() implemented by: &Employee::Print(), …;

49 Séparation des préoccupations Types de règles de composition Règles de correspondance Mise en correspondance sans spécifier comment combiner Règles implicites : MatchByName et DontMatch Règles explicites : Equate et Correspond Equate(A, B); Correspond(A, B, B); Règles de combinaison Join (jointure) Replace (remplacement) Règles mixtes de correspondance et de combinaison ByNameMerge(A, B); MatchByName(A); Join(A); Equate(A, B); NoncorrespondingMerge(A, B); DontMatch(A); Join(A); Equate(A, B); ByNameOverride(A, B); MatchByName(A); Replace(A); Equate(A, B);

50 Séparation des préoccupations Règles de composition pour lexemple ByNameMerge(appli, ); Fusion implicite des attributs/opérations de même nom (id, ville, accesseurs, …) Equate(variable appli.employee.employee_name, ); Force la fusion de 2 attributs/opérations de noms différents (nom de lemployé) Correspond(operation appli.print,, ); Force la fusion de 2 opérations de noms différents ( Equate) Override(realizationset appli.employee_list.insert, ); Quand les implémentations sont différentes : choisi limplémentation la plus appropriée ([paiement]insert est + complète)

51 Séparation des préoccupations Conclusion

52 Séparation des préoccupations SOP vs AOP Composition les sujets se composent pour donner un nouveau sujet les aspects ne se composent quà travers une application Utilisation les sujets sont des points de vue sur lapplication pour séparer différentes préoccupations « métier » les aspects sont orthogonaux à lapplication pour séparer différentes préoccupations techniques

53 Séparation des préoccupations Défis à relever Une gestion uniforme des préoccupations Une gestion de la composition des préoccupations

54 Séparation des préoccupations Vers une séparation des préoccupations à la conception Objects, Classes, Smalltalk, C++,... Procedures, Pascal, C, Technologie modèle MDA Transformation de modèles Raffinement Composition par assemblage Encapsulation et spécialisation Technologie procedurale Technologie composant Technologie objet Composants, Interfaces in et out, containers, EJB, CCM … Guerre des intergiciels


Télécharger ppt "Séparation des préoccupations.. Module Modèles, Objets et Composants."

Présentations similaires


Annonces Google