Transcript Aspect - TeamSoftsuite

Génie Logiciel Avancée
POA
Programmation Orientée Aspect
Frameworks et Langages
Travail Réalisé par : (GL5 2005-2006)
MAALEJ Mahmoud
KHELIL Mohamed Khaled
Sommaire
1.
2.
3.
4.
5.
Programmation Orientée Aspect(Principe)
AspectJ
Jac (UMLAF)
AspectWerkz
.NET
•
•
Attribute et Intercepteur
Aspect C#
6. Jboss aop
Programmation Orientée
Aspect(Principe)
Introduction
• La programmation OA est une méthode de programmation
qui permet de séparer l'implémentation de toutes les
exigences, fonctionnelles ou non, d'un logiciel.
• Par rapport à l'orienté objet, cette nouvelle technique
permet aux programmeurs d'encapsuler des comportements
qui affectaient de multiples classes dans des modules
réutilisables.
• La programmation OA permet donc d'encapsuler dans un
module les préoccupations qui se recoupent avec d'autres.
Aspect Oriented Programming
Application basée sur l’orientée objet :
• Divers classes
• Chacune des classes possède son
propre code
Aspect Oriented Programming
Application basée sur l’orientée objet :
• Divers classes
• Chacune des classes possède son
propre code
• Du code non fonctionnel peut venir
‘polluer’ le code métier
• Reconfiguration = recompilation
Aspect Oriented Programming
Application basée sur l’orientée objet :
• Du code non fonctionnel peut venir
‘polluer’ le code métier
• Reconfiguration = recompilation
Logger.log(‘SEVERE’, ‘appel 1’);
Ce n’est pas du
code métier!
Aspect Oriented Programming
pointcuts : points spécifiques
de l’application où du code non
fonctionnel peut être appelé
Aspect Oriented Programming
Aspect =
pointcuts : points spécifiques
de l’application où du code non
fonctionnel peut être appelé
coupe transversale :
ensemble de pointcuts ayant un
rapport entre eux
Aspect Oriented Programming
Aspect =
pointcuts : points spécifiques
de l’application où du code non
fonctionnel peut être appelé
coupe transversale :
ensemble de pointcuts ayant un
rapport entre eux
wrapper : code non
fonctionnel, séparé du code de
l’application
Aspect Oriented Programming
Logger.log(‘SEVERE’, infos_wrappee);
• Code non fonctionnel séparé
• Géré par l’environnement
Étapes de Développement d'une Application
Orientée Aspect
1. La décomposition des éléments du système. Il s'agit donc d'identifier
tous les composants et aspects. On sépare toutes les préoccupations,
qu'elles soient fonctionnelles ou non.
2. L'implémentation de chaque préoccupation. Chaque problématique sera
codée séparément dans un composant ou un aspect.
3. L'intégration du système. Tout langage OA offre un mécanisme
d'intégration appelé le "weaver". Le "weaver", à l'image d'un métier à
tisser, va donc composer le système final sur base des règles et des
modules qui lui ont été donnés.
Étapes de Développement d'une Application
Orientée Aspect
2
Avantages Promis par la Programmation
Orientée Aspect
• l'implémentation séparée des préoccupations permet
d'éviter la duplication du code.
• vu que les modules ne sont pas au courant des
problématiques qui se recoupent, il est plus facile d'ajouter
des nouvelles fonctionnalités au système.
• si on veut plus tard rajouter une exigence non fonctionnelle
comme la synchronisation, il suffit de créer un nouvel
aspect qui s'en occupe, sans toucher au code des
composants existants.
Avantages Promis par la Programmation
Orientée Aspect
2
• La programmation OA découplant les modules, leur
réutilisation en est facilitée.
• Le design du système à implémenter est aussi facilité par
l'OA
• Les programmeurs trouvent plus facilement la cause du
problème en cas de bug dans le code source d'un langage
orienté aspect.
AspecJ
• AspectJ est composé de deux parties:
• une spécification qui décrit la syntaxe et la sémantique du
langage.
• Une implémentation qui vérifie la conformité des codes
sources aux spécifications et les transforme en code exécutable
ou interprétable par une machine.
• AspectJ est en fait une extension à Java.
• Nous pouvons définir des aspects accompagnés de leurs
règles d'intégration.
AspectJ 2
•
AspectJ supporte deux sortes de coupes : les coupes dynamiques et les
coupes statiques.
Les coupes dynamiques rendent possible l’ajout de comportement
à certains points bien définis de l’exécution d’un programme.
-
- Les coupes statiques permettent de modifier la structure d’un
programme (en ajoutant des méthodes, des interfaces, ou en modifiant la
hiérarchie des classes).
•
Ses règles s'expriment sous forme de points de jointure, "pointcuts" et "advice".
•
Un aspect est un mélange de règles AspectJ et d'instructions Java qui modularise une
préoccupation.
•
AspectJ dispose de son propre compilateur qui permet de combiner les composants et les
aspects entre-eux et de convertir le code source obtenu en code interprétable par une machine
virtuelle Java.
Les Points de Jointure
• Les points de jointure désignent des points précis dans
l'exécution d'un programme.
• AspectJ permet de définir les points de jointure suivants :
•
un appel de méthode ou de constructeur (on se trouve dans le contexte de
l'appelant)
• l'exécution d'une méthode ou d'un constructeur (on se trouve dans le
contexte de l'exécution, donc de l'appelé)
Les Points de Jointure 2
−
l'accès en lecture ou écriture d'un champ.
− l'exécution d'un bloc "catch" qui traite une exception Java.
− l'initialisation d'un objet ou d'une classe (càd des membres statiques
d'une classe).
Les PointCuts
• Les pointcuts correspondent à la définition syntaxique d'un
ensemble de points de jointure
• Voici une des formes les plus simples de définition de
pointcut :
pointcut <nom du pointcut> :
call ( <signature de méthode>
Ce pointcut définit tous les points de jointures qui
correspondent à l'appel (call) d'une méthode dont la
signature correspond à <signature de méthode>.
AspectJ permet d'utiliser des caractères génériques intitulé
Wildcards (* et ..) pour identifier un ensemble de points
d'interception de manière concise.
Les Advices
• Un advice est un mécanisme (similaire à une méthode)
utilisé pour déclarer l'exécution de code à tous les points de
jointure d'un "pointcut".
• Il y a trois types d'advice : les "before advices", les "around
advices" et les "after advices".
• L'avantage des advices vient du fait qu'ils peuvent
avoir accès à certaines valeurs du contexte
d'exécution d'un pointcut:
before(Information in): appelTransaction (in) {
log.enregistrer("Tentative transaction:" + in);
}
Les Advices 2
• Ce "before advice" concerne tous les points de
jointure du pointcut appelTransaction. Avant
d'appeler les méthodes désignées par
appelTransaction, on fait appel à
log.enregistrer(…)qui va enregistrer l'argument
in de ces méthodes dans un fichier journal.
Les Aspects
• Un aspect rassemble des pointcuts et des advices
pour former une unité de recoupement.
• Les pointcuts et les advices définissent à eux deux
les règles d'intégration.
• Un aspect est similaire à une classe Java, dans ce
sens où, il contient des champs et des méthodes et
peut même étendre d'autres classes ou d'autres
aspects.
JAC
Java Aspect Component
Le Framework de Programmation
Orienté Aspect
Principe
•
•
•
•
Le projet JAC : compagnie AOPSYS (Renaud Pawlak,
Laurent Martelli) en 2000, open-source.
Modèle de tissage générique d'aspects, wrapping
automatique et dynamique.
développé en java , aucune extension syntaxique du
langage Java
Les Méthodes que contient les objets d’aspects:
des méthodes encapsulantes ,des méthodes de rôle et des
gestionnaires d'exceptions.
Concepts de base
• Point de jonction : c’est une classe , un attribut , une
•
•
•
•
méthode , une structure ou une exception
Coupe transversale: ensemble de points de jonctions ayant
un lien logique entre eux
Méthode d’aspect ou code advice : traitement additionnel
Aspect : coupe transversale + méthode d’aspect associés a
chacun des points de jonction
Encapsulateur ou Wrapper : Objets autonomes dont les
méthode encapsulent les méthodes métier (méthodes
d’aspects)
Coupe transversale , points de
jonction
JAC(illustration)
Code final
Chargeur
Dynamique
J
A
Aspect
conception
C
JAC(illustration)
Code final
Chargeur
Dynamique
Code final
J
A
Aspect
Aspect
runtime
Chargement
dynamique et
modification du byte
code à la volée
C
JAC(illustration)
Chargeur
Dynamique
Code final
Interception d’un
pointcut
Et appel du wrapper
correspondant
J
A
C
Aspect
runtime
JAC(illustration)
Chargeur
Dynamique
Code final
J
A
Logger.Log(‘SEVERE’,methode)
Aspect
C
runtime
COMPOSANTES JAC
• Un environnement de développement UML orienté POA ,
•
•
•
•
•
•
modéliser la logique métier,générer compiler le code Java.
Des aspects prêts à l’emploi et configurables
Un conteneur léger et ouvert pour les classes métier et les aspects
purement techniques.
Un noyau capable de tisser les aspects à la logique métier au
« runtime »
Une interface d’administration permettant de débuguer
l’application et de modifier dynamiquement la configuration des
aspects.
Un serveur d’applications JAVA, orienté Aspect.
Un didacticiel, un guide pour développeurs et des exemples
UMLAF(UML Aspectual
Factory)
-Extensions de notation
UML pour Aspects et coupes
-Outil RAD
-Limité au diagramme de classe
-Écrit en java avec JAC qui utilise les
aspects GuiAC, SessionAC,
PersistenceAC, ConfirmationAC et
IntegrityAC.
Aspects techniques configurables fournis par JAC
Aspects purement techniques fournis dans l’API JAC
• Persistance (SGBD et Systèmes de Fichier)
• Authentification
• Transactions
• Déploiement
• Broadcasting
• Cohérence des données
• Synchronisation
• Accès distant
• Intégrité
• GUI (SWING et Web)
(JAVADOC de JAC)
(Exemple)
Définition de l’aspect et du
pointcut
(Exemple)
Définition du Wrapper
(Exemple)
Configuration du descripteur de
tissage .JAC
(Exemple)
Configuration de l’aspect
Avantages et Inconvénients
+
Propre seulement à Java
Facilité de déploiement
Gain de temps
Services techniques simples
Réutilisation facilitée et rapide
du code
Outil Instable
Non standardisé
( POUR LE MOMENT)
AspectWerkz
AspectWerkz
• Les coupes: pour définir une coupe il propose un fichier de
configuration soit XML, soit javadoc.
• AspectWerkz fournit un ensemble de balises XML et d’attributs pour
définir des aspects comme: (<aspect>, <pointcut> et <advice>.
• Les Aspects: comme ceux d’AspectJ peuvent exécuter, des codes
advice de types « before », « after » et « around »
• Les codes advice d’un aspect sont rassemblés dans une classe
d’aspects qui étend la classe « org.codehaus.aspectwerkz.aspect.Aspect »
Mécanisme d’introspection de point
de jonction
• L’introspection de point de jonction s ’effectue à l’aide de
la classe « org.codehaus.aspectwerkz.joinpoint.JoinPoint »
• L’instance de JoinPoint passée en paramètre aux méthodes
implémentant les codes advice est une référence à un objet
décrivant le point de jonction en cours.
• Les méthodes principales de la classe des introspections:(
« Signature getSignature », «String getType() », « Object
getTargetInstance() », « object proceed »).
Les types de point de jonction
• Les types de jonction fournit par AspectWerkz peuvent concerner des
méthodes, des attributs, des exceptions et des constructeurs
• Pour les méthodes et les constructeurs AspectWerkz autorise deux
types de point de jonction, les appels de méthodes (call) et les
exécutions de méthodes (execution).
• La différence entre les types call et execution concerne le contexte
dans lequel le programme se trouve au moment du point de jonction.
La signature d’une coupe qui intercepte les appels pour les méthodes:
<pointcut name=« coupe » pattern=« call(void aop.aspectwerkz.Order.*(..)) »/>
La signature d’une coupe qui intercepte les appel au constructeur:
<pointcut name=« coupe » pattern=« call(void aop.aspectwerkz.Order.*(..)) »/>
Les types de point de jonction2
• Pour les attributs, les points de jonction de types get et set permettent
d’intercepter respectivement les lectures et écritures d’attributs.
• Ils sont utiles lorsque nous souhaitons implémenter des aspects qui
manipulent l ’état d’un objet.
• Les types get et set sont associés à des expressions qui définissent les
attributs dont nous souhaitons intercepter les accés
• Ces expression comprennent le type de l’attribut, sa classe et son nom:
<pointcut name=« coupe » pattern=«get(Map Order.Items) »>
Les types de point de jonction3
• Pour les exceptions: le type handler permet d’intercepter les débuts
d’exécutions des blocs « catch » et de définir des aspects qui
interviennent lors de la récupération d’exceptions.
• Ce point de jonction peut étre utile pour journaliser dans un fichier les
messages de toutes les exceptions levées par une application.
• La gestion des exceptions dans un aspect permet souvent d’alléger le
traitement des exceptions au sein du programme et le rendant ainsi plus
lisible et plus maintenable.
• L’expression suivante désigne tous les début des blocs catch récupérant
l’exception « java.io.IOException »:
<pointcut name=« coupe » pattern=« handler(java.io.IOException+) »/>
Les codes advice
• Plusieurs codes advices peuvent etre définis dans une classe d’aspects
• Les méthodes de codes advice d’AspectWerkz sont similaires à celles
que nous avons rencontrées dans les frameworks JAC et JBoss AOP.
• AspectWerkz fournit les trois types de codes advice principaux
(before, after, et around)qui sont déclarésdans le fichier
aspectWerkz.xml .
• L’extrait suivant fournit un exemple de définition de code advice pour
chaque type:
<advice name=« beforeAdvice » type=« before » bind-to=« coupe »/>
<advice name=« afterAdvice » type=« after » bind-to=« coupe »/>
<advice name=« aroundAdvice » type=« around » bind-to=« coupe »/>
Programmation Orientée Aspect
avec plate-forme .net
Est ce Possible?
Technique d’implémentations
concrètes de l'AOP
dans .NET
• Ce que l'on appelle Aspect correspond à
l'application d'un ensemble de Conseils
(enrichissements de code ou code advice) à
un ensemble d'éléments du code de base
(typiquement à un ensemble de classes)
Première solution reposant
uniquement sur le
FRAMEWORK .NET
Attributes et intercepteurs .NET
Attributes.net
• Les Attributes.NET: ce sont des marqueurs que l'on place
en en-tête d'une déclaration (de méthode, de classe,
d'attribut, de namespace...) et qui permet de donner à cette
déclaration une sémantique enrichie
• Un attribute hérite de la classe System.Attribute
• les Attributes permettent de repérer des emplacements
particuliers dans le code .NET et d'associer à ce repérage
des méta-données (stockées dans l'Assembly).
• comment installer du code avant et après l'invocation de
méthodes sur une classe ?
• Comment ajouter une méthode à une classe ? Cela est
possible grâce aux intercepteurs .net
Intercepteurs .NET
(Framework .NET Remoting )
• lorsqu'on invoque une méthode sur un objet
héritant de System.ContextBoundObject elle est
transformée en un objet de type IMessage par
l’intermédiaire de deux objets du framework .net
le proxy transparent et le proxy réel, ce message
passe ensuite par un ou plusieurs MessageSink
qui peuvent décider de déclencher du code avant
le transfert du message au suivant, ou après avoir
reçu le message de retour.
Processus d’interception
Framework .NET remoting
Relation du remoting avec la
notion d’intercepteur
• Il suffirait donc d'installer un MessageSink
personnalisé en amont de chaque objet
métier de manière à pouvoir déclencher du
code avant et après l'invocation de
méthodes
Deuxième solution
AspectC#
Un tisseur pour langage C#
ASPECT C#
Une implémentation de l’AOP pour
c#
C’est quoi?
• C’est un tisseur d’aspect (AspectCSharp.exe)
• d'un fichier de configuration XML pour associer
les aspects au code de base
• MAIS il n’offre pas de remplaçant aux joinpoint
(pas d’attribute,pas de delegate……) .Il est
actuellement en version alpha
Exemple HelloWorld AspectC#
Définition de la classe d’aspect
Descripteur de tissage d’aspects
.xml
JBossAOP
Introduction
• JBoss AOP a été conçu et développé par Bill Burke avec la
collaboration de contributeurs, dont Marc Fleury, le CEO
du JBoss Group.
• JBoss AOP peut s’utiliser de façon autonome ou
conjointement avec le serveur d’applications J2EE JBoss.
• Dans le premier cas, la version autonome est appelée
standalone.
• Dans le deuxième cas, à partir de la version 4.0, le serveur
d’applications JBoss inclut en standard le framework
JBoss AOP.
Les coupes
• Avec JBoss AOP, les coupes sont définies dans des fichiers XML.
Chaque application est associée à un fichier XML de définition de
coupe appelé habituellement jboss-aop.xml.
• La balise principale d’un fichier jboss-aop.xml de coupe est <aop>.
Tout fichier de définition de coupe a la structure suivante :
<?xml version="1.0" encoding="UTF-8"?>
<aop>
<bind pointcut=" ... expression de coupe ... " >
<interceptor class=" ... classe d’interception ... " />
</bind>
....
</aop>
Les coupes
• La première ligne est un en-tête standard en XML. Les
définitions de coupe sont comprises entre les balises <aop>
et </aop>.
• La balise <bind> définit une coupe à l’aide d’une
expression fournie par l’attribut pointcut. Un fichier
jbossaop.xml contient autant de balises <bind> qu’il y a de
coupes dans l’application.
• À l’intérieur d’une balise <bind> la balise <interceptor>
définit l’intercepteur associé à la coupe.
Les types de coupes
• JBossAOP permet de définir cinq types de coupes : exécution de
méthode, constructeur, attribut, classe et appel de méthode.
• Chacun de ces types est associé à un mot-clé différent dans
l’expression de coupe (attribut pointcut de la balise <bind>).
• La structure type d’une expression de coupe est donc la
suivante :
<bind pointcut="mot-clé(signature)" >
• Des wildcards peuvent être utilisés dans les signatures de méthodes. Il
est ainsi possible d’inclure plusieurs méthodes dans une même coupe.
De façon similaireà ce que propose AspectJ, JBoss AOP utilise les
wildcards étoile (*) et pointpoint (..).
Les types de coupes 2
• Le type exécution de méthodes: Il se définit avec le mot-clé
execution. Le mot-clé est associé à une expression formée par un
signature contenant éventuellement des wildcards : toutes les méthodes
dont la signature vérifie l’expression sont inclues dans la coupe, par
exemple l’expression suivante :
>
<bind pointcut="execution(public aop.jboss.Order- new(..))" >
• Le type attribut: Les coupes de type attribut concernent les lectures
et les écritures d’attributs, Trois mots-clés sont fournis par JBoss AOP :
get, set et field. Le premier désigne les opérations de lecture
d’attributs, le deuxième les écritures et le troisième à la fois les lectures
et les écritures, par exemple l’expresion suivante:
<bind pointcut="set(private * aop.jboss.Order->articles)" >
Les types de coupes 3
•
Le type classe:Les
coupes de type classe regroupe les trois types vus
précédemment : exécution de méthodes, constructeur et attribut. Tous les
points de jonction de ces trois types sont donc inclus dans les coupes de
type classe.
• Celles-ci se déclarent à l’aide du mot-clé all associé à un nom de classe
pouvant contenir un ou plusieurs wildcards *. Par exemple, l’expression
suivante :
<bind pointcut="all(aop.jboss.O*)" >
•
Le type appel de méthode: Le
dernier type de coupe fourni par JBoss AOP
concerne les appels de méthodes. Il s’agit donc d’inclure dans la coupe tous
les points de jonction qui correspondent à l’appel d’une ou de plusieurs
méthodes.
• Ce type de coupe se déclare à l’aide du mot-clé call associé à une signature
de méthode pouvant contenir des wildcards. Par exemple, la coupe suivante
:
<bind pointcut="call(* aop.jboss.Order->*(..))" >
Les intercepteurs
• Les intercepteurs JBoss AOP s’écrivent en Java dans des classes qui
doivent implémenter l’interface org.jboss.aop.advice.Interceptor.
• Les deux méthodes suivantes sont définies dans cette interface :
· getName : retourne le nom de l’intercepteur. Le nom est choisi
librement par le développeur.
· invoke : définit le code à exécuter avant et après un point de
jonction.
• De ces deux méthodes, invoke est la plus importante. C’est la méthode
invoquée par le framework JBoss AOP juste avant un point de jonction
associé à l’intercepteur.
Les intercepteurs 2
• La signature de la méthode invoke est imposée. Elle accepte
un seul paramètre de type org.jboss.aop.joinpoint.Invocation.
Comme nous le verrons à le code suivant, ce paramètre
permet de faire de l’introspection de point de jonction.
import org.jboss.aop.advice.Interceptor;
import org.jboss.aop.joinpoint.Invocation;
public class MyInterceptor implements Interceptor {
public String getName() { return "unNom"; }
public Object invoke(Invocation invocation) throws Throwable {
System.out.println("Code avant");
Object rsp = invocation.invokeNext();
System.out.println("Code après");
return rsp;
}}
Les intercepteurs 3
• Dans un intercepteur, l’appel de la méthode invokeNext permet de
délimiter les parties de code qui s’exécutent avant et après le point de
jonction.
•
La méthode invokeNext doit être appelée sur l’objet de type
Invocation passé en paramètre de la méthode invoke.
• La méthode invokeNext joue pour JBoss AOP le même rôle que
proceed pour AspectJ et JAC.
• La méthode invoke retourne une valeur de type Object. Ce type
correspond à la valeur retournée par le code du point de jonction. Il est
nécessaire de propager cette valeur à l’appelant.
Conclusion
Questions?