programmation orientee aspect 201401 - ensim
DESCRIPTION
Introduction aux bases de données NoSQL faite pour l'Ensim (Ecole Nationale Supérieure d'Ingénieurs du Mans), niveau Master. Introduction à la Meta-programmation puis présentation de l'AOP et de ses cas d'usage. Détails sur AspectJ permettant d'implémenter en Java les principes AOP.TRANSCRIPT
Méta-programmation&
ProgrammationOrientée Aspect
Laurent Broudoux (@lbroudoux) | Janvier 2014
Quelques mots...
Laurent Broudoux
Le jour ...
Architecte IT Senior chez MMA
Mots-clés : Java, SOA, Agile, Software factories
La nuit …
Coder, geek, open source comitter (voir http://github.com/lbroudoux)
Me joindre / suivre
@lbroudoux
http://lbroudoux.wordpress.com
Comprendre...
ProgrammationMéta
?????????
Que sont les Métadonnées ?
● Des données à propos d'autres données ou des données décrivant d'autres données
– Structurale (conjoint à la création de la donnée)● Type● Valeurs possibles● Relations avec d'autres données● Objectifs
– Descriptives (après la création de la donnée)● Conditions de création● Contexte d'existence● Etc ...
Comment définir des Métadonnées ?
● De façon implicite
– En suivant des conventions
● De façon explicite
– A l'extérieur du code● Configuration : XML, YML, …
– A l'intérieur du code● Commentaires
– Javadoc (@author, @version, @since, ...)
● Code lui-même– Meta tags HTML (<meta name=''author'' content=''L. Broudoux''>)– Annotations Java (@Override, @Deprecated, …)– Domain Specific Language pour les langages dynamiques
Méta Programmation ?
● Ecriture de programmes qui écrivent ou manipulent d'autres programmes ou eux-même en se basant sur des métadonnées.
« It is about programming at the meta level, that is about changing your interpreter or changing how code is compile »
- Ralph E. Johnson
Bénéfices
● Lors de la conception
– Modularité● Séparation des préoccupations
– Evolutivité● Lors du développement
– Gain de productivité, temps ● En évitant le code boiler plate
– Minimisation du LOC
– Simplicité
Un process pour la Méta-programmation
Définition des Méta-données
Comment exprimer les Métadonnées ?Sous quel forme (implicite vs explicite, externe vs interne) ?
Processing des Méta-données
Comment extraire, récupérer les Métadonnées associées au programme courant ?
Interprétation des Méta-données
Comment opérer des transformations du programme courant en fonction des Métadonnées trouvées ?
Un exemple d'application (i)
● Soit une méthode permettant de retrouver les utilisateurs ayant le même prénom …
– Imaginons la intégrée dans une classe DAO
Un exemple d'application (ii)
● On désire maintenant ajouter une méthode permettant de retrouver les utilisateurs ayant le même nom …
– Imaginons la intégrée dans la même classe DAO
Quelles différences ?
Un exemple d'application (iii)
● En mettant en œuvre les principes de la Méta-programmation, on peux imaginer ne plus avoir à écrire ces méthodes !
● On décide d'une convention permettant de faire la correspondance …
… on implémente la transformation nécessaire pour ajouter ces fonctions !
Outils pour implémenter
Principalement en Java ...
Un processus pour la Méta-programmation
Définition des Méta-données
Processing des Méta-données
Interprétation des Méta-données
Comment exprimer les Métadonnées ?Sous quel forme (implicite vs explicite, externe vs interne) ?
Comment extraire, récupérer les Métadonnées associées au programme courant ?
Comment opérer des transformations du programme courant en fonction des Métadonnées trouvées ?
Conventions
● La façon la plus simple est de définir des conventions : de nommage ou de localisation.
● Attention : le bon respect de ces conventions ne peut souvent pas être vérifié !!
● Exemples :
– Nommage du test case de Foo : FooTest
– Nommage des méthodes liées à la persistance d'objets : save(), update(), delete(), findAll(), findBy*(), …
– Localisation des classes persistantes dans /grails-app/domain pour Grails
Définition des Méta-données
On nomme cette approche « Convention Over Configuration »
Paramétrage Externe
● On décrit dans un fichier annexe des propriétés, comportements ou contraintes supplémentaires d'éléments de l'application.
● Exemples :
– ejb-jar.xml pour EJB
– routes.rb pour RoR
Définition des Méta-données
Annotations Java
● Depuis Java 5, le langage offre la possibilité de définir ses propres annotations
● Une annotation se définit dans un fichier .java avec le mot clé @interface
Définition des Méta-données
Cible : une classe, une méthode, un champs
Rétention : seulement dans le source, dans le bytecode mais non accessible, dans le bytecode et accessible
Attributs : éléments de configuration des méta-données portées par l'annotation.
Annotations Java
● Une annotation s'applique en important simplement la classe correspondante et en utilisant le marqueur @<Mon annotation> avant l'élément visé (classe, méthode ou champs)
Définition des Méta-données
Domain Specific Language
● Dans le cadre des langages dynamiques, on peut utiliser des DSL directement embarqués dans le code mais en dehors de la partie algorithmie.
● Exemples :
– Contraintes dans Groovy/Grails
– Règles de routage dans RoR
Définition des Méta-données
Un processus pour la Méta-programmation
Définition des Méta-données
Processing des Méta-données
Interprétation des Méta-données
Comment exprimer les Métadonnées ?Sous quel forme (implicite vs explicite, externe vs interne) ?
Comment extraire, récupérer les Métadonnées associées au programme courant ?
Comment opérer des transformations du programme courant en fonction des Métadonnées trouvées ?
Réflexivité et chargeurs declasses● Pour les conventions de nommage, les APIs de
réflexivité sont vos amies !
– Packages java.lang.reflect en Java
– Classes groovy.lang.MetaClass et groovy.lang.ExpandoMetaClass en Groovy
– Méthodes instance_variables(), instance_methods() et respond_to ?() en Ruby
● Pour les conventions de localisation, les chargeurs de classes sont vos amis !
– URLClassLoader sur les langages de la JVM
– Directives require en Ruby ou Python
Processing des Méta-données
Annotations Java
● Au runtime
– Depuis Java 5, il est possible de récupérer programmatiquement les annotations d'un objet
Processing des Méta-données
Annotations Java
● Au build time
– Depuis Java 6, il est possible de récupérer programmatiquement les annotations d'un objet pendant la compilation en créant un AnnotationProcessor.
● Il est alors possible d'interagir avec les messages de diagnostic du compilateur et enchaîner d'autres actions ...
Processing des Méta-données
Un processus pour la Méta-programmation
Définition des Méta-données
Processing des Méta-données
Interprétation des Méta-données
Comment exprimer les Métadonnées ?Sous quel forme (implicite vs explicite, externe vs interne) ?
Comment extraire, récupérer les Métadonnées associées au programme courant ?
Comment opérer des transformations du programme courant en fonction des Métadonnées trouvées ?
Proxy dynamique Java
● Le principe :
– Le proxy est un objet généré dynamiquement par la JVM afin d'être vu comme implémentant 1 ou plusieurs interfaces,
– Le proxy ne porte pas d'implémentation, il délègue le tout à un InvocationHandler
– L'InvocationHandler peut agir en tant que « décorateur » d'un autre objet wrappé
Interprétation des Méta-données
Client ProxyInvocation
HandlerCible
Vu comme un seul objet implémentant une ou plusieurs interfaces
Proxy dynamique Java
● L'utilisation
– On implémente l'interface java.lang.reflect.InvocationHandler
– On appelle la méthode newProxyInstance() sur la classe java.lang.reflect.Proxy en en fournissant les interfaces devant être implémentées et l'invocation handler
– C'est tout !
Interprétation des Méta-données
Proxy dynamique Java
● Une des fonctions les plus puissantes de la JVM !
● Avec les proxies dynamiques, on peut implémenter :
– Des politiques de sécurité pour l'accès aux objets,
– La transparence des communications réseaux entre objets,
– Des applications utilisant multiples versions incompatibles de la même librairie,
– Toutes les transformations de comportement possibles et imaginables pour un programme !
Interprétation des Méta-données
Transformations complètes
● Modification de la structure du code
– Abstract Syntax Tree (AST) dans les langages dynamiques
– Ajout / modification de comportements
– Modification de hiérarchies de classes (voir gestion de pseudo héritage multiple même en Java)
● Modification directe du bytecode
– Application du principe des proxies dynamiques aux classes
● Voir ASM, CGLib ou Javassist
Interprétation des Méta-données
Orientée AspectProgrammation
ou Aspect Oriented Programming
Programmation Orientée Aspect
« La Programmation Orientée Aspect est un paradigme de développement qui vise à augmenter la modularité en permettant de traiter de façon indépendante les cross-cutting concerns (préoccupations secondaires ou orthogonales) »
- Gregor Kiczales, 1990s
Cross-cutting concerns (i)
« Lorsque qu'un client valide un panier, il faut vérifier que le contenu est disponible et sauvegarder la commande en base. »
Expert métierVentes
Cross-cutting concerns (ii)
« Lorsque le panier est validé, il faut vérifier que l'on dispose bien d'un client correctement identifié / loggé »
Expert Sécurité
Cross-cutting concerns (iii)
« A chaque validation de panier, je veux tracer l'appel pour connaître : les performances, les erreurs potentielles, ... »
Exploitant
Cross-cutting concerns (iv)
« Quand je valide un panier, il faut mettre à jour les stocks »
Expert métier Approvisionnement
Cross-cutting concerns (v)
« Les 2 systèmes Vente et Approvisionnement doivent être cohérents »
Expert SI
Quelle proportionde ce code dédiéeà la préoccupation
principale ?
TX
Cross-cutting concerns (vi)
● Quelles autres réponses purement objet ?
– Traiter par hiérarchie de classes ?● TxCart < StockCart < TracableCart < SecuredCart < Cart ?
● Réponses de l'AOP
– Gérer chaque concern indépendamment et fusionner le tout dans une étape d'assemblage !
Vente (Cart)
Appro (Stock)
Vente (Cart)
Securité
Traces
weavingSources
Application
AspectJ
● Première implémentation Java des principes de l'AOP. Provient du centre de recherche de Xerox. Version 1.0 en 2002.
● AspectJ est une extension du langage Java gérée par la fondation Eclipse (voir http://www.eclipse.org/aspectj)
● AspectJ implémente le weaving en faisant de la réécriture de bytecode. 4 types de weaving :
– Compile-time : le code source de l'application et celui du langage aspect sont fusionnés avant d'être transformé en bytecode
– Link-time : la fusion se passe après la production de bytecode pour le langage primaire et le langage aspect
– Load-time : la fusion de bytecode se passe lors du chargement par le ClassLoader
– Run-time : la JVM est responsable de la détection et l'exécution des aspects
AspectJ - exemple
● HelloWorld AOP style !
TraceAspect.aj
AspectJ – concepts principaux
● Join point
– Un « point » d'exécution prédictible d'une application● Pointcut
– Une expression permettant d'identifier des join points au sein d'un programme
● Advice
– Du code extérieur à exécuter quand un join point est atteint dans le code de l'application
● Inter-type declaration
– Un mécanisme permettant d'ajouter des attributs ou des méthodes à des classes précédemment définies
● Aspect
– Une structure analogue à une classe qui encapsule join points, pointcuts, advices et inter-type declaration.
AspectJ – Join points
● Notion la plus importante du paradigme : un « point » clairement défini dans l'exécution d'un composant.
a a.b
1
3
4
5
7
6
2
8
910 11
1213
A a = new A();
a.a();
AspectJ – Pointcuts (i)
● Exemples
Designator Description
execution Matche l'exécution d'une méthode ou d'un constructeur
call Matche l'appel d'une méthode ou d'un constructeur
initialization Matche l'exécution du premier constructeur de la classe
handler Matche les exceptions levées
get Matche la référence à un attribut de classe
set Matche l'assignation d'un attribut de classe
this Retourne l'objet associé à un join point particulier ou restreint la portée d'un join point en spécifiant un type de classe
target Retourne l'objet cible d'un join point ou restreint la portée d'un join point
args Expose les arguments d'un join point ou restreint la portée d'un join point en spécifiant des arguments
cflow Retourne les join points dans le flux d'exécution d'un autre join point
cflowbelow Retourne les join points dans le flux d'exécution d'un autre join point sans inclure le join point courant
AspectJ – Pointcuts (ii)
● Quelques exemples ...
Expression Commentaire
pointcut allStringMethods(String str) : call(public * HelloWorld.*(..) && args(str))
Matche toutes les méthodes publics de HelloWorld ayant 1 argument de type String. L'argument est récupéré pour utilisation dans l'advice
pointcut construct() : initialization(new(..))
Matche les constructeurs de tous les objets dans le système !
pointcut constructRoleList() : initialization(RoleList.new())
Matche le constructeur de la classe RoleList et de tous ses ascendants (ArrayList, AbstractList, List)
pointcut userFirstname(User user) : execution(public String getFirstname()) && this(user)
Matche la méthode getFirstname() et rend disponible l'objet courant de l'invocation disponible pour l'advice
poincut handle(UserNotFoundException e) : handler(UserNotFoundException) && args(e)
Matche le lancement d'une exception donnée par n'importe quelle méthode. Rend accessible l'exception pour l'advice.
pointcut getB() : call(* * B.getB());pointcut a() : call(public void A.a());pointcut getBInA() : getB() && cflow(a()) ;
Matche l'exécution de la méthode getB() seulement lorsque appelée depuis la méthode a()
AspectJ – Advices (i)
● Référence
Advice Description
before S'exécute avant le join point désigné.A utiliser pour tout ce qui concerne l'insertion de pré-conditions ou garantir l'initialisation d'objets (ouverture de connexion DB, etc ...)
after S'exécute après le join point désigné.A utiliser pour tout ce qui concerne les post-conditions, les opérations de filtrages ou garantir la libération de ressources (fermeture connexion)
after returning Même chose que after. Permet en plus de garantir que le join point visé s'est exécuté avec succès.
after throwing Même chose que after. Permet en plus de garantir que le join point visé s'est achevé en lançant une exception.
around Remplace l'exécution du join point désigné.A utiliser lorsque l'on veut conditionner l'exécution d'un join point ou complètement remplacer son exécution.
AspectJ – Advices (ii)
● Eléments disponibles dans les advices
– thisJoinPoint : attribut permettant d'accéder aux détails du join point courant (déclaration et instance)
– thisJoinPointStaticPart : attribut permettant d'accéder aux détails de déclaration du join point courant
– proceed() : méthode permettant de lancer l'exécution du join point courant
AspectJ – Inter-type Declarations
● Les ITDs permettent :
– l'ajout d'attributs ou de méthode à une classe,
– L'ajout de comportement via la modification de la hiérarchie d'héritage ou d'implémentation.
Après compilation et weaving, la classe User implémente l'interface Comparable. Il est donc possible d'invoquer la méthode compareTo() sur les instances de User.
AspectJ – Aspect
● Un aspect est simplement la structure permettant de regrouper les éléments vus précédemment et présentant une certaine cohérence
● Dans AspectJ, on décrit un aspect : soit dans un fichier .aj, soit dans une classe Java annotée avec @Aspect
● Cycle de vie d'un Aspect
– Par défaut, les aspects sont des singletons. On ne peut donc pas leur faire porter d'état !
– Il est possible de forcer la création d'un Aspect par objet en utilisant la directive perthis(this(obj))
– Il est possible de forcer la création d'un Aspect par flux en utilisant la directive percflow(<pointcut>)
Quelques usages de l'AOP
● Gestion de toute la « machinerie » technique : sécurité, transactions, connexions réseaux et base de données, serialization...
● Gestion des préoccupations liées au diagnostique : log et traces, mesures de performances, exception handling particulier, …
● Gestion de toute la « machinerie » objet : getters et setters, toString(), equals(), …
● Déploiement de patch : nouveaux advices venant remplacer les précédents !
● Assemblage de métiers différents : vente et approvisionnement, vente et connaissance client, ...
Points clés● Les primitives de méta-programming s'organisent selon 3 phases :
– Définition de méta-données,
– Processing de méta-données,
– Interprétation de méta-données et transformation de programme.
● Assemblons ces primitives et imaginons :
– L'usage d'annotations Java ou le respect de conventions de nommages en phase de développement,
– L'interception par un processeur lors de la compilation qui génère lui-même des aspects,
– Aspects qui peuvent alors être fusionnés pour enrichir les composants produits ...
● … tout en conservant un code initial clair, léger et orienté vers l'objectif métier du composant !
Merci !