Spring AOP pour la journalisation

AOP (Aspect Oriented programming) est un paradigme de programmation qui permet la séparation du code métier du code technique. Ce paradigme est un peu délaissé par bon nombre de développeurs mais constitue un très puissant outil.
Dans ce tutoriel, nous essaierons d'appliquer ce paradigme dans la journalisation de nos services avec spring boot 3.

Pré-requis

• JDK 17
• IDE
• maven 3.x

Dépendences à ajouter

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>3.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

LoggingAspect.java
Cette class contiendra notre AOP pour la journalisation :

package dev.tuxbe.democonfig.contracts;

import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.JoinPoint;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

@Aspect
@Component
@Slf4j
public class LoggingAspect {

    @Pointcut("execution(* dev.tuxbe.democonfig.services.*.*(..))")
    public void serviceMethods() {
    }

    @Before("serviceMethods()")
    public void logBeforeServiceMethods(JoinPoint joinpoint) {
        String name = joinpoint.getSignature().getName();
        log.info("Début de traitement de la method {} avec pour parametre {}", name, joinpoint.getArgs());
    }

    @AfterReturning(value = "serviceMethods()", returning = "proceed")
    public void logAfterReturningServiceMethods(JoinPoint joinpoint, Object proceed) {
        String methodName = joinpoint.getSignature().getName();
        Object[] args = joinpoint.getArgs();

        // Logiquement, si nous atteignons ce point, le traitement s'est bien terminé
        log.info("Méthode {} exécutée avec succès avec les arguments {}", methodName, args);
        log.info("Résultat : {}", proceed);
    }

    @AfterThrowing(pointcut = "serviceMethods()", throwing = "ex")
    public void logAfterThrowingServiceMethods(JoinPoint joinPoint, Throwable ex) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();

        // Récupérer la requête HTTP
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest();
        String uri = request.getRequestURI();
        String method = request.getMethod();

        // Logiquement, si nous atteignons ce point, une exception a été levée pendant l'exécution de la méthode
        log.info("{} : {} exécutée avec echec avec les arguments {}",method, uri, args);
        log.info("Message d'error : {}", ex.getMessage());
    }
}

• @Pointcut() permet de marquer un point d'écoute à chaque fois qu'une méthode se trouvant dans le package dev.tuxbe.democonfig.services est appelée.
• La méthode annoté avec @Before("serviceMethods()") est appelé avant l’exécution des services que vous écoutez
• La méthode annoté avec AfterThrowing() est exécutée à chaque fois qu'une erreur sera détectée lors de l’exécution du service écouté.
• La méthode annoté avec AfterReturning() est exécutée lorsque l'exécution du service s'est déroulée sans erreur

Cette technique de journalisation vous aide à avoir un code maintenable et propre 🚀