66. Programmation orientée aspects (AOP)

Niveau :

Intermédiaire

AOP est l'acronyme d'Aspect Oriented Programming: la traduction française est programmation orientée aspects. AOSD (Aspect Oriented Software Development) est aussi utilisé.

L'AOP a été créée par Gregor Kickzales pour le laboratoire Xerox en 1996. L'AOP propose une façon de mettre en oeuvre certaines fonctionnalités de façon élégante et pratique.

Le développement orienté aspects permet la mise en oeuvre de la séparation des préoccupations (separation of concerns : SOC). Il s'adresse essentiellement à des fonctionnalités transverses.

L'AOP est un type de programmation qui propose de séparer le code technique du code métier d'une application pour des préoccupations transversales qu'elles soient techniques ou architecturales. L'AOP enrichit un modèle de programmation (POO ou procédurale) mais ne le remplace pas.

L'AOP ne remplace donc pas la POO mais la complète en proposant des solutions mises en oeuvre de façon élégante à certaines de ses limitations ou fonctionnalités manquantes. AOP permet de facilement implémenter des fonctionnalités transverses de façon modulaire. Traditionnellement, ces fonctionnalités sont partiellement mises en oeuvre sans AOP en utilisant des design patterns, des frameworks ou des outils (générateurs, précompilateurs).

L'idée principale de l'AOP est de considérer qu'un système est mieux développé lorsque l'implémentation de ses fonctionnalités est séparée notamment celles qui concernent des fonctionnalités techniques et transverses.

Les composants ou entités développés dans une application ont généralement besoin de plusieurs fonctionnalités transverses purement techniques : log, habilitation, gestion de transactions, ... Ces fonctionnalités ajoutent du code dans les traitements ce qui les alourdit.

La programmation orientée aspect propose d'externaliser ces fonctionnalités sous la forme d'aspects.

L'AOP est un concept qui est indépendant de tout langage : il est possible de fournir des implémentations d'AOP dans différents langages.

Ce chapitre contient plusieurs sections :

• Le besoin d'un autre modèle de programmation
• Les concepts de l'AOP
• La mise en oeuvre de l'AOP
• Les avantages et les inconvénients
• Des exemples d'utilisation
• Des implémentations pour la plate-forme Java

66.1. Le besoin d'un autre modèle de programmation

Généralement le code d'une application peut être regroupé dans deux catégories :

• les traitements fonctionnels qui permettent à l'application de répondre aux besoins pour lesquels elle a été développée
• les traitements techniques

Le développement d'applications évolue avec différents modèles de programmation pour faciliter le développement d'applications de plus en plus complexes :

Le but de ces différents modèles est d'améliorer la structuration du code d'une application afin de faciliter son écriture et sa maintenance.

Le développement d'une application en couches permet à chacune de ces dernières d'être dédiée à une activité particulière. Cependant, il existe de nombreux traitements transversaux, généralement purement techniques qui sont utilisés dans les différentes couches.

Aucune méthode de programmation ne propose de solution pour une mise en oeuvre facile et pratique de ces traitements.

La programmation orientée objet ne propose que peut de solutions efficaces pour ce type de traitements : généralement cela passe par des appels à des objets dédiés dans les traitements.

La programmation orientée aspect propose d'externaliser ces traitements dans des entités nommées aspect.

Actuellement, les modules d'une application utilisent du code pour des traitements transversaux : l'AOP permet d'inverser cette dépendance. Aucun code de ces traitements n'est utilisé dans le module. Le code de ces traitements est regroupé dans des greffons qui sont insérés à la compilation ou à l'exécution.

66.2. Les concepts de l'AOP

Des points d'insertions (jointpoints) permettent d'utiliser ces aspects en précisant l'endroit où ils pourront être insérés. Le nombre de jointpoints n'est pas illimité : par exemple, il n'est pas possible d'insérer un greffon dans le code d'une méthode.

Les points de coupes sont des points d'insertions où les greffons seront insérés sans avoir à ajouter de code dans les traitements.

Un tisseur d'aspects permet d'insérer les aspects dans le code de l'application. Un aspect est un traitement particulier qui doit insérer à un ou plusieurs endroits définis par les points de coupe.

L'AOP utilise plusieurs concepts qui lui sont propres :

• point d'exécution (Joinpoint) : aussi appelé point de jonction, c'est un endroit particulier où il est possible d'invoquer un greffon dans le flot des traitements des composants (exemple : appel d'une méthode ou d'un constructeur, exécution d'une méthode, accès à un attribut, ...). Potentiellement n'importe quelle instruction peut être un point d'exécution mais l'AOP propose un sous-ensemble bien défini qui constitue les points d'exécution utilisables
• point de coupe (jointcut) : aussi appelé point d'action ou point de greffe ou point de recouvrement, c'est l'endroit où le greffon sera précisément invoqué lors du tissage. Un point de coupe est un sous-ensemble défini de points de jonctions
• greffon (advice) : aussi appelé perfectionnement, il contient des traitements techniques qui seront insérés à des jointcuts et exécutés
• aspect (aspect) : encapsule une fonctionnalité transverse et est composé d'un ou plusieurs points de coupe et greffons
• tissage (weaving) : action d'insertion des aspects
• tisseur (weaver) : outil qui réalise des tissages des aspects
• inter-type declarations : permet de déclarer de nouveau membres dans une classe

66.3. La mise en oeuvre de l'AOP

La mise en oeuvre de l'AOP consiste à :

• Définir les fonctionnalités
• Implémenter ces fonctionnalités sous la forme d'aspects
• Tisser les aspects pour les intégrer dans le code existant

La mise en oeuvre des aspects dans le code d'une application est réalisée lors d'une opération de tissage (weaving) par un tisseur (weaver)

C'est un tisseur d'aspects qui est responsable de la mise en oeuvre de l'AOP. L'AOP peut donc être mis en oeuvre avec n'importe quel langage qui possède un tisseur d'aspects.

Le tissage d'aspects permet d'insérer du code à des points d'exécution de l'application. Le tissage peut se faire de deux façons :

• statique : le tissage se fait avant l'exécution, généralement à la compilation, ce qui fait que le code exécuté mixe du code de l'application et des aspects. Ceci implique une recompilation en cas de modification ou d'ajout d'aspects mais ce type de tissage est généralement plus performant. (exemple : AspectJ)
• dynamique : l'avantage est qu'il est facilement possible de modifier les aspects (exemple : JAC, JBoss-AOP)

Le tissage peut être réalisé de trois manières :

• A la compilation : lors de la compilation si le compilateur supporte l'AOP ou post compilation avec un compilateur dédié. Cette compilation peut se faire au niveau du code source ou au niveau du bytecode. Dans ce dernier cas, il est possible de tisser n'importe quelle application sans avoir son code source. Il est aussi plus facile d'analyser le bytecode que son code source correspondant
• Au chargement : lors du chargement de la classe avec un classloader dédié
• A l'exécution : en utilisant des mécanismes reposant sur des proxys ou des interceptions

Un tisseur qui agit au niveau du bytecode peut utiliser des bibliothèques dédiées à sa manipulation telles que Byte Code Engineering Library (BCEL), ASM ou Javassist.

66.4. Les avantages et les inconvénients

La programmation orientée aspects possèdent des avantages mais aussi quelques inconvénients dont il faut tenir compte avant de la mettre en oeuvre.

Les avantages sont :

• Facilité de maintenance du code invoquant les traitements car il est épuré des fonctionnalités et des services techniques : le code est allégé et moins emmêlé puisque les fonctionnalités transverses sont regroupées dans les aspects
• Permet de contourner certaines faiblesses de la programmation orientée objet
• Particulièrement adapté pour les fonctionnalités techniques
• Permet une meilleure modularité du code et des applications ce qui augmente la réutilisation du code et la modularité des systèmes

Les inconvénients sont :

• La lecture du code contenant les traitements ne permet pas de connaitre les aspects qui seront exécutés (sans utiliser un outil).
• Nécessite un temps de prise en main
• Pas de normalisation : il existe plusieurs approches et implémentations, chaque implémentation proposant sa propre solution

66.5. Des exemples d'utilisation

L'AOP permet une implémentation modulaire de nombreuses fonctionnalités transverses.

Les utilisations possibles d'AOP sont nombreuses, notamment :

Le logging

Il peut être intéressant de définir des aspects qui vont réaliser des tâches de logging.

Le monitoring

Des aspects peuvent être définis pour obtenir des informations sur l'exécution de certaines méthodes pour par exemple :

• suivre un flot d'exécution
• compter le nombre d'invocations d'une méthode
• calculer des temps d'exécution d'une méthode
• ...

Ces informations peuvent ensuite être agrégées et diffusées pour consultation.

La gestion des exceptions

De nombreuses exceptions sont gérées de la même façon et de façon répétitive. Ces traitements peuvent donc être pour partie pris en charge par AOP, notamment la partie logging de ces traitements.

Le débogage

L'AOP peut permettre l'ajout de traces qu'il sera facile de désactiver.

Le profiling

La persistance

L'AOP peut être utilisée pour exécuter des traitements avant ou après des mises à jour.

La sécurité

L'AOP peut être utilisée pour gérer les habilitations d'accès à une méthode.

Les tests

La gestion des pré-conditions et post-conditions

L'AOP permet facilement la mise en place de pré et post conditions sur une ou plusieurs méthodes.

66.6. Des implémentations pour la plate-forme Java

Malheureusement, l'implémentation de l'AOP n'est pas standardisée : chaque implémentation fournie sa propre syntaxe pour mettre en oeuvre tout ou partie des fonctionnalités de l'AOP.

Il existe donc plusieurs implémentations de l'AOP pour Java qui implémentent tout ou partie des concepts de l'AOP de façon différente.

Les implémentations d'AOP suivent deux approches :

• Une approche généraliste : par exemple AspectJ
• Une approche spécifique : par exemple pour les besoins d'un framework tel que Spring avant sa version 2.0

Plusieurs implémentations d'AOP sont disponibles pour la plate-forme Java notamment :

78 commentaires