Mes publications LinkedIn
L'AOP avec Spring : arrêtez de noyer votre code métier
On a tous fait ça un jour :
- un
log.info(...)au début de chaque méthode ; - un contrôle de sécurité dupliqué dans dix controllers ;
- une gestion de transaction répétée partout.
Résultat : le code métier est noyé sous du code technique. La solution s'appelle l'AOP (Aspect-Oriented Programming, ou programmation orientée aspect). Elle est déjà dans votre stack Spring, et vous l'utilisez sûrement sans le savoir à chaque fois que vous écrivez @Transactional ou @Cacheable.
Le problème concret
Certaines préoccupations traversent toute l'application : les logs, la sécurité, les transactions, le cache, la mesure des performances. On les appelle des préoccupations transverses (cross-cutting concerns).
Sans AOP, on les recopie dans chaque méthode :
public Order createOrder(OrderRequest request) {
log.info("createOrder appelé avec {}", request);
long start = System.currentTimeMillis();
// ... logique métier ...
log.info("createOrder terminé en {} ms", System.currentTimeMillis() - start);
return order;
}
Multipliez ça par cinquante méthodes : le code devient long, répétitif et difficile à maintenir.
Les 4 mots-clés à connaître
| Terme | Ce que c'est |
|---|---|
| Aspect | La classe qui regroupe le comportement transverse (ex. : le logging). |
| Advice | Le code exécuté et le moment où il s'exécute : @Before, @After, @AfterReturning, @AfterThrowing, @Around. |
| Pointcut | L'expression qui dit où appliquer l'advice (quelles classes, quelles méthodes). |
| Join Point | Le point précis de l'exécution intercepté ; avec Spring AOP, c'est l'appel d'une méthode. |
Un vrai exemple de code
Ajoutez la dépendance :
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
Puis écrivez un aspect qui mesure le temps d'exécution de tous les services :
@Aspect
@Component
@Slf4j
public class PerformanceAspect {
@Around("execution(* com.example.service..*(..))")
public Object mesurer(ProceedingJoinPoint joinPoint) throws Throwable {
long start = System.currentTimeMillis();
try {
return joinPoint.proceed();
} finally {
log.info("{} exécuté en {} ms",
joinPoint.getSignature().toShortString(),
System.currentTimeMillis() - start);
}
}
}
Le service redevient propre :
public Order createOrder(OrderRequest request) {
// uniquement la logique métier
}
Tip
Pour cibler précisément les méthodes, créez votre propre annotation (par exemple @Chronometre) et utilisez le pointcut @annotation(com.example.Chronometre).
Les cas d'usage qui font gagner du temps
- Logging centralisé des entrées, sorties et exceptions.
- Sécurité : vérifier des droits avant l'appel d'une méthode.
- Transactions : c'est exactement ce que fait
@Transactional. - Cache :
@Cacheablerepose sur le même mécanisme. - Monitoring : mesurer les temps de réponse.
- Audit : tracer qui a fait quoi et quand.
- Retry : relancer automatiquement une opération qui échoue.
Warning
Spring AOP fonctionne avec des proxies : un appel interne (this.methode()) dans la même classe ne passe pas par le proxy, donc l'aspect ne s'applique pas. C'est aussi la raison pour laquelle @Transactional ne marche pas sur un appel interne.
En résumé
L'AOP permet de séparer clairement le quoi (la logique métier) du comment (les préoccupations techniques). Si vous codez avec Spring, c'est un outil qui peut changer votre façon d'organiser votre code dès demain.