AOP :Programmation Orienté Aspect

L'AOP est simple! .

Qu'est ce que l'AOP ?

Un aspect est ... une partie d'une application.
Cela reste de toute façon du code java , defini dans des classes.
Ces methodes appelés "advice" s'executent après, avant,..des methodes definis dans les points d'exécution ("joint point"), sans modifier leur code!!
Exemple d'application de l'AOP:
Exemples de modules :

gestion des utilisateurs (authentification),
archivage des données (persistance),
trace ...

Avantage
Permet de rendre une application plus modulaire, en regroupant des fonctionnalités en un même lieu, alors que leurs exécutions est répartie dans l'ensemble des classes, et donc plus facile à maintenir.

Vocabulaire

Aspect: Une classe annotés avec le tag @Aspect. Les méthodes d'un aspect ("advises") sont exécutées à l'apparition de certains évènements.
Join point: Un point durant l'execution d'un programme, comme l'éxécution d'une methode, ou la levée d'une exception.
Advice: Certains auteurs le traduise par "greffon". Méthode éxécutée à un "Joint poin".Il y a plusieurs types de Advice possible: "around," "before" and "after" ....
Pointcut:Une expression qui correspond à des "join point" . Un "Advice" est toujours associé à une definition de "pointcut" et s'exécute aà chaque "join point" qui correspond au "pointcut" . Les "pointcut" sont des expressions regulières, ce qui donne une puissance considerable à ca type de programmation.
Target object: Object qui sont "advised" (monitoré?) par un ou plusieurs aspect.
AOP proxy: Un objet créé par le framework aop dans le but implementer les methodes des "advise" à implementer.
Weaving: (tissage) Relie aspects avec le reste de l'application.Il peut être fait à la compilation (En utilisant le compilateur AspectJ par exemple), au chargement ou à l'éxécution.
Types de advice:
- Before : L'"advice" s'éxécute avant un "join point", mais il n'a pas la possibilité d'empécher l'éxécution de la méthode du "joint point", à part bien sûr de lever une exception.
- After returning: L'"advice" est éxécuté après l'éxecution normale du "join point".
- After throwing: L'"advice" sera éxécuté si une methode lève une exception.
- After (finally):L'"advice" est executé quelquesoit la manière par lequel le "joint point" est terminé (Normalement ou suite à une exception).
- Around : L'"advice" entoure le "join point", comme une méthode.Il peut bien sur accomplir certaine tache et retouner une valeur ou lever une exception.

Quelles sont les dependances necessaires ?

Le comportement est largement dependant des jar accessibles dans le path!
Voila un fichier POM (Project Object Model) destiné à maven2:

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.bg</groupId>
	<artifactId>bgTestSpring</artifactId>
	<packaging>war</packaging>
	<version>1.0-SNAPSHOT</version>
	<name>bgTestSpring Maven Webapp</name>
	<url>http://maven.apache.org</url>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>

<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring</artifactId>
			<version>2.5.1</version>
		</dependency>

<dependency>
			<groupId>aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>1.2</version>
		</dependency>

<dependency>
			<groupId>aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.5.2</version>
		</dependency>
		
		
		<dependency>
			<groupId>cglib</groupId>
			<artifactId>cglib-nodep</artifactId>
			<version>2.1_3</version>
		</dependency>

</dependencies>
	<build>
		<finalName>bgTestSpring</finalName>
	</build>
</project>

Un simple bean qui nous servira de cobail

Un aspect

On remarque :

L'annotation @Aspect devant class
L'annotation @AfterReturning avec comme argument une methode de BeanVerySimple.L'argument accepte les expressions regulières
2 methodes sans annotations: Elles seront configurées dans le fichier de config Spring

Le fichier de config Spring

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<aop:aspectj-autoproxy />

<aop:config>
		<aop:pointcut id="bgPointCut"  expression="execution(void bg.spring.util.BeanVerySimple.maMethode())"/>    		
		<aop:aspect id="loggingAspect" ref="myFirstAspect">
		    <aop:before method="myMethodeBefore"  pointcut-ref="bgPointCut"/>    		
		    <aop:after-returning method="myMethodeAfter" pointcut-ref="bgPointCut"/>
	    </aop:aspect>	    
	</aop:config>

</beans>