- Programmation Orientée Aspect
-
Programmation orientée aspect
La programmation orientée aspect (POA, en anglais aspect-oriented programming - AOP) est un paradigme de programmation qui permet de séparer les considérations techniques (aspect en anglais) des descriptions métier dans une application. Par exemple, le principe de l'inversion de contrôle (en anglais, inversion of control, IOC) peut être implémentée par cette méthode de programmation.
La programmation orientée aspect est une technologie transversale et n'est pas liée à un langage de programmation particulier mais peut être mise en œuvre aussi bien avec un langage orienté objet comme Python qu'avec un langage impératif comme le C, le seul prérequis étant l'existence d'un tisseur d'aspect pour le langage cible (cf. § Tisseurs d'aspects)
Sommaire
Historique
Les concepts de la programmation orientée aspect ont été formulés par Gregor Kiczales et son équipe, qui travaillait alors pour le Xerox PARC.
Limites technologiques
Les techniques actuelles de conception logicielles et de programmation amènent à découper un logiciel en modules logiciels a priori indépendants les uns des autres car gérant des aspects différents du système conçu. Certains de ces modules implémentent soit des tâches métier, soit des tâches plus applicatives comme l'authentification des utilisateurs ou encore offrant des services techniques comme la génération de trace ou le multi-threading. Ces modules représentent alors au même niveau d'abstraction, différentes considérations (différents aspects) d'une application, le plus souvent celui de la couche métier.
Exemples de modules :
- gestion des utilisateurs (authentification),
- archivage des données (persistance),
- programmation concurrentielle (multi-threading),
- information pendant l'exécution du logiciel (trace),
- logique métier (par exemple informatique de gestion, système d'information géographique, commerce électronique, ...)
- etc.
Dans la pratique, les considérations techniques que sont censés implémenter les modules non seulement s'entrecroisent (par exemple la gestion des utilisateurs fait aussi appel à la génération de trace) mais sont de plus réparties dans la couche métier : c'est l'intrication ou entrecroisement des aspects techniques (crosscutting en anglais). Ainsi, une couche logicielle, initialement dédiée à gérer la logique métier applicative (par exemple un système bancaire), va se retrouver dépendante de modules gérant les aspects transactionnels, journalisation, etc., conduisant à une complexification du code, de son développement et de sa maintenance.
La programmation par aspect va permettre d'extraire les dépendances entre modules concernant des aspects techniques entrecroisés et de les gérer depuis l'extérieur de ces modules en les spécifiant dans des composants du système à développer nommés « aspects » ; ils sont développés à un autre niveau d'abstraction.
Principe
Ainsi, au lieu d'avoir un appel direct à un module technique depuis un module métier, ou entre deux modules techniques différents, en programmation par aspect, le code du module en cours de développement est concentré sur le but poursuivi (la logique bancaire, pour reprendre notre exemple) , tandis qu'un aspect est spécifié de façon autonome, implémentant un aspect technique particulier, par exemple la persistance ou encore la génération de trace. Un ensemble de points d'insertions ou joinpoint en anglais sont ensuite définis pour établir la liaison entre l'aspect et le code métier ou un autre aspect. Ces définitions de joinpoint sont définis dans le cadre de la POA. Selon les frameworks ou les langages d'aspects, la fusion du code technique avec le code métier est alors soit réalisée à la compilation, soit à l'exécution.
Bien sûr, si chaque aspect créé devait lui-même définir explicitement à quel point d'exécution il doit s'insérer dans le code métier ou dans un autre aspect, c’est-à-dire par exemple avec une dépendance directe vers le module métier où devra s'intercaler le code technique, on n'aurait alors fait que décaler le problème. Aussi, l'astuce particulière de la programmation par aspect consiste à utiliser un système d'expressions rationnelles pour préciser à quels points d'exécution (en anglais, joinpoint) du système l'aspect spécifié devra être activé.
Exemple / Étude de cas
Un logiciel métier qui décrit un environnement distribué est écrit de manière classique en utilisant une décomposition fonctionnelle ou objet. Au moment du déploiement du système, on s’aperçoit que les machines physiques sur lesquelles le système va tourner ont en fait des caractéristiques hétérogènes (puissance, bande passante, etc.) qui impactent ou modifient les fonctionnalités du logiciel d’origine.
Une approche fréquente consisterait en ce cas à « patcher » le code un peu partout pour adapter le logiciel à son environnent d’exécution réel. Avec les outils de POA on peut facilement spécifier les changements requis SANS toucher au source du code 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 déclaratives.
Un aspect permet donc de spécifier :
- les points d'action (pointcut), qui définissent 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 activés avant, autour de ou après les points d'action définis.
Avantages
Le couplage entre les modules gérant des aspects techniques peut être réduit de façon très importante, en utilisant ce principe, ce qui présente de nombreux avantages :
- Maintenance aisée : les modules techniques, sous forme d'aspect, peuvent être maintenus plus facilement du fait de leur détachement de leur utilisation,
- Meilleure réutilisation : tout module peut être réutilisé sans se préoccuper de son environnement et indépendamment du métier ou du domaine d'application. Chaque module implémentant une fonctionnalité technique précise, on n'a pas besoin de se préoccuper des évolutions futures : de nouvelles fonctionnalités pourront être implémentées dans de nouveaux modules qui interagiront avec le système au travers des aspects.
- Gain de productivité : le programmeur ne se préoccupe que de l'aspect de l'application qui le concerne, ce qui simplifie son travail, et permet d'augmenter la parallélisation du développement.
- Amélioration de la qualité du code : la simplification du code qu'entraîne la programmation par aspect permet de le rendre plus lisible et donc de meilleure qualité.
Inconvénients
Le tissage d'aspect qui n'est finalement que de la génération automatique de code inséré à certains points d'exécution du système développé, produit un code qui peut être difficile à analyser (parce que généré automatiquement) lors des phases de mise au point des logiciels (déboguage, test). Mais en fait cette difficulté est du même ordre que celle apportée par toute décomposition non linéaire (fonctionnelle ou objet par exemple).
Cela dit, une implémentation comme AJDT, basée sur AspectJ, offre des outils sophistiqués qui permettent de passer de façon transparente, en mode déboguage, du code d'une classe à celui d'un aspect.
Lexique
La programmation orientée aspect, parce qu'elle propose un paradigme de programmation et de nouveaux concepts, a développé un jargon bien spécifique qui ne facilite pas la compréhension de ses concepts qui sont, en définitive, simples mais puissants.
- aspect
- un module définissant des greffons et leurs points d'activation ;
- greffon (advice)
- un programme qui sera activé à un certain point d'exécution du système, précisé par un point de jonction ;
- tissage ou tramage (weaving)
- insertion statique ou dynamique dans le système logiciel de l'appel aux greffons ;
- point d'action, de coupure ou de greffe (pointcut)
- endroit du logiciel où est inséré un greffon par le tisseur d'aspect ;
- point de jonction ou d'exécution (join point)
- endroit spécifique dans le flot d'exécution du système, où il est valide d'insérer un greffon. Pour clarifier le propos, il n'est pas possible, par exemple, d'insérer un greffon au milieu du code d'une fonction. Par contre on pourra le faire avant, autour de, à la place ou après l'appel de la fonction.
- considérations entrecroisées ou préoccupations transversales (cross-cutting concerns)
- mélange, au sein d'un même programme, de sous-programmes distincts couvrant des aspects techniques séparés.
Implémentation
Stratégies
Deux grandes stratégies de tissage d'aspects existent :
- le tissage statique par instrumentation du code source ou du pseudo-code machine intermédiaire (bytecode java, IL)
- le tissage dynamique lors de l'exécution du logiciel (implémentée par exemple par JAC)
Tisseurs d'aspects
- En Java :
- AspectJ : Extension du langage Java nécessitant donc une étape de précompilation. Le résultat est toutefois du bytecode Java standard.
- JAC (Java Aspect Components) : Framework 100% Java.
- Spring : Spring AOP
- En C++ :
- En .NET (C#, VB.NET …) :
- En PHP :
- En C :
- En Caml :
- En Python :
- En Common Lisp :
- En Ruby :
Références
- L'article de référence sur l'AOP au Xerox Palo Alto Research Center, Aspect Oriented programming ECOOP 1997
- Renaud Pawlak, Jean-Philippe Retaillé, Lionel Seinturier, Programmation orientée aspect pour Java / J2EE, Eyrolles, 2004, 446 p., ISBN 2212114087
- Ramnivas Laddad, AspectJ in Action: Practical Aspect-Oriented Programming, Manning Publications, 2003, 512 p., ISBN 1930110936
- Russell Miles, AspectJ Cookbook, O'Reilly, 2004, 360 p., ISBN 0596006543
Liens externes
- (fr) AOP, Intérêts et Usages
- (en) AOP Alliance (Java/J2EE AOP standards)
- (fr) Initiation à la programmation orientée aspect
Catégorie : Paradigme de programmation
Wikimedia Foundation. 2010.
