Renaud Pawlak et l'équipe de développement de JAC

L'AOP (Aspect-Oriented Programming, Programmation Orientée Aspect) a été définie par Gregor Kickzales (du Xerox) en 1996. Tout comme la programmation structurée et la programmation orientée objet ont, dans leur temps, introduit de nouvelles approches pour concevoir les programmes et un ensemble de règles et de conventions pour aider les programmeurs à produire du code plus lisible et plus réutilisable (erradication des "gotos" au profit des boucles, introduction des types et des structurations modulaires autour des classes), l'AOP est une philosophie de programmation qui est essentiellement une question de style. L'AOP résout donc des problèmes qui peuvent être traités dans des approches classiques, mais d'une manière plus élégante. Pour comprendre l'esprit de l'AOP, il est indispensable de bien comprendre les trois points suivants.

JAC fournit un ensemble de concepts de programmation dérivés de l'AOP et qui permettent au programmeur d'implanter l'inversion des dépendances de façon propre.

Voici une classe métier qui fait des calculs simples:

public class Calcul {
    int value=0;
    public void add(int toadd) {
        value+=toadd;
    }
    public void sub(int tosub) {
        value-=tosub;
    }
}

Imaginons maintenant que, pour cette application, l'attribut "value" ne prenne pas de valeurs négatives. Ce sera aussi le cas pour d'autres classes du programme car, dans ce métier, on n'aime pas les valeurs négatives. On se trouve alors devant un problème d'organisation du programme car le test (inférieur à 0) risque de devenir ce qu'on appele "transverse" (en d'autres mots, il n'est pas purement fonctionnel et risque à terme de polluer le code applicatif).

Avec l'AOP, j'ai la possibilité d'externaliser ce code en programmant un composant d'aspect:

01> public class TestAC extends AspectComponent {
02>     public TestAC() {
03>         pointcut( "Calcul", "sub", LimiterWrapper.class, "limit" );
04>     }
05>     public class LimiterWrapper extends Wrapper {
06>         public void limit(Interaction i) {
07>             if(((Integer)getFieldValue(i.wrappee,"value")).intValue()
08>                    - ((Integer)args[0]).intValue() < 0 )
09>                 throw new Exception("<0 forbidden");
10>             proceed();
11>        }
12>        ...
13>}   }

C'est plus compliqué que de rajouter une ligne de code mais, à terme et pour les programmes complexes, le bénéfice est énorme... d'autant plus que les aspects dans JAC peuvent être ajoutés ou retirés pendant que l'application tourne (d'où un gain en terme de dynamicité et de maintenance).

Explication du code de l'aspect:

JAC présente deux niveaux de détails pour utiliser les aspects.

Pour finir, JAC fournit aussi un ensemble d'aspects et un environnement pour la distribution (déploiement, communications distantes, sessions, authentification, interface web). Tous les aspects fonctionnent aussi bien en centralisé qu'en distribué si bien que l'on peut définir des préoccupations qui ont des influences globales et distribuées. Nous fournissons aussi un ensemble d'aspects permettant de configurer facilement des préoccupations relatives aux protocoles distribués les plus fréquemment rencontrés comme la cohérence, la diffusion ou le load-balancing. Nous espérons que vous trouverez ces aspects utiles pour vos développements!


Renaud Pawlak
Last modified: Tue Dec 3 01:04:41 CET 2002