Exposé :Aspectj

Université Mohamed Chérif Messadia

ــ Souk-Ahras ــ

Réalisé par:

Daoudi Ilhem

Plan:

1-Introduction.

2-Définition.

3-Implémentation d’un aspect .

4-Les Coupes .

5-Code Advice.

6-Conclustion.

7-Références.

1-Introduction:

• Programmation Oriente Aspect

implique briser la logique du

programme en parties

distinctes appelées soi-disant

préoccupations .

• Voyons dans cet exposé

comment l’outil Aspecj peut

gérer les aspects transversaux

d'une application .

2-Définition:

• Aspectj est une extension orientée aspect, créée pour le langage de

programmation java.

• Aspectj est devenu le standard, du fait de son utilisation répandue,

pour la programmation orientée aspect en mettant l'accent sur la

simplicité et la facilité de mise en œuvre pour les utilisateurs finaux.

• Aspectj se base sur la syntaxe du langage java et s'intègre

aux ide pour afficher sa structure transversale depuis sa première

publication en 2001.

• Télécharger la distribution aspectj de : www.Eclipse.Org/aspectj .

3-Implémentation d’un aspect:• Définir un nouvel aspect est très semblable à créer une nouvelle classe. Le mot-clef

class est juste remplacé par aspect. Dans un aspect nous allons pouvoir définir des

coupes et des codes advice qui induiront les fonctionnalités liées à cet aspect

Exemple 1:

public aspect HelloWorld {

// Coupe :

pointcut mainCall () :

call ( public static void main( String[] args ) );

// Code Advice :

before () : mainCall() {

System.out.println ("Hello world!");

}

}

3-Implémentation d’un aspect :

public class MainHelloWord {

// Point de jonction ( joinpoint ) :

public static void main (String[] args) {

}

}

Au moment de la compilation, le tisseur

d'aspects ajoutera le comportement défini

dans le code advice HelloWorld.aj au

moment de l'appel de la méthode main.

4-LES COUPES :• Une coupe permet de regrouper un ou plusieurs points de jonction.

• Selon le type de point de jonction, le mot clé à utiliser pour définir la coupe est

différent. La syntaxe est résumée dans le tableau suivant :

Syntaxe Description du point de jonction

call(methodeExpression) Appel d'une méthode

execution(methodeExpression) Exécution d'une méthode

get(attributExpression) Lecture d'un attribut

Exemple :

get (int Point.x)

set(attributExpression) Ecriture d'un attribut

Syntaxe Description du point de jonction

handler(exceptionExpression) Exécution d'un bloc de récupération d'une

exception (catch) dont le nom vérifie

Exemple :

handler(IOException+)

initialization(constanteExpression) Exécution d'un constructeur de classe dont le

nom vérifie constanteExpression

Exemple :

initialization(Customer.new(..))

preinitialization(constanteExpression) Exécution d'un constructeur hérité

staticinitialization(classeExpression) Exécution d'un bloc de code static dans une

classe

Exemple :

staticinitialization(Point)

adviceexecution() Exécution d'un code advice

5-CODE ADVICE :

• Une fois la coupe définie, il faut écrire le code à exécuter au moment où

l'événement décrit par la coupe est levé. Avant d'écrire ce code advice, il faut

décider à quel moment exécuter le code : avant l'événement, après ou autour

de l'événement.

• before permet d'exécuter du code avant d'entrer dans le code lié à

l'événement.

• after permet quant à lui d'exécuter du code après l'événement.

• around permet soit de remplacer l'événement en lui-même, soit d'exécuter du

code avant et après le point de jonction.

• Pour exécuter le code de l'événement il faut utiliser proceed à l'intérieur du

code advice. Si la méthode a un type de retour, alors il faut faire précéder le

mot-clef around de Object. L'appel à proceed renvoie alors un type Object qu'il

est possible de récupérer pour le renvoyer.

5-CODE ADVICE :

• Voici un exemple très simple permettant de tracer l'exécution de la méthode getX.

pointcut getXValue(): execution(int *..Point.getX());

Object around() : getXValue()

{

System.out.println("=> Entrée dans getX");

Object ret = proceed();

System.out.println("<= Sortie de la méthode getX");

return ret;

}

6-CONCLUSTION :

• Les langages orientés aspect, et plus particulièrement AspectJ,

commencent à être utilisés de plus en plus. Certains

programmeurs intègrent cette nouvelle méthode dans leur

processus de développement à des fins de tests internes,

débugage, traçage d'information, et d'autres l'utilisent déjà pour

développer des applications complètes.

7-RÉFÉRENCES :

• http://ewawszczyk.developpez.com/tutoriel/java/spring/aop/

• https://en.wikipedia.org/wiki/AspectJ

• http://www.cin.ufpe.br/~in0980/bib/JanofskyAspectJTutorial.html

• https://www.eformation.uha.fr/moodle/pluginfile.php/50303/mod_resource/content

/0/references/XPOSE_ASPECTJ3_LEVY_SOPHIE.pdf