Programmation Orientée Aspect en Java Avec Aspectj: Selim Kebir

Programmation oriente aspect en Java avec AspectJ
Par Selim KEBIR
Date de publication : 2 fvrier 2010
Cet article est consacr la programmation oriente aspect. Il prsente d'abord, d'une manire indpendante de l'implmentation, les principaux concepts de l'AOP puis, illustre ces concepts avec des mises en uvre pratiques en langage AspectJ travers un exemple d'application.
Programmation oriente aspect en Java avec AspectJ par Selim KEBIR
I - Introduction..............................................................................................................................................................3 I-A - Proccupations transversales........................................................................................................................ 4 I-A-1 - Enchevtrement du code (code tangling)............................................................................................. 4 I-A-2 - parpillement du code (code scattering).............................................................................................. 5 I-B - Mthodologie de l'AOP.................................................................................................................................. 5 II - Concepts................................................................................................................................................................ 6 II-A - Aspect............................................................................................................................................................6 II-B - Point de jonction (joinpoint).......................................................................................................................... 6 II-C - Coupe (pointcut)........................................................................................................................................... 7 II-D - Code advice (advice code)...........................................................................................................................7 II-E - Mcanisme d'introduction..............................................................................................................................8 II-F - Tissage (weaving)......................................................................................................................................... 8 III - AspectJ..................................................................................................................................................................8 III-A - Historique et origine..................................................................................................................................... 8 III-B - Tlchargement et installation de l'outil.......................................................................................................9 III-C - Prsentation gnrale.................................................................................................................................. 9 III-D - Point de jonction........................................................................................................................................ 10 III-E - Coupe......................................................................................................................................................... 11 III-F - Advice......................................................................................................................................................... 12 III-G - Dclaration inter-type.................................................................................................................................13 III-H - Aspect........................................................................................................................................................ 13 IV - Exemple d'application......................................................................................................................................... 14 IV-A - Introduction................................................................................................................................................ 14 IV-B - Le systme d'arbre d'expression...............................................................................................................14 IV-C - La proccupation "cache"..........................................................................................................................16 IV-D - Excution sans cache............................................................................................................................... 19 IV-E - Excution avec cache................................................................................................................................20 V - Conclusion........................................................................................................................................................... 20 VI - Tlchargement des sources............................................................................................................................. 21 VII - Liens connexes..................................................................................................................................................21 VIII - Remerciements................................................................................................................................................. 21 IX - Commentaires des lecteurs................................................................................................................................21
-2Copyright 2009 Developpez LLC. Tous droits rservs Developpez LLC. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts. Cette page est dpose la SACD.
http://skebir.developpez.com/tutoriels/java/aspectj/
I - Introduction
Depuis une trentaine d'annes, l'approche oriente objet a procur des bnfices indnombrables dans la communaut gnie logicielle. En effet, elle permet de modulariser de larges systmes d'une manire intuitive car elle offre un modle de programmation riche trs proche du monde rel. Aujourd'hui, l'orient objet bnficie d'un excellent background notamment grce la popularisation d'UML. En plus, une multitude de langages de programmation (Java, C++, Smalltalk, ...) ont adopt ce paradigme de manire native. Cependant, l'approche oriente objet montre ses limites et choue face la modularisation des proccupations transversales au systme. Parmi les proccupations transversales plus courantes, on trouve la scurit, la gestion transactionnelle de la persistance, la synchronisation, le logging (Figure). Ces proccupations ont la particularit d'un ct, d'tre disperses travers plusieurs modules, et d'un autre ct, d'tre enchevtres avec les modules mtiers du systme. Ces deux phnomnes dgradent considrablement le maintien, la comprhension et l'volutivit du code.
Proccupations transversales C'est l que la programmation oriente aspect intervient en apportant des mcanismes la fois simples apprhender et puissants qui permettent de capturer des proccupations transversales. En effet, l'oriente aspect procure une solution lgante aux problmes d'enchevtrement et d'parpillement du code. Aujourd'hui, cette technique d'ingnierie logicielle s'affirme comme tant la prochaine tape pour le dcoupage des systmes en offrant une nouvelle dimension pour la modularisation notamment avec la notion d'aspect. En effet, paralllement aux classes qui sont un support idal pour modulariser les proccupations mtiers du systme, les aspects sont un support pour capturer les proccupations transversales. Dans une dmarche oriente aspect, les proccupations transversales peuvent voluer indpendamment des proccupations mtier et vice-versa (Figure). Et afin, que l'application finale prennent en compte toutes les proccupations, le systme passe par une tape dite de tissage d'aspects. Durant cette tape, les proccupations transversales encapsules dans les aspects vont tre tisses ou intgres dans les proccupations mtiers.
Sparation des proccupations transversales et mtiers Actuellement, une panoplie de langages et de plateformes orientes aspects existe (AspectJ, AspectWerkz, AspectC++, ...). Dans cet article, nous allons nous intresser au langage AspectJ qui est notre connaissance
l'exprimentation la plus aboutie de langages orients aspects. Ce n'est pas un langage part entire mais une extension du langage Java qui permet ce dernier de supporter la programmation oriente aspect. Dans cet article, nous allons tout d'abord nous intresser dans la section aux concepts de la programmation oriente aspect savoir les points de jonction, les coupes et les codes advices. La prsentation de ses concepts sera indpendante de toute implmentation afin de faciliter leur apprhension. Puis, nous nous intresserons dans la section au langage AspectJ en prsentant l'implmentation des principaux concepts de l'AOP travers ce langage. Et enfin, nous terminerons dans la section par un exemple pratique d'une application oriente aspect. Mais avant, nous allons voir les problmes engendrs par la non modularisation des proccupations transversales ainsi que la mthodologie gnrale d'une dmarche oriente aspect.
I-A - Proccupations transversales

Les proccupations transversales (en anglais crosscutting concerns) sont les fonctionnalits dites non mtiers. Un dveloppeur est souvent confront ce genre de fonctionnalits lorsqu'il dveloppe une application de grande envergure. Dans ce cas, mme si on applique une bonne modularisation verticale des proccupations mtiers, on aura toujours un problme de proccupations horizontales qui transversent l'ensemble des modules mtiers. Il existe en fait deux principaux symptmes lis aux proccupations transversales : l'enchevtrement du code et l'parpillement du code
I-A-1 - Enchevtrement du code (code tangling)

L'enchevtrement du code est provoqu quand un module est implment pour traiter plusieurs proccupations en mme temps. Un dveloppeur a souvent affaire, pendant qu'il dveloppe un module, des proccupations telles que la logique mtier, la gestion transactionnelle de la persistance, le logging, la scurit, etc... (Figure). Cela conduit la prsence simultane d'lments issus de chaque proccupation et il en rsulte en un enchevtrement du code.
Enchevtrement du code Un autre exemple pour illustrer l'enchevtrement du code est la notion d'espace multi dimensionnel de proccupations. Imaginons que les besoins sont projets sur un espace multi dimensionnel o chaque proccupation reprsente une dimension. Dans cet espace, chaque proccupation est indpendante et peut voluer sans affecter les autres proccupations. Par exemple, le changement du schma de scurit n'affecte pas la logique mtier. Cependant, un espace multidimensionnel de proccupation est rduit dans un espace uni dimensionnel d'implmentation (Figure).
Espace des proccupations et espace d'implmentation Tant que l'espace d'implmentation est uni dimensionnel, on se concentre souvent sur l'implmentation de la proccupation qui a un rle dominant ; les autres proccupations sont alors enchevtres avec la proccupation dominante.
I-A-2 - parpillement du code (code scattering)

L'parpillement du code survient quand une proccupation est implmente dans plusieurs modules. Les proccupations transversales sont, par dfinition, disperses travers plusieurs modules. Par exemple, dans un systme utilisant une base de donnes, le logging est une proccupation implmente dans tous les modules qui accdent la base (Figure).
parpillement du code de la proccupation logging
I-B - Mthodologie de l'AOP

Le dveloppement de logiciels en utilisant l'approche oriente aspect est similaire au dveloppement de logiciels avec d'autres mthodologies (voir figure) : identification des proccupations, leur implmentation, et leur combinaison pour former le systme final. La communaut des chercheurs de l'AOP dfinit ces trois tapes comme suit :
Etapes de dveloppement dans une mthodologie AOP 1 Dcomposition aspectuelle : Les besoins sont ici dcomposs pour identifier les proccupations fonctionnelles et transversales. Par exemple, un dveloppeur pourra identifier les proccupations suivantes : logique mtier, logging, cache, gestion transactionnelle de la persistance, authentification, etc. Ensuite, il pourra dcider que seule la logique mtier est une proccupation fonctionnelle. Toutes les autres proccupations sont des proccupations transversales au systme et qui vont tre utilises par plusieurs modules. Implmentation des proccupations : Chaque proccupation est implmente indpendamment des autres. Comme pour l'exemple du paragraphe prcdent, le dveloppeur aura implmenter la logique mtier, le logging, le cache, la gestion transactionnelle de la persistance, l'authentification, etc. Recomposition aspectuelle : Des rgles de recompositions sont spcifies en crant des units appeles aspects. Le processus de recomposition, aussi connu sous le nom de tissage ou d'intgration, utilise ces informations pour composer le systme final. Comme pour l'exemple prcdent, le dveloppeur peut crer une rgle qui s'assure que chaque opration effectue par la logique mtier doit d'abord tre mise en journal (logge).
2 3
II - Concepts II-A - Aspect

Un aspect est une entit logicielle qui capture une fonctionnalit transversale une application. Les trois elments principaux dfinis dans un aspect sont les coupes (pointcuts), les codes advice et le mcanisme d'introduction. Les coupes dfinissent o l'aspect doit tre intgr dans une application et les codes advice dfinissent ce que fait l'aspect (le quoi). Le mcanisme d'introduction permet d'ajouter du contenu structurel dans une application. Nous allons dfinir ces concepts avec plus de dtails dans les paragraphes suivants.
II-B - Point de jonction (joinpoint)

Un point de jonction est un point dans le flot de contrle d'un programme dans lequel un ou plusieurs aspects peuvent tre appliqus. Bien que la notion de point de jonction soit gnrale (potentiellement, chaque instruction d'un programme peut tre un point de jonction), tous les points dans le flot de contrle ne sont pas considrs comme utiles pour l'AOP. Les points de jonction sont groups en fonction de leur type, et seulement un sous-ensemble de tous les types possibles de points de jonction est support par les langages orients aspects.
Bien que la dfinition d'un point de jonction dsigne un moment de l'excution, cette dfinition est base sur la structure d'un programme (ses classes, mthodes, attributs, etc.). Les catgories suivantes dcrivent les types de points de jonction communment rencontrs et qui sont indpendants de toute implmentation : Les mthodes : dans les langages orients objet, l'excution d'un programme peut tre considre comme une squence d'appels et d'excution de mthodes. Les diffrents scnarios d'excution d'une application peuvent tre exprims en termes de squences de messages qui dclenchent l'excution de mthodes. Les appels et les excutions de mthodes sont donc deux types de points de jonction couramment utiliss. Les constructeurs : les constructeurs sont principalement utiliss pour crer les instances des classes d'une application. Comme pour les mthodes, Les appels et les excutions d'un constructeur correspondent des types de points de jonction. Les attributs : les langages orients aspect considrent les oprations de lecture et d'criture sur les attributs comme des types de points de jonction. Un exemple concret d'utilisation de ce type de point de jonction est la gestion transactionnelle de la persistance. Les exceptions : les exceptions sont leves (throw) pour signaler une situation d'excution anormale et elles sont captures (catch}) pour excuter un traitement particulier. Ces deux vnements (le throw et le catch) sont des points d'excution trs importants dans une application. Ils sont tout les deux considrs par la plupart des langages orients aspect comme des types de points de jonction.
Les appels et les excutions de mthodes sont incontestablement les types de points de jonction les plus utiliss dans l'AOP. D'autres lments de codes, comme les boucles FOR et les instructions conditionnelles IF, qui dfinissent la structure d'un programme sont considrs de trs faible granularit pour tre utiliss pour dfinir des points de jonction. En conclusion, tous les programmes, mmes les plus simples, contiennent plusieurs points de jonction diffrents. La tche du dveloppeur est de slectionner les points de jonction qui sont utiles pour implmenter un aspect donn. Cette slection est ralise grce la notion de coupe (pointcut), qui est prsente dans le paragraphe suivant.
II-C - Coupe (pointcut)

Dans le paragraphe prcdent, nous avons dit que les points de jonction sont des points dans le flot de contrle d'un programme dans lequel un ou plusieurs aspects peuvent tre appliqus. La notion de point de jonction n'est pas suffisante elle seule pour dfinir quels points de jonction sont pertinents pour un aspect donn. On a besoin d'une autre notion pour dcrire les points de jonction. Cette notion est la coupe. Une coupe slctionne un ensemble de points de jonction. Un langage de programmation orient aspect se doit de fournir au dveloppeur une structure syntaxique permettant de dclarer une coupe. Cependant chaque langage dfinit sa propre syntaxe. Gnralement, une coupe est dfinie avec un langage de patterns qui permet d'indiquer o l'aspect doit tre intgr dans l'application en utilisant des quantificateurs, des oprateurs boolen et des caractres joker ou \textit{wildcards} (comme le caractere *).
II-D - Code advice (advice code)

Un code advice est un bloc de code dfinissant le comportement d'un aspect. Concrtement, un code advice est un bloc d'instruction qui spcifie le comportement de l'aspect. Un code advice est toujours associ une coupe ou plus exactement aux points de jonctions slectionns par cette coupe. En effet, un code advice n'est jamais appel manuellement, mais il est invoqu chaque fois qu'un point de jonction, slectionn par la coupe la quelle il est associ, survient.
Un code advice peut tre excut selon trois modes : avant, aprs, ou autour d'un point de jonction. Lorsqu'il est excut autour du point de jonction, il peut carrment remplacer l'excution de ce dernier, ou bien lui redonner le contrle.
II-E - Mcanisme d'introduction

Le mcanisme d'introduction est un mcanisme d'extension permettant d'introduire de nouveaux lments structuraux au code d'une application. Le mcanisme d'introduction permet d'tendre la structure d'une application et non pas le comportement de cette dernire. En effet, le mcanisme d'introduction ne s'appuie pas sur la notion de coupe mais va oprer sur des emplacements bien dfinis dans le programme. On peut dire que le mcanisme d'introduction est pour l'oriente aspect ce que l'hritage est pour l'oriente objet puisque ces deux derniers permettent d'tendre la structure et non pas le comportement de l'application.
II-F - Tissage (weaving)

Le tissage (weaving) est le processus qui prends en entre un ensemble d'aspects et une application de base et fournit en sortie une application dont le comportement et la structure sont tendus par les aspects. Une application oriente aspect contient des classes et des aspects. L'opration qui prends en entre les classes et les aspects et produit une application qui intgre les fonctionnalits des classes et des aspects est connu sous le nom de tissage d'aspect (aspect weaving). Le programme qui ralise cette opration est appel tisseur d'aspects (aspect weaver) ou bien tisseur (weaver) tout court. (Figure)
Tissage des aspects
III - AspectJ III-A - Historique et origine

L'histoire d'AspectJ est troitement lies celle la programmation oriente aspect. En effet, Ce langage a t dvelopp par la mme quipe l'origine de l'AOP. Un premier prototype d'AspectJ a t ralis en 1998. Et depuis,
plusieurs versions d'AspectJ ont vu le jour, et chacune apportait de nouvelles fonctionnalits et corrigeait les bugs de la prcdente. La premire version officielle d'AspectJ, dsign AspectJ 1.0, a t ralise en novembre 2001, Durant cette anne, l'AOP a t compltement reconnue par la communaut informatique mondiale, et une dition spciale du journal Communications of the ACM a t ddie l'AOP. En dcembre 2002, le projet AspectJ a quitt XEROX PARC et a rejoint la communaut open-source Eclipse. Et depuis, le plugin Eclipse AspectJ Developpement Tools (AJDT) est dvelopp. Ce plugin intgre AspectJ et permet d'crire, de compiler et d'excuter des programmes orient aspects dans l'environnement de dveloppement Eclipse.
III-B - Tlchargement et installation de l'outil

AspectJ peut tre tlcharg partir de cette adresse http://www.eclipse.org/aspectj/downloads.php, il se prsente sous forme d'un compilateur (ajc) et d'un ensemble de librairie. Pour installer AspectJ il suffit d'excuter l'installation pralablement tlcharge depuis le lien indiqu prcdemment.
Installation d'AspectJ A la fin de l'installation, il est recommand de mettre le rpertoire %aspectj_folder%/bin dans la variable d'environnement path afin de pouvoir l'utiliser dans la ligne de commande partir de n'importe quel chemin.
III-C - Prsentation gnrale

AspectJ est aujourd'hui une implmentation oriente aspect phare qui fournit un excellent support pour apprhender les concepts de la programmation oriente aspect. Comme indiqu dans le paragraphe prcdent, sa plus grande force rside dans le fait qu'il est issue des travaux de la mme quipe l'origine de l'oriente aspect. AspectJ est donc une extension oriente aspect du langage de programmation Java. Il permet de dclarer des aspects, des coupes, des codes advices et des introductions. Il offre aussi un tisseur d'aspect appel ajc (pour AspectJCompiler) qui prends en entre des classes java et des aspects, et produit en sortie des classes dont le comportement est augment par les aspects. Aujourd'hui, AspectJ bnficie d'une multitude d'outils de dboguage, d'environnement de dveloppements et de visualisateurs d'aspects. AspectJ permet de dfinir deux types de transversalits avec les classes de base : transversalit statique (static crosscutting) et transversalit dynamique (dynamic crosscutting).
Transversalit statique : La transversalit statique consiste augmenter la structure des classes. Pour cela AspectJ offre la notion de mcanisme d'introduction qui permet entre autres d'ajouter des lments structuraux comme des attributs ou des mthodes aux classes. Le mcanisme d'introduction d'AspectJ permet aussi d'ajouter des liens entre des classes comme l'hritage et l'implmentation d'interfaces. Concrtement, AspectJ offre un support simple et facile apprhender pour implmenter ce genre de transversalit. Transversalit dynamique : La transversalit dynamique consiste augmenter le comportement des classes. Pour cela AspectJ offre les notions de coupes et de code advices. Les coupes servent slectionner des points prcis dans les classes. Et les advices iront se greffer avant, aprs ou autour de ces points afin d'tendre leur comportement.
Dans ce qui suit, nous allons aborder les principaux concepts de ce langage et leur mise en oeuvre pratique. Pour cela, tous le exemples qui seront prsents reposeront sur le diagramme de classes de la figure suivante.
Diagramme de classes d'un systme de figures gomtriques
III-D - Point de jonction

En ralit, Un point de jonction est n'importe quel point d'excution dans un systme. Parmi tous les points de jonction possibles dans un systme on cite de faon non exhaustive : L'appel une mthode ; L'excution d'une mthode ; L'affectation de variable ; L'appel au constructeur d'une classe ; Une instruction conditionnelle (i.e. IF/THEN/ELSE) ; Le traitement d'une exception ; Les boucles (i.e. FOR, WHILE, DO/WHILE) ; etc... Mais en pratique, et par souci de prvenir la dpendance de l'implmentation et la transversalit instable, le modle de points de jonction adopt par AspectJ n'offre qu'un sous ensemble de points de jonctions possibles. Par exemple, Il ne considre pas les boucles comme des points de jonctions. L'ensemble des points de jonction offert par AspectJ est rsum dans le tableau suivant.
- 10 Copyright 2009 Developpez LLC. Tous droits rservs Developpez LLC. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts. Cette page est dpose la SACD.
Point de jonction Method call Method execution Constructor call Constructor execution Static initializer execution Object pre-initialization Object initialization Field reference Field set Handler execution Advice execution
Description Quand une mthode est appele Quand le corps d'une mthode est execut Quand un constructeur est appel Quand le corps d'un constructeur est execut Quand l'initialisation statique d'une classe est excute Avant l'initialisation de l'objet Quand l'initialisation d'un objet est excute Quand un attribut non-constant d'une classe est rfrenc Quand un attribut d'une classe est modifi Quand un traitement d'une exception est excut Quand le code d'un advice est excut
Dans AspectJ, Tout les points de jonction ont un contexte associ eux. Par exemple, le contexte d'un point de jonction correspondant un appel de mthode contient l'objet appelant, l'objet appel, et les arguments de la mthode. De la mme manire, le contexte d'un point de jonction correspondant au traitement d'une exception contient l'objet courant, et l'exception leve.
III-E - Coupe
Dans AspectJ, les coupes corresdpondent plusieurs points de jonctions dans le flot d'un programme. Par exemple, la coupe :
call(void Point.setX(int))
capture chaque points de jonctions correspondant un appel la mthode setX() de la classe Point qui ne retourne aucune valeur void et qui a comme paramtre un entier (int). Une coupe peut tre construite partir d'autre coupes en utilisant les oprateurs and, or et not (respectivement &&, || et !). Par exemple, la coupe :
call(void Point.setX(int)) || call(void Point.setY(int))
Dsigne les points de jonction correspondant un appel la mthode Point.setX() ou un appel la mthode Point.setY(). Les coupes peuvent identifier des points de jonction de diffrentes classes, en d'autres termes, elles peuvent tre transverses aux classes. Par exemple, la coupe :
call(void call(void call(void call(void call(void FigureElement.incrXY(int,int)) Point.setX(int)) Point.setY(int)) Line.setP1(Point)) Line.setP2(Point)) || || || ||
capture chaque point de jonction qui est un appel une des cinq mthodes (la premire mthode est une mthode d'interface). Dans le dernier exemple, la coupe capture tous les points de jonction correspondant au mouvement d'un objet de type FigureElement. AspectJ permet de dclarer des coupes nommes avec le mot-cl pointcut, afin qu'elles puissent tre rutilises sans avoir les redfinir. Les instructions suivantes dclarent une coupe nomme :
pointcut move(): call(void FigureElement.incrXY(int,int)) call(void Point.setX(int)) call(void Point.setY(int)) call(void Line.setP1(Point)) call(void Line.setP2(Point));
|| || || ||
Ainsi, on peut appeler n'importe quel moment la coupe nomme move(). Jusque l, les coupes que nous avons donnes taient bases sur une numration explicite d'un ensemble de signature de mthodes. AspectJ offre aussi un mcanisme qui permet de spcifier des coupes en termes de proprits de mthodes autres que leur nom exact. La faon la plus simple de le faire est d'utiliser les expressions rgulires pour exprimer les champs de la signature des mthodes. Par exemple, la coupe :
call(void Point.set*(..))
capture chaque point de jonction correspondant un appel d'une mthode ne retournant aucun rsultat (void) et appartenant la classe Point et commenant par la chaine set, quelque soit le type et le nombre de ses paramtres. La coupe :
call(public * Line.* (..))
capture tout les appels aux mthodes publiques (public) de la classe Line. Les exemples prcdents ne font appel qu' un seul type de coupe qui est l'appel de mthode (i.e. call). Il existe d'autres types de coupes dans AspectJ comme : l'excution de mthode (ex : execution(void Point.setX(..))), ou l'accs aux attributs (ex : get(Point.x)), etc.
III-F - Advice
Les coupes capturent les points de jonction, mais elles ne font rien de plus. Pour implmenter un comportement transversal, on utilise les advices. En effet, un advice fait correspondre une coupe (i.e. un ensemble de points de jonction) un bout de code excut chaque point de jonction de cette coupe. Un code advice est un bloc d'instruction associ une coupe. Il est excut avant, aprs ou autour des points de jonction slectionns par la coupe qui lui est associe. AspectJ offre 3 types de codes advice : before, after et around. Les codes advice de type before (respectivement after) permettent d'introduire un comportement avant (respectivement aprs) un point de jonction. Cependant les codes advice de type after se dclinent en 2 variantes : after returning et after throwing qui signifient respectivement aprs le retour d'une mthode sans exception et avec exception. Un advice de type around quant lui dfinit un bloc d'instructions qui s'excute autour d'un point de jonction. Il permet ventuellement de remplacer carrment l'excution d'une mthode. AspectJ fournit la mthode proceed() qui permet de rendre le contrle de l'excution au point de jonction dans un code advice de type around. Le code suivant montre un exemple d'advice de type before, qui utilise la coupe move() dfinit prcdemment :
before() : move() { System.out.println("Figure sur le point d'tre dplace");}
Le code suivant montre un exemple d'advice de type around :

around() : call(Display.update()) { if (! Display.disabled()) proceed();}
Nous avons dit prcdemment qu' chaque point de jonction est associ un contexte d'excution (cf. section ) contenant par exemple les arguments de la mthode si le point de jonction en est une. Dans AspectJ, ce contexte est accessible via les trois coupes primitives : this, target, args. Ce contexte s'avre trs utile lorsqu'on veut par exemple, accder aux paramtres d'une mthode dans un code advice. L'advice suivant :
after(int x,int y) returning : call(void FigureElement.incrXY(int,int) && args(x,y) { System.out.println("la figure a t dplac de +"x"+","+y); }
rcupre les arguments de la mthode incrXY(int,int) dans les variables x et y et peut faire n'importe quel traitement avec ces valeurs. Les coupes primitives this et target permettent respectivement de rcuprer l'objet courant et l'objet cible du contexte d'excution pour le point de jonction. Le tableau suivant rsume la signification de l'objet courant, de l'objet cible et des arguments pour chaque type de points de jonction. Point de jonction Method Call Method Execution Constructor Call Constructor Execution Static initializer execution Object preinitialization Object initialization Field reference Field assignment Handler execution Advice execution Objet courant L'objet appelant L'objet appelant L'objet appelant L'objet appelant Nant Nant L'objet appelant L'objet appelant L'objet appelant L'objet appelant L'aspect appelant Objet cible L'objet appel L'objet appel Nant L'objet appelant Nant Nant L'objet appelant L'objet appel L'objet appel L'objet appelant L'aspect appelant Arguments Les arguments de la mthode Les arguments de la mthode Les arguments du constructeur Les arguments du constructeur Nant Les arguments du constructeur Les arguments du constructeurs Nant La valeur assigne L'exception leve Les arguments de l'advice
III-G - Dclaration inter-type

Les dclarations inter-types, dans AspectJ, correspondent au mcanisme d'introduction vu prcdemment (cf. section ). Elles permettent de dclarer des membres dans des classes, ou de changer la relation d'hritages entre classes. Le code suivant montre quelques exemples de dclaration inter-types. Il s'agit d'ajouter un attribut name de type String et deux mthodes setName() et getName() la classe Point :
public String Point.name ; public void Point.setName ( String name ) { this.name = name ; } public String Point.getName ( ) { return name ; }
L'instruction suivante permet de dclarer que les classes Point et Line hritent de la classe GeometricObject :
declare parents : (Point || Line) extends GeometricObject ;
III-H - Aspect
Dans AspectJ. Un aspect contient tout les ingrdients ncessaires pour la dfinition d'une proccupation transversale savoir : les dfinitions de coupes, les codes advice et les dclarations inter-types. Il peut aussi ventuellement contenir des attributs et des mthodes qui lui sont propres. Le code suivant montre un exemple d'aspect ralisant la proccupation de mise jour d'affichage :
aspect UpdateDisplay {
pointcut move(FigureElement elem) : target (elem) && ( call ( void Line.setP1 (Point) ) || call ( void Line.setP2 (Point) ) || call ( void Point.setX (int) ) || call ( void Point.setY (int) ) || call ( void FigureElement.incrXY(int, int) ) ) ; after(FigureElement elem) returning : move ( elem ) { Display.update(elem); }
IV - Exemple d'application IV-A - Introduction

Dans cette section, nous allons nous intresser un exemple d'implmentation d'une proccupation transversale sur un systme existant. D'abord, nous allons commencer par dcrire le systme sur lequel va porter l'exemple. Il s'agit d'un systme d'arbre d'expression syntaxique. Nous allons le dcrire l'aide de diagrammes UML accompagns du code source Java correspondant. Ensuite, nous allons dcrire la proccupation qu'on veut implmenter dans le systme. Cette proccupation consiste en l'implmentation d'un cache qui permettra d'optimiser l'valuation des arbres syntaxiques en vitant les parcours en profondeur. Enfin, Nous allons terminer par comparer l'excution de l'exemple avec et sans la proccupation cache.
IV-B - Le systme d'arbre d'expression

Le systme permet de reprsenter des expressions syntaxiques sous forme d'arbre d'expression syntaxique. Par souci de simplicit, nous avons dcid de ne reprsenter qu'une seule opration qui est l'opration Plus. Donc, le systme est compos de trois classes : Expression, Number et Plus et il est dcrit par le diagramme de classe de la figure suivante :
Systme d'arbre d'expression Le code source correspondant aux trois classes du systme est trs simple et est prsent ci-dessous. Expression.java
package org.sdf; public abstract class Expression { public abstract int eval(); }
Plus.java
package org.sdf; public class Plus extends Expression { private Expression leftExpression;
Plus.java
private Expression rightExpression; public Plus(Expression leftExpression, Expression rightExpression) { super(); this.leftExpression = leftExpression; this.rightExpression = rightExpression; } public Expression getLeftExpression() { return leftExpression; } public void setLeftExpression(Expression leftExpression) { this.leftExpression = leftExpression; } public Expression getRightExpression() { return rightExpression; } public void setRightExpression(Expression rightExpression) { this.rightExpression = rightExpression; } @Override public int eval() { System.out.println("Evaluation d'un noeud"); return leftExpression.eval() + rightExpression.eval(); }
Number.java
package org.sdf; public class Number extends Expression { private int value; public Number(int value) { this.value = value; } public void setValue(int value) { this.value = value; } @Override public int eval() { System.out.println("Evaluation d'un noeud"); return value; }
Si on excute le programme suivant Main.java

package org.sdf; public class Main { /** * @param args */ public static void main(String[] args) { Number dix = new Number(10); Number neuf = new Number(9); Number cinq = new Number(5);
Main.java
} }
Plus plus1 = new Plus(dix,neuf); Plus plus2 = new Plus(plus1,cinq); // au dbut, defaut de cache obligatoire System.out.println("premier appel"); System.out.println(plus2.eval()); // on a un cache valide, donc on le consulte au lieu de parcourir l'arbre System.out.println("deusieme appel"); System.out.println(plus2.eval()); // on va altrer la valeur du noeud cinq // qui va conduire invalider son cache ainsi que celui de operation2 cinq.setValue(4); System.out.println("troisieme appel"); System.out.println(plus2.eval());
on aura comme rsultat l'arbre de la figure suivante :
Arbre reprsentant l'expression ((10+9)+5)
IV-C - La proccupation "cache"

Supposons que nous voulons tendre le systme pour qu'il supporte un mcanisme de cache. Le principe du cache dans l'arbre d'expression est simple : on ajoute une variable cache aux niveau de chaque nud, et chaque appel de eval(), on vrifie si la valeur du cache est valide. Si c'est le cas, on n'aura pas besoin de parcourir les sous-arbres gauches et droits. Apporter un mcanisme de cache au systme est certes trs bnfique ct performance. Mais malheureusement, le code source sera moins lisible. Car, d'une part, il y aura un enchevtrement du code source mtier (i.e. code source original du systme d'arbre d'expression) et du code source de la proccupation cache et d'autre part, la proccupation cache sera disperse travers les classes du systme. En effet, pour implmenter une telle proccupation, on aura dclarer une variable cache dans la classe Expression qui dtiendra la valeur courante du cache, et des mthodes pour accder a cette variable. De plus, on devra implmenter un mcanisme d'invalidation du cache dans toutes les sous-classes de la classe Expression au cas o la valeur du cache serait invalide. Et puis, on devra changer l'implmentation des mthodes eval() dans toutes les classes de faon ce qu'elles renvoient la valeur du cache s'il est valide. C'est l o l'AOP intervient, en apportant une solution efficace et lgante aux problmes cits ci-dessus. La proccupation cache sera implmente dans un seul module et non parpille travers plusieurs classes. Comme prcis ci-dessus, pour grer le cache, on devra dclarer une variable cache qui dtient la valeur courante du cache, ainsi qu'une variable boolenne qui indique si le cache est valide ou pas. Ceci est ralis grce au mcanisme de dclaration inter-types (cf. section ) comme suit :
private int Expression.cache; private boolean Expression.cacheValid = false;
public int Expression.getCache() { return cache; } public void Expression.setCache(int cache) { this.cache = cache; } public boolean Expression.isCacheValid() { return cacheValid; } public void Expression.validateCache() { this.cacheValid = true; }
En plus de ces deux variables, chaque nud devra connaitre l'identit de son pre afin qu'il puisse lui signaliser que son cache n'est plus valide, ce qui va impliquer aussi l'invalidation du cache du pre et vice-versa jusqu' la racine. Ceci est fait en dclarant une variable appele ancestor qui pointera vers le pre du nud, et une mthode qui permet d'invalider le cache des ascendants (s'ils existent) en cascade, comme suit :
private Expression Expression.ancestor = null; public void Expression.invalidateCache() { cacheValid = false; if (this.getAncestor()!=null) this.getAncestor().invalidateCache(); } public Expression Expression.getAncestor() { return ancestor; } public void Expression.setAncestor(Expression ancestor) { this.ancestor = ancestor; }
L'invalidation du cache devra survenir aprs chaque changement de valeur d'un nud. Le changement de valeur d'un nud consiste en l'appel d'une des mthodes : Number.setValue(); Plus.setLeftExpression(); Plus.setRightExpression();
En AspectJ, cette coupe s'exprime comme suit :

pointcut changeValue(Expression exp): target(exp) && ( call(public void Number.setValue(int)) || call(public void Plus.setLeftExpression(Expression)) || call(public void Plus.setRightExpression(Expression)) );
Et l'advice correspondant cette coupe devra appeler la mthode invalidateCache() sur l'objet exp (objet sur lequel la mthode a t appele et rcupre avec la coupe primitive target) aprs chaque occurrence de l'un des points de jonction de la coupe. Il est dclar comme suit :
after(Expression exp):changeValue(exp) { exp.invalidateCache(); }
Afin de pouvoir consulter le cache avant d'valuer les fils gauches et droits, on devra capturer chaque point de jonction correspondant un appel la mthode eval(). Ceci est effectu grce la coupe suivante :
pointcut evaluation(Expression exp): target(exp) && call(public int Expression.eval());
Et l'advice correspondant cette coupe doit d'abord voir si le cache est valide. Si ce n'est pas le cas, il appelle la mthode originale avec proceed() pour valuer la valeur des sous-arbres, puis il affecte cette valeur au cache, le valide et retourne sa valeur. Il est dclar comme suit :
int around(Expression exp):evaluation(exp) { if (!exp.isCacheValid()) { int result = proceed(exp); exp.setCache(result); exp.validateCache(); } return exp.getCache(); }
La dernire chose faire consiste crer un lien entre un nud et son pre. Pour cela, on devra capturer tous les points de jonction correspondant au constructeur de la classe Plus. Ceci est fait avec la coupe suivante :
pointcut PlusCreation(Plus exp): this(exp) && execution(Plus.new(Expression,Expression));
Et l'advice correspondant devra lier le pre aux fils, en utilisant la mthode setAncestor() dclare prcdemment, comme suit :
after(Plus exp) : PlusCreation(exp) { exp.getLeftExpression().setAncestor(exp); exp.getRightExpression().setAncestor(exp); }
Voil, il ne reste plus qu' mettre tous ces petits bouts de code dans un mme module (ou aspect). Ce qui va rsulter en ceci : Caching.aj
package org.sdf; public aspect Caching { private int Expression.cache; private boolean Expression.cacheValid = false; private Expression Expression.ancestor = null; public int Expression.getCache() { return cache; } public void Expression.setCache(int cache) { this.cache = cache; } public boolean Expression.isCacheValid() { return cacheValid; } public void Expression.validateCache() { this.cacheValid = true; } public void Expression.invalidateCache() { cacheValid = false; if (this.getAncestor()!=null) this.getAncestor().invalidateCache();
Caching.aj
} public Expression Expression.getAncestor() { return ancestor; } public void Expression.setAncestor(Expression ancestor) { this.ancestor = ancestor; } pointcut changeValue(Expression exp): target(exp) && ( call(public void Number.setValue(int)) || call(public void Plus.setLeftExpression(Expression)) || call(public void Plus.setRightExpression(Expression)) ); after(Expression exp):changeValue(exp) { exp.invalidateCache(); } pointcut evaluation(Expression exp): target(exp) && call(public int Expression.eval()); int around(Expression exp):evaluation(exp) { if (!exp.isCacheValid()) { int result = proceed(exp); exp.setCache(result); exp.validateCache(); } return exp.getCache(); } pointcut PlusCreation(Plus exp): this(exp) && execution(Plus.new(Expression,Expression)); after(Plus exp) : PlusCreation(exp) { exp.getLeftExpression().setAncestor(exp); exp.getRightExpression().setAncestor(exp); }
IV-D - Excution sans cache

Pour ne pas prendre en compte l'aspect Caching, le fichier Caching.aj ne doit pas tre indiqu au compilateur ajc lors de la compilation. Les commandes suivantes servent compiler les classes sans la prise en compte de l'aspect Caching et excuter l'application :
ajc -cp c:\aspectj1.6\lib\aspectjrt.jar -source 1.6 org/sdf/*.java java org.sdf.Main
Ce qui donne le rsultat suivant aprs l'excution :

premier appel Evaluation d'un Evaluation d'un Evaluation d'un Evaluation d'un Evaluation d'un 24 deusieme appel Evaluation d'un Evaluation d'un
noeud noeud noeud noeud noeud noeud noeud
Evaluation d'un Evaluation d'un Evaluation d'un 24 troisieme appel Evaluation d'un Evaluation d'un Evaluation d'un Evaluation d'un Evaluation d'un 23
noeud noeud noeud noeud noeud noeud noeud noeud
On remarque qu' chaque appel, on devra visiter les cinq nuds de l'arbre.
IV-E - Excution avec cache

Pour prendre en compte l'aspect Caching, le fichier Caching.aj doit tre indiqu au compilateur ajc lors de la compilation. Les commandes suivantes servent compiler les classes avec la prise en compte du tissage de l'aspect Caching et excuter l'application :
ajc -cp c:\aspectj1.6\lib\aspectjrt.jar -source 1.6 org/sdf/*.java org/sdf/*.aj java -cp c:\aspectj1.6\lib\aspectjrt.jar;. org.sdf.Main
Ce qui donne le rsultat suivant aprs l'excution :

premier appel Evaluation d'un Evaluation d'un Evaluation d'un Evaluation d'un Evaluation d'un 24 deusieme appel 24 troisieme appel Evaluation d'un Evaluation d'un 23
noeud noeud noeud noeud noeud
noeud noeud
On remarque qu'au premier appel de eval(), on devra crer 5 dfauts de cache obligatoires. Mais au deuxime appel aucun nud n'est valu, la valeur 24 est extraite du cache et aucun parcours de l'arbre n'est effectu. Au troisime appel la valeur du nud cinq est altre donc la valeur de son cache et aussi celle du cache de son pre (le nud plus 2) sont invalides, ce qui rsulte en la rvaluation de seulement deux nuds dans l'arbre.
V - Conclusion
Dans cet article, nous avons fais un survol sur la programmation oriente aspect. Aprs avoir expliqu les problmes auxquels l'AOP apporte des solutions efficaces dans la section , nous avons abord les principaux concepts de ce paradigme dans la section en se basant sur des rfrences plus ou moins rcentes. Ensuite, nous avons prsent dans la section le langage AspectJ, ses origines, les notions qu'il apporte au langage de programmation Java. Nous avons vu la syntaxe de ses principales composantes accompagne de plusieurs exemples illustratifs. La section prsente un exemple concret d'implmentation d'une proccupation transversale dans un systme existant. Il s'agit d'implmenter un schma de cache dans un systme d'arbre d'expression, afin d'viter des parcours en profondeur. Pour cela, le systme a subit une volution sans perdre le moindre degr de maintenabilit ou de comprhensibilit. La proccupation transversale Cache a t exprime dans le langage AspectJ. Elle a t encapsule dans un seul module et le programme principal n'a subit aucune modification. Les rsultats empiriques ont montr la faisabilit de cette approche.
VI - Tlchargement des sources

Tlcharger
VII - Liens connexes

Critique du livre Critique du livre Introduction AOP (Aspect-Oriented Programming) avec le framework Spring Framework Programmation Oriente Aspect sous Delphi AspectJ AspectJ Developpement tools
VIII - Remerciements
Je remercie La Zlie et jacques_jean pour l'excellent travail qu'il ont effectue pour la relecture orthographique ainsi que Ricky81 et Baptiste Wicht pour leurs conseils et encouragements.
IX - Commentaires des lecteurs

Vos commentaires sont les bienvenus dans cette discussion

Programmation Orientée Aspect en Java Avec Aspectj: Selim Kebir

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Programmation Orientée Aspect en Java Avec Aspectj: Selim Kebir

Enviado por

Direitos autorais:

Formatos disponíveis

Programmation oriente aspect en Java avec AspectJ

Par Selim KEBIR

Date de publication : 2 fvrier 2010

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

I-A - Proccupations transversales

I-A-1 - Enchevtrement du code (code tangling)

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

I-A-2 - parpillement du code (code scattering)

parpillement du code de la proccupation logging

I-B - Mthodologie de l'AOP

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

II - Concepts II-A - Aspect

II-B - Point de jonction (joinpoint)

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

II-C - Coupe (pointcut)

II-D - Code advice (advice code)

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

II-E - Mcanisme d'introduction

II-F - Tissage (weaving)

Tissage des aspects

III - AspectJ III-A - Historique et origine

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

III-B - Tlchargement et installation de l'outil

III-C - Prsentation gnrale

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

Diagramme de classes d'un systme de figures gomtriques

III-D - Point de jonction

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

Le code suivant montre un exemple d'advice de type around :

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

III-G - Dclaration inter-type

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

IV - Exemple d'application IV-A - Introduction

IV-B - Le systme d'arbre d'expression

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

Si on excute le programme suivant Main.java

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

on aura comme rsultat l'arbre de la figure suivante :

Arbre reprsentant l'expression ((10+9)+5)

IV-C - La proccupation "cache"

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

En AspectJ, cette coupe s'exprime comme suit :

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

pointcut evaluation(Expression exp): target(exp) && call(public int Expression.eval());

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

IV-D - Excution sans cache

Ce qui donne le rsultat suivant aprs l'excution :

noeud noeud noeud noeud noeud noeud noeud

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

noeud noeud noeud noeud noeud noeud noeud noeud

IV-E - Excution avec cache

Ce qui donne le rsultat suivant aprs l'excution :

noeud noeud noeud noeud noeud

Programmation oriente aspect en Java avec AspectJ par Selim KEBIR

VI - Tlchargement des sources

VII - Liens connexes

IX - Commentaires des lecteurs

Você também pode gostar