Accueil › Spring Boot › Écrire un aspect avec @Aspect
Écrire un aspect avec @Aspect
AOP et proxiesintermediaire
Pour écrire ses propres aspects, il faut d'abord ajouter la dépendance dédiée (absente des starters courants) :
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
Un aspect est une classe @Aspect et @Component (sinon Spring ne la détecte pas), avec une ou plusieurs méthodes advice annotées selon le moment souhaité :
@Aspect
@Component
public class ChronoAspect {
@Around("execution(* com.boutique.service.*.*(..))")
public Object mesurer(ProceedingJoinPoint pjp) throws Throwable {
long debut = System.currentTimeMillis();
Object resultat = pjp.proceed(); // exécute la méthode réelle
long duree = System.currentTimeMillis() - debut;
System.out.printf("%s : %d ms%n", pjp.getSignature().toShortString(), duree);
return resultat;
}
}
Ce pointcut, execution(* com.boutique.service.*.*(..)), cible toutes les méthodes publiques de toutes les classes du package service. @Around est le plus flexible : il reçoit un ProceedingJoinPoint et doit appeler proceed() pour que la méthode ciblée s'exécute réellement — l'oublier revient à supprimer le comportement de la méthode.
Les autres advices sont plus simples pour des cas ciblés : @Before (avant), @After (après, comme un finally), @AfterReturning (après un retour normal) et @AfterThrowing (après une exception).
Les termes à connaître
- spring-boot-starter-aop
Dépendance qui apporte AspectJ (utilisé uniquement pour sa syntaxe de pointcuts et ses annotations, pas pour son tissage) et active automatiquement le support des aspects
@Aspectvia l'auto-configuration de Spring Boot.- @Aspect
Annotation qui marque une classe comme un aspect. À combiner avec
@Component(ou une déclaration@Bean) pour que Spring la détecte et l'enregistre comme bean —@Aspectseule ne suffit pas.- @Before, @After
@Beforeexécute l'advice avant la méthode ciblée.@Afterl'exécute après, que la méthode se termine normalement ou lève une exception (équivalent d'unfinally).- @AfterReturning, @AfterThrowing
@AfterReturnings'exécute seulement si la méthode se termine sans exception (accès possible à la valeur de retour).@AfterThrowings'exécute seulement si elle lève une exception (accès possible à l'exception).- @Around
L'advice le plus puissant : il englobe complètement l'appel. Il reçoit un
ProceedingJoinPointet doit appelerproceed()explicitement pour exécuter la méthode ciblée — sinon elle ne s'exécute jamais.- ProceedingJoinPoint
Paramètre reçu par un advice
@Around, qui représente l'appel intercepté.proceed()déclenche la méthode réelle et renvoie son résultat ;getArgs()etgetSignature()donnent accès aux arguments et à la méthode ciblée.- @Pointcut
Permet de nommer une expression de pointcut dans une méthode vide, pour la réutiliser dans plusieurs advices au lieu de la répéter.
- @Order
Définit l'ordre d'exécution quand plusieurs aspects s'appliquent au même join point. Une valeur plus petite s'exécute en premier (priorité plus haute) et s'imbrique « à l'extérieur » des autres.
Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.