Formations — 1 037 leçons en français

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 @Aspect via 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 — @Aspect seule ne suffit pas.

@Before, @After

@Before exécute l'advice avant la méthode ciblée. @After l'exécute après, que la méthode se termine normalement ou lève une exception (équivalent d'un finally).

@AfterReturning, @AfterThrowing

@AfterReturning s'exécute seulement si la méthode se termine sans exception (accès possible à la valeur de retour). @AfterThrowing s'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 ProceedingJoinPoint et doit appeler proceed() 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() et getSignature() 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.

Lire l'explication détaillée et faire le quiz →

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.