Design Pattern Implementation in Java and AspectJ

Transcription

1 Design Pattern Implementation in Java and AspectJ IFT6251 Jean-Francois Gélinas Automne 2005

2 Plan de présentation Problématique Introduction au paradigme aspect Survol AspectJ Patrons de conception Analyse de l implémentation aspect Related works Critique Problématiques aspect

3 Problématique (1/1) La programmation objet a permis de régler plusieurs problèmes de conception (encapsulation, etc). Toutefois, cette technique de développement atteint ses limites lors l expression de certaines relations entre les objets. Les patrons de conception proposés par la bande des 4 (GOF) offrent des solutions flexibles à certaines de ces problématiques. Leur implémentation est souvent problématique et dépendant du paradigme utilié. Duplication et propagation de code Implémentation difficile à réutiliser Etc.

4 Introduction au paradigme aspect (1/3) ECOOP 97 «It seems natural to explore the effect of AOP on the implementation of GOF pattern» Depuis 1997, la programmation orientée aspect (Aspect Oriented Programming - AOP) provoque l'engouement de la communauté scientifique s'intéressant au génie logiciel. Cette technique offre de nouvelles perspectives à un principe bien connu en génie logiciel : la séparation des préoccupations. Daniel Sabbath (IBM, VP of Software Group Strategy) : IBM sees AOP as technology is crucial to the companies software growth IBM is using AOP "right now" within departments such as WebSphere IBM is investing heavily in AOP (specifically, AspectJ, AJDT, HyperJ, CME) AOP shows "real value"

5 Introduction au paradigme aspect (2/3) Avantages (intuitifs!) de la séparation des préoccupations : Compréhension Maintenabilité Extensibilité Réutilisabilité Adaptabilité La séparation des préoccupations au sein d une application a un impact direct sur les attributs de qualité. Cette amélioration est réalisée à l aide d abstractions permettant de représenter de manière explicite une préoccupation traverse, i.e. aspects.

6 Introduction au paradigme aspect (3/3) Exemple de préoccupations transverses Synchronisation Validation des erreurs (error checking) Contraintes d interaction (design pattern, etc) Gestion de mémoire Persistance Sécurité Logging Monitoring Procédure de tests...

7 Survol AspectJ (1/17) Implémentation Aspect la plus utilisée et la plus connue Semblable à Java (extension du paradigme objet) Supporté par le projet Eclipse Extension intégré à Java Accepte tous les programmes java (.java en entrée) On obtient des fichiers.class compatible avec toutes les JVM en sortie Intégré avec de nombreux outils (AJDT, etc)

8 Survol AspectJ (2/17) Exemple Éditeur de Figures Une figure est constitué de plusieurs éléments de figure. Un élément de figure est soit un point ou une ligne. Les Figures sont tracées sur l appel de la méthode Display. Un point est composé de deux coordonnées X et Y. Une ligne est définie par deux points.

9 Survol AspectJ (3/17) Éditeur de Figures - Design Display Figure * FigureElement Les Composants sont - Cohésifs - Faiblement Couplés - Possèdent des interfaces définies (abstraction, encapsulation) Point getx() gety() setx(int) 2 Line getp1 setp1 setp1(point) Design Modulaire Adéquat! sety(int) setp2(point)

10 Survol AspectJ (4/17) Exemple d une préoccupation transverse: envoyer un message à ScreenManager si un élément de figure est déplacé Display Figure * FigureElement Point getx() gety() setx(int) sety(int) 2 Line getp1 setp1 setp1(point) setp2(point) DisplayTracker

11 Survol AspectJ (5/17) DisplayTracker class DisplayTracker { Préoccupation Display Figure Point getx() gety() 2 * FigureElement Line getp1 setp1 static void updatepoint(point p) { this.display(p);... static void updateline(line l) { this.display(l);... setx(int) setp1(point) sety(int) setp2(point) class Point { void setx(int x) { DisplayTracker.updatePoint(this); this.x = x; class Line { void setp1(point p1 { DisplayTracker.updateLine(this); this.p1 = p1;

12 Survol AspectJ (6/17) Exemple d une 2ième préoccupation transverse: Conserver une trace des opérations exécutées... Display Figure * FigureElement Tracer traceentry traceexit Point getx() gety() setx(int) sety(int) 2 Line getp1 setp1 setp1(point) setp2(point) Tracing

13 Survol AspectJ (7/17) Tracer class Tracer { Display Figure Point getx() gety() 2 * FigureElement Line getp1 setp1 static void traceentry(string str) { System.out.println(str); static void traceexit(string str) { System.out.println(str); setx(int) setp1(point) sety(int) setp2(point) class Point { void setx(int x) { Tracer.traceEntry( Entry Point.set ); _x = x; Tracer.traceExit( Exit Point.set ); class Line { void setp1(point p1 { Tracer.traceEntry( Entry Line.set ); _p1 = p1; Tracer.traceExit( Exit Line.set );

14 Survol AspectJ (8/17) Résolution Objet traditionnelle : Tracing? Display? Display Code dupliqué Tracer trace Figure * FigureElement Point getx() gety() 2 getp1 setp1 Line Tracing setx(int) setp1(point) sety(int) setp2(point) Display Tracker Code Épars

15 Survol AspectJ (9/17) class Line { private Point _p1, _p2; Point getp1() { return _p1; Point getp2() { return _p2; void setp1(point p1) { Tracer.traceEntry( entry setp1 ); _p1 = p1; Tracer.traceExit( exit setp1 ); void setp2(point p2) { Tracer.traceEntry( entry setp2 ); _p2 = p2; Tracer.traceExit( exit setp2 ); class Point { private int _x = 0, _y = 0; class Tracer { static void traceentry(string str) { System.out.println(str); static void traceexit(string str) { System.out.println(str); int getx() { return _x; int gety() { return _y; void setx(int x) { Tracer.traceEntry( entry setx ); _x = x; Tracer.traceExit( exit setx ) void sety(int y) { Tracer.traceEntry( exit sety ); Bienvenue dans le monde aspectj! _y = y; Tracer.traceExit( exit sety );

16 Survol AspectJ (10/17) Mécanismes du langage AspectJ Extension de Java + Modèle de joint point Pointcuts Introductions Advice

17 Survol AspectJ (11/17) Aspect : Unité modulaire représentant une préoccupation transverse. Peut être abstrait, hériter de classes et d aspect abstraits et implémenter des interfaces. Peut introduire de nouvelles méthodes / attributs à un composant (aspect/classe). AspectX AspectY classx AspectY AspectX x classy

18 Survol AspectJ (12/17) Modèle de join point (point de jointure) Endroits bien identifiés dans un l exécution d un programme (appel de méthodes, accès à des attributs, constructeur, etc) Composition des join points Rassembler un ensemble de prédicats d intérêt pointcuts: ensemble de join points Utilité des Join points Permet de préciser à quel(s) endroit(s) un advice viendra se greffer dans nos composants

19 Survol AspectJ (13/17) Quelques primitives de join points call(signature) Capture un appel de méthode ou un constructeur basé sur la Signature execution(signature) Capture l exécution de méthode ou un constructeur basé sur la Signature get(signature) Capture un get sur un attribut basé sur la Signature set(signature) Capture un set sur un attribut basé sur la Signature handles(typepattern) Capture une exception de type Throwable (TypePattern). instanceof(classname) within(classname) Etc, il y a plus de 30 primitives de point de jointure

20 Survol AspectJ (14/17) Advice: Partie de code qui se greffe à un pointcut et qui injecte un comportement à tous les joinpoints sélectionnés par le pointcut. exemple: before (args): pointcut { Body où before représente le type de l advice (prochaine acétate). Le passage de paramètres via le pointcut est possible

21 Survol AspectJ (15/17) Le code définit par l Advice s exécute : before, le code est injecté avant le joinpoint before (args): pointcut { Body Advice JP after, le code est injecté après le joinpoint after (args): pointcut { Body JP Advice around, le code est injecté around (à la place) du code définit au joinpoint ReturnType around (args): pointcut { Body Advice JP

22 Survol AspectJ (16/17) Joinpoints: call(* Line.*), call(* Point.*) Pointcut: collection de joinpoints : traced() Display Tracer pointcut traced(): call(* Line.*) call(* Point.*); Figure * FigureElement Point getx() gety() setx(int) sety(int) 2 Line getp1 setp1 setp1(point) setp2(point) On veut un point d intérêt sur TOUS les appels de méthodes des instances de Line et Point.

23 Survol AspectJ (17/17) class Line { private Point _p1, _p2; Point getp1() { return _p1; Point getp2() { return _p2; aspect Tracing { pointcut traced(): call(* Line.* call(* Point.*); aspect pointcut void setp1(point p1) { _p1 = p1; void setp2(point p2) { _p2 = p2; before(): traced() { println( Entering: + thisjopinpoint); after(): traced() { println( Exit: + thisjopinpoint); advice class Point { private int _x = 0, _y = 0; int getx() { return _x; int gety() { return _y; void setx(int x) { _x = x; void sety(int y) { _y = y; void println(string str) {<write to appropriate stream> méthode Un Aspect est défini dans une entité La préoccupation est localisée Pas de code dupliqué Amélioration de la cohésion des classes

24 Patrons de conception (1/10) Problématiques liées à l utilisation : Implémentation «tailored to the instance of use» «disappearing into the code» «design pattern is reusable, its implementation usually are not» Documentation «scattering and tangling with other code» Composition «difficult to reason about systems with multiple patterns involving the same classes, because the composition creates large clusters of mutually dependent classes»

25 Patrons de conception (2/10) Modélisation du pattern Observateur (OO).

26 Patrons de conception (3/10) Code relatif à une préoccupation

27 Patrons de conception (4/10) Code relatif à une préoccupation Toutes les instances du pattern observateur possèdent les mêmes mécanismes (Update, Register, Notify, etc)

28 Patrons de conception (5/10) Objectifs aspect : On vise à améliorer la cohésion des composantes affectées par le pattern. Les mécanismes abstraits (propres à toutes les instances du pattern) sont regroupés dans un aspect abstrait. Un aspect concret fournit l implémentation de l aspect abstrait via les mécanismes d héritage. La maintenance, la compréhension et la modularité des composantes sont grandement améliorées.

29 Patrons de conception (6/10) Aspect abstrait (librairie) 1.Rôles 2. Support de mapping entre les Sujets et les Observateurs 3. Logique de mise à jour

30 Patrons de conception (7/10) Aspect concret 4.Spécification des rôles 5.Points d intérêt 6.Implémentation du comportement souhaité (!)

31 Patrons de conception (8/10) Impact sur les composants La classe Point exprime un concept cohésif dénudé des mécanismes propres au pattern (facilite la réutilisation) Le pattern de conception est réutilisable et localisé

32 Patrons de conception (9/10) Propriétés de cette implémentation Localisée Représentation adéquate des rôles. Réutilisable Librairie de patrons. Transparence Couplage inexistant entre les composantes objets. (Un)pluggabilité (!) Conséquence des 3 autres propriétés.

33 Patrons de conception (10/10) Catégorisation des patrons : Rôles déclaré au sein de l aspect. (Composite, observer, mediator, CoR) Aspects utilisés comme fabrique d objets. (Singleton, prototype, memento, iterator, flyweight) Construction de langage. (Adapter, decorator, strategy, visitor, proxy) Héritage multiple (Abstract factory, template method, builder, bridge) Code épars modularisé (State, Interpreter) Aucun bénéfice (Façade)

34 Analyse de l implémentation aspect (1/6) Effectuée à partir de 3 niveaux de critères : 1. Améliorations générales : À partir d attributs de qualité : localité, réutilisabilité, inversions des dépendances, composabilité et (un)pluggabilité. 2. Améliorations spécifiques : Propres à l implémentation du paradigme. 3. Origine de la problématique : Rôles définis ou surimposés

35 Analyse de l implémentation aspect (2/6) Améliorations générales : 17 des 23 patrons sont localisés. 12 de ces 17 patrons sont implémentés sont forme de librairie réutilisable. 14 de ces 17 patrons permettent une composition de manière transparente.

36 Analyse de l implémentation aspect (3/6) Améliorations générales : Critères laissés aux bonnes intuitions des auteurs utilisation de métriques selon les normes ISO9126 (piste possible)

37 Analyse de l implémentation aspect (4/6) Améliorations spécifiques: Propres aux mécanismes aspects Mediator Élimination des dépendances cycliques.

38 Analyse de l implémentation aspect (5/6) Origine de la problématique : La propagation des patrons aux classes : Rôle défini «No functionality outside the pattern» Réalisé en spécialisant une classe abstraite Rôle Surimposé «Augmentation of the already existing class» Réalisé à l aide d interfaces (ou classes abstraites) définissant le comportement

39 Analyse de l implémentation aspect (6/6) Solutions aspects : Groupe 1- Rôle défini Ex: Facade, Factories, etc Aucun bénéfice avec l AOP Groupe 2- Rôle Surimposé Ex: Observer, Mediator, CoR, etc Bénéfices pour chacune des propriétés Groupe 3- Rôle hybride (Surimposé et défini) Composite, Visitor, ect Bénéfices cas par cas.

40 Related work (1/1) Pistes d intérêt : Investigation de l impact du paradigme de programmation sur les solutions. Développement d outils de génération, de libraires, d outils de support. Classification des patrons afin de réduire et comprendre les interactions. Problématiques liés à la composition de patrons. Amélioration de la représentation des patrons.

41 Critique (1/1) Analyse intéressante mais subjective laissée aux bonnes intuitions des auteurs. Solution : Utilisation de métriques pour quantifier les bénéfices/coûts. Solution : Définir un framework à partir des attributs de qualité définis par ISO9126. Utilisation d exemples simplistes. Solution : Développement ou évaluation sur un projet d envergure afin de valider les assomptions des auteurs. Simplification de certaines problématiques Ex : Observer -> tous de même type.

42 Problématiques aspects (1/1) «Overhead» de conception Solution : Développement d outils (plus puissant que AJDT) pour faciliter le débogage d applications aspects. Gestion des points d intérêt Solution : Utilisation de principes d IA ou de «snapshot» projet. Analyse d impact sur des projets d envergure Ex : Intégration des patrons aspect à un projet existant (impact sur les classes)

43 Merci! Questions?

44 Technologies AOP disponibles AspectWerkz AspectJ DemeterJ/DJ eterjava/ Multi-dimensional separation of Concerns/HyperJ J/HyperJ.htm AOP projects page rojects