Introduction AOP (Aspect-Oriented Programming) avec le framework Spring

par Eric Wawszczyk

Date de publication : 17 dcembre 2007

Dans beaucoup d'applications informatiques, un module ou composant mtier est rgulirement pollu par de multiples appels des composants utilitaires externes. La programmation par aspect (AOP) va permettre d'extraire les dpendances entre modules concernant des aspects techniques entrecroiss et de les grer depuis l'extrieur de ces modules en les spcifiant dans des composants du systme dvelopper nomms aspects ; ils sont dvelopps un autre niveau d'abstraction.

Introduction AOP (Aspect-Oriented Programming) avec le framework Spring par Eric Wawszczyk

I - Introduction..............................................................................................................................................................3 II - La programmation oriente aspect........................................................................................................................ 4 II-A - Principe..........................................................................................................................................................4 II-B - Lexique.......................................................................................................................................................... 4 II-C - Stratgies d'implmentation..........................................................................................................................5 III - AOP : Exemple d'utilisation...................................................................................................................................6 III-A - Prsentation................................................................................................................................................. 6 III-B - La classe tracer........................................................................................................................................ 6 III-C - Le fichier de configuration Spring................................................................................................................7 III-D - La classe MonLogger.................................................................................................................................. 8 III-E - Rsultat........................................................................................................................................................ 8 IV - AOP : Fonctions avances................................................................................................................................... 9 IV-A - Les pointcut................................................................................................................................................. 9 IV-B - Les diffrents Advice................................................................................................................................... 9 V - Conclusion........................................................................................................................................................... 10 V-A - Avantages................................................................................................................................................... 10 V-B - Inconvnients.............................................................................................................................................. 10 VI - Remerciements................................................................................................................................................... 11 VII - Liens...................................................................................................................................................................12

-2Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright Eric Wawszczyk. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. 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://ewawszczyk.developpez.com/tutoriel/java/spring/aop/

Introduction AOP (Aspect-Oriented Programming) avec le framework Spring par Eric Wawszczyk

Cet article a pour but de vous prsenter rapidement la programmation par aspect (AOP) et sa mise en application dans une application base sur le framework Spring. Dans la pratique, les considrations techniques que sont censes implmenter les modules d'une application non seulement s'entrecroisent (par exemple la gestion des utilisateurs fait aussi appel la gnration de trace) mais aussi sont rpartis dans la couche mtier. C'est l'intrication ou entrecroisement des aspects techniques. Ainsi, une couche logicielle initialement ddie grer la logique mtier applicative, va se retrouver dpendante de modules grant les aspects transactionnels, journalisation, etc. La programmation par aspect (AOP) va permettre d'extraire les dpendances entre ces modules.

I - Introduction

-3Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright Eric Wawszczyk. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. 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://ewawszczyk.developpez.com/tutoriel/java/spring/aop/

Introduction AOP (Aspect-Oriented Programming) avec le framework Spring par Eric Wawszczyk

II - La programmation oriente aspect II-A - Principe

Au lieu d'avoir un appel direct un module technique depuis un module mtier, ou entre deux modules techniques diffrents, en programmation par aspect, le code du module en cours de dveloppement est concentr sur le but poursuivi (la logique mtier), tandis qu'un aspect est spcifi de faon autonome, implmentant un aspect technique particulier, par exemple la persistance ou encore la gnration de trace. Un ensemble de points d'insertions ou joinpoint en anglais sont ensuite dfinis pour tablir la liaison entre l'aspect et le code mtier ou un autre aspect. Ces dfinitions de joinpoint sont dfinies dans le cadre de la PAO. Selon les frameworks ou les langages d'aspects, la fusion du code technique avec le code mtier est alors soit ralise la compilation, soit l'excution. Bien sr, si chaque aspect cr devait lui-mme dfinir explicitement quel point d'excution il doit s'insrer dans le code mtier ou dans un autre aspect, c'est--dire par exemple avec une dpendance directe vers le module mtier o devra s'intercaler le code technique, on n'aurait alors fait que dcaler le problme. Aussi, l'astuce particulire de la programmation par aspect consiste utiliser un systme d'expressions rationnelles pour prciser quels points d'excution (en anglais, joinpoint) du systme l'aspect spcifi devra tre activ. Exemple : Ajout de logs dans une application existante Une approche frquente consisterait en ce cas patcher le code un peu partout pour rajouter des log.debug() au dbut et la fin de chaque mthode. Avec les outils d'AOP on peut facilement spcifier les changements requis SANS toucher au code source original, dont la logique reste intacte. Les outils de programmation par aspect sont en fait similaires aux modificateurs (before, after et around) que l'on trouve dans des langages comme LISP, auxquels on a ajout la possibilit d'une description d'insertions dclaratives. Un aspect permet donc de spcifier : les points d'action (poincut), qui dfinissent les points de jonction satisfaisants aux conditions d'activation de l'aspect, donc le ou les moments o l'interaction va avoir lieu, les greffons c'est--dire les programmes (advice) qui seront activs avant, autour de ou aprs les points d'action dfinis.

II-B - Lexique
La programmation oriente aspect, parce qu'elle propose un paradigme de programmation et de nouveaux concepts, a dvelopp un jargon bien spcifique qui ne facilite pas la comprhension de ses concepts qui sont, en dfinitive, simples mais puissants. aspect : un module dfinissant des greffons et leurs points d'activation, greffon (en anglais, advice) : un programme qui sera activ un certain point d'excution du systme, prcis par un point de jonction, point d'action, de coupure, de greffe (en anglais, pointcut) : endroit du logiciel o est insr un greffon par le tisseur d'aspect, point de jonction, d'excution (en anglais, join point) : endroit spcifique dans le flot d'excution du systme, o il est valide d'insrer un greffon. Pour clarifier le propos, il n'est pas possible, par exemple, d'insrer un greffon au milieu du code d'une fonction. Par contre on pourra le faire avant, autour de, la place ou aprs l'appel de la fonction.

Deux grandes stratgies de tissage d'aspects existent : le tissage statique par instrumentation du code source ou du pseudo-code machine intermdiaire le tissage dynamique lors de l'excution du logiciel

C'est ce dernier cas que nous mettrons en pratique dans l'exemple qui va suivre.
-4Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright Eric Wawszczyk. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. 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://ewawszczyk.developpez.com/tutoriel/java/spring/aop/

Introduction AOP (Aspect-Oriented Programming) avec le framework Spring par Eric Wawszczyk

II-C - Stratgies d'implmentation

-5Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright Eric Wawszczyk. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. 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://ewawszczyk.developpez.com/tutoriel/java/spring/aop/

Introduction AOP (Aspect-Oriented Programming) avec le framework Spring par Eric Wawszczyk

III - AOP : Exemple d'utilisation

L'objectif de ce cas pratique est de tracer les appels aux mthodes objets dans une application base sur Spring. Ce besoin peut aussi bien se prsenter en phase de dveloppement, pendant laquelle, le dveloppeur n'a pas forcment envie de mettre dans son code des log.debug() partout. Mais aussi en phase de maintenance, pour mieux comprendre le cheminement de l'application ou tracer un bug. Avec Spring, il est possible de tracer les appels aux mthodes objets pendant l'excution ET SANS modifier le code de l'application.

III-A - Prsentation III-B - La classe tracer

Prenons l'exemple d'une simple classe mtier "MonService" qui contient la mthode "hello()" et renvoie une String. Nous allons donc voir comment modifier la configuration de Spring afin de mettre une trace chaque appel et chaque sortie de la mthode hello(). Le principe est d'intercepter les entres/sorties de la mthode "hello()" et de les logger l'aide d'une classe externe "MonLogger". MonService.java
package ew.service; public class MonService { public String hello(String msg){ String s = "Hello "+msg; System.out.println(s); return s; }

Et maintenant le programme qui l'appelle : MonServiceTest.java

package ew.test; import junit.framework.TestCase; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import ew.service.MonService; public class MonServiceTest extends TestCase { public void testMonService() { ApplicationContext context = new ClassPathXmlApplicationContext( new String[] {"springContext.xml"} ); MonService monService = (MonService) context.getBean("monService"); monService.hello("from Spring !"); } }

Et excutant le programme, nous obtenons :

-6Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright Eric Wawszczyk. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. 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://ewawszczyk.developpez.com/tutoriel/java/spring/aop/

Introduction AOP (Aspect-Oriented Programming) avec le framework Spring par Eric Wawszczyk

Hello from Spring !

III-C - Le fichier de configuration Spring

Le fichier de configuration initial de Spring : springContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/springbeans-2.5.xsd"> <bean name="monService" class="ew.service.MonService" /> </beans>

Le fichier Spring complt par la configuration AOP : springContext.xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/springbeans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/springaop-2.5.xsd"> <!-- Debut de la configuration AOP --> <aop:config> <aop:pointcut id="servicePointcut" expression="execution(* ew.service.*.*(..))"/> <aop:aspect id="loggingAspect" ref="monLogger"> <aop:before method="logMethodEntry" pointcut-ref="servicePointcut"/> <aop:after-returning method="logMethodExit" returning="result" pointcut-ref="servicePointcut"/> </aop:aspect> </aop:config> <bean id="monLogger" class="ew.aop.MonLogger"/> <!-- Fin de la configuration AOP --> <bean name="monService" class="ew.service.MonService" /> </beans>

Explication de la configuration AOP : <aop:config> ... </aop:config> Dfinit le bloc de configuration AOP <aop:pointcut id="servicePointcut" expression="execution(* ew.service.*.*(..))"/> Permet de dfinir des points d'interception sur les objets. Ici l'expression ew.service.*.* signifie que toutes les mthodes des objets qui sont dans le package "ew.service" seront interceptes. <aop:aspect id="loggingAspect" ref="monLogger"> Les appels aux mthodes seront renvoys vers le bean Spring "monLogger" (classe ew.aop.MonLogger) <aop:before method="logMethodEntry" ...> Avant l'appel (before) de la mthode "hello()", la mthode "MonLogger.logMethodEntry()" est appele
-7Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright Eric Wawszczyk. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. 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://ewawszczyk.developpez.com/tutoriel/java/spring/aop/

Introduction AOP (Aspect-Oriented Programming) avec le framework Spring par Eric Wawszczyk

<aop:after-returning method="logMethodExit" returning="result"...> Apres l'appel (after) de la mthode "hello()", la mthode "MonLogger.logMethodExit()" est appele et le rsultat de la mthode "hello()" lui sera pass en argument. Cette classe contient les 2 mthodes "logMethodEntry()" et "logMethodExit()" qui vont tre appeles par Spring-AOP pour tracer les appels des mthodes interceptes. MonLogger.java
package ew.aop; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.JoinPoint.StaticPart; public class MonLogger { // Cette mthode est appele chaque fois (et avant) qu'une mthode du package ew.service est intercepte public void logMethodEntry(JoinPoint joinPoint) { Object[] args = joinPoint.getArgs(); // Nom de la mthode intercepte String name = joinPoint.getSignature().toLongString(); StringBuffer sb = new StringBuffer(name + " called with: ["); // Liste des valeurs des arguments reus par la mthode for(int i = 0; i < args.length; i++) { Object o = args[i]; sb.append("'"+o+"'"); sb.append((i == args.length - 1) ? "" : ", "); } sb.append("]"); } System.out.println(sb);

// Cette mthode est appele chaque fois (et aprs) qu'une mthode du package ew.service est intercepte // Elle reoit en argument 'result' qui est le retour de la mthode intercepte public void logMethodExit(StaticPart staticPart, Object result) { // Nom de la mthode intercepte String name = staticPart.getSignature().toLongString(); } } System.out.println(name + " returning: [" + result + "]");

III-D - La classe MonLogger III-E - Rsultat

Et excutant le programme, nous obtenons maintenant :
public java.lang.String ew.service.MonService.hello(java.lang.String) called with: ['from Spring !'] Hello from Spring ! public java.lang.String ew.service.MonService.hello(java.lang.String) returning: [Hello from Spring !]

-8Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright Eric Wawszczyk. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. 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://ewawszczyk.developpez.com/tutoriel/java/spring/aop/

Introduction AOP (Aspect-Oriented Programming) avec le framework Spring par Eric Wawszczyk

IV - AOP : Fonctions avances IV-A - Les pointcut

Les mthodes interceptes sont dfinies dans la balise <aop:pointcut> par l'attribut expression : <aop:pointcut expression="..."/> Voici quelques exemples d'expression courantes pour un pointcup : execution(public * *(..)) : Toutes les mthodes public execution(* set*(..)) : Toutes les mthodes commencant par 'set' execution(* com.xyz.service.IAccountService.*(..)) : Toutes les mthodes de l'interface 'IAccountService' execution(* com.xyz.service.*.*(..)) : Toutes les mthodes du package 'com.xyz.service' execution(* com.xyz.service..*.*(..)) : Toutes les mthodes du package 'com.xyz.service' et de ses souspackages

Les diffrents types d'advice sont : Before advice: Excut avant le join point. After returning advice: Excut aprs le join point (Si la mthode intercepte s'excute normalement - sans retourner d'exception). After throwing advice: Excut si la mthode intercepte retourne une exception. After (finally) advice: Excut en sortie du join point (excution normale de la mthode ou sortie en exception). Around advice: Il englobe l'excution de la mthode intercepte. Il s'agit du plus puissant des advices. Il permet de paramtrer le comportement avant et aprs excution de la mthode. Il permet ainsi d'excuter ou non la mthode, de dfinir le retour souhait, voir de lancer une exception.

IV-B - Les diffrents Advice

-9Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright Eric Wawszczyk. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. 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://ewawszczyk.developpez.com/tutoriel/java/spring/aop/

Introduction AOP (Aspect-Oriented Programming) avec le framework Spring par Eric Wawszczyk

V - Conclusion
Grce l'AOP, le couplage entre les modules grant des aspects techniques peut tre rduit de faon trs importante, en utilisant ce principe, ce qui prsente de nombreux avantages : Maintenance accrue : les modules techniques, sous forme d'aspect, peuvent tre maintenu plus facilement du fait de son dtachement de son utilisation, Meilleure rutilisation : tout module peut tre rutilis sans se proccuper de son environnement et indpendamment du mtier ou du domaine d'application. Chaque module implmentant une fonctionnalit technique prcise, on n'a pas besoin de se proccuper des volutions futures : de nouvelles fonctionnalits pourront tre implmentes dans de nouveaux modules qui interagiront avec le systme au travers des aspects. Gain de productivit : le programmeur ne se proccupe que de l'aspect de l'application qui le concerne, ce qui simplifie son travail, et permet d'augmenter la paralllisation du dveloppement. Amlioration de la qualit du code : La simplification du code qu'entrane la programmation par aspect permet de le rendre plus lisible et donc de meilleure qualit.

V-A - Avantages
Le tissage d'aspect qui n'est finalement que de la gnration automatique de code insr certains points d'excution du systme dvelopp, produit un code qui peut tre difficile analyser (parce que gnr automatiquement) lors des phases de mise au point des logiciels (dboguage, test). Mais en fait cette difficult est du mme ordre que celle apporte par toute dcomposition non linaire (fonctionnelle ou objet par exemple).

V-B - Inconvnients

- 10 Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright Eric Wawszczyk. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. 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://ewawszczyk.developpez.com/tutoriel/java/spring/aop/

Introduction AOP (Aspect-Oriented Programming) avec le framework Spring par Eric Wawszczyk

VI - Remerciements
Merci ma socit Webnet pour m'avoir laiss du temps pour rdiger cet article. Merci RideKick pour sa relecture.

- 11 Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright Eric Wawszczyk. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. 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://ewawszczyk.developpez.com/tutoriel/java/spring/aop/

Introduction AOP (Aspect-Oriented Programming) avec le framework Spring par Eric Wawszczyk

VII - Liens
Les sources du tutoriel Dfinition de la programmation oriente aspect Introduction au framework Spring Spring : thorie & pratique - Programmation oriente aspect Aspect Oriented Programming with Spring

- 12 Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright Eric Wawszczyk. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. 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://ewawszczyk.developpez.com/tutoriel/java/spring/aop/