 |
 |
 |
| 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 :
Généralement le code d'une application peut être regroupé dans deux catégories :
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 :
|
Modèle |
Préoccupation |
Elément |
|
Programmation linéaire |
||
|
Programmation structurée |
Flot de contrôle |
Instructions |
|
Programmation procédurale |
Découper le code en portions |
Fonction, procédure |
|
Programmation orientée objets |
Données sous la forme d'objets |
Classe |
|
Programmation orientée aspects |
Fonctionnalités transverses |
Aspect |
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.
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 :
La mise en oeuvre de l'AOP consiste à :
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 :
Le tissage peut être réalisé de trois manières :
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.
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 :
Les inconvénients sont :
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 :
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.
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 :
Plusieurs implémentations d'AOP sont disponibles pour la plate-forme Java notamment :
|
Implémentation |
URL |
|
AspectJ |
|
|
Spring AOP |
|
|
JBoss-AOP |
|
|
AspectWerkz |
|
|
Java Aspect Components |
|
|
HyperJ |
