POA Programmation Orientée Aspect Frameworks et Langages

1. Génie Logiciel Avancée POAProgrammation Orientée AspectFrameworks et Langages Travail Réalisé par : (GL5 2005-2006) MAALEJ Mahmoud KHELIL Mohamed Khaled

2. Sommaire • Programmation Orientée Aspect(Principe) • AspectJ • Jac (UMLAF) • AspectWerkz • .NET • Attribute et Intercepteur • Aspect C# • Jboss aop

3. Programmation Orientée Aspect(Principe)

4. 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.

5. Aspect Oriented Programming • Application basée sur l’orientée objet : • Divers classes • Chacune des classes possède son propre code

6. 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

7. 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!

8. Aspect Oriented Programming pointcuts : points spécifiques de l’application où du code non fonctionnel peut être appelé

9. 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

10. 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

11. Aspect Oriented Programming Logger.log(‘SEVERE’, infos_wrappee); • Code non fonctionnel séparé • Géré par l’environnement

12. É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.

13. Étapes de Développement d'une Application Orientée Aspect2

14. 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.

15. Avantages Promis par la Programmation Orientée Aspect2 • 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.

16. 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.

17. 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.

18. 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é)

19. 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).

20. 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.

21. 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); }

22. 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.

23. 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.

24. JACJava Aspect ComponentLe Framework de Programmation Orienté Aspect

25. 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.

26. 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)

27. Coupe transversale , points de jonction

28. Code final Aspect JAC(illustration) Chargeur Dynamique J A C conception

29. Code final Code final Aspect Aspect JAC(illustration) Chargeur Dynamique J A C Chargement dynamique et modification du byte code à la volée runtime

30. Code final Aspect JAC(illustration) Interception d’un pointcut Et appel du wrapper correspondant Chargeur Dynamique J A C runtime

31. Code final Aspect JAC(illustration) Chargeur Dynamique J A C Logger.Log(‘SEVERE’,methode) runtime

32. 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

33. 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.

34. 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)

35. (Exemple)Définition de l’aspect et du pointcut

36. (Exemple)Définition du Wrapper

37. (Exemple)Configuration du descripteur de tissage .JAC

38. (Exemple)Configuration de l’aspect

39. Avantages et Inconvénients +Facilité de déploiement Gain de temps Services techniques simples Réutilisation facilitée et rapide du code - Propre seulement à Java Outil Instable Non standardisé ( POUR LE MOMENT)

40. AspectWerkz

41. 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 »

42. 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 »).

43. 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.*(..)) »/>

44. 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) »>

45. 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+) »/>

46. 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 »/>

48. Programmation Orientée Aspect avec plate-forme .net Est ce Possible?

49. Technique d’implémentations concrètes de l'AOPdans .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)

50. Première solution reposant uniquement sur le FRAMEWORK .NET