Spring AOP pour la journalisation

Beugré Toussaint — Tue, 22 Oct 2024 11:04:29 +0000

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 🚀

Dépendances cycliques en spring boot

Beugré Toussaint — Tue, 22 Oct 2024 10:23:14 +0000

Une dépendance cyclique intervient en Java lorsque deux class ou deux modules dépendent l'un de l'autre, formant ainsi un cycle.

Supposons que nous ayons deux beans A et B qui dépendent l'un de l'autre comme le montre l'exemple ci-dessous :

@Component
public class A{
    private final B b;
    public A(B b){
        this.b = b;
    }
}

@Component
public class B{
    private final A a;
    public B(A a){
        this.a = a;
    }
}

Lors de l'exécution de votre projet, vous aurez l'erreur suivante :

Relying upon circular references is discouraged and they are prohibited by default. Update your application to remove the dependency cycle between beans. As a last resort, it may be possible to break the cycle automatically by setting spring.main.allow-circular-references to true.

Ainsi, pour résoudre cette dépendance cyclique, nous avons quatre solutions :

Refactoriser le code pour séparer les responsabilités.
Utiliser des classes intermédiaires ou des interfaces.
Appliquer l'injection de dépendances via des méthodes (setter).
Utiliser des annotations comme @lazy pour retarder l'initialisation.

Dans notre cas, nous utiliserons la quatrième solution qui est juste d'utiliser l'annotation @lazy comme le montre l'exemple ci-dessous :

@Component
public class A{
    private final B b;
    public A(@Lazy B b){
        this.b = b;
    }
}

@Component
public class B{
    private final A a;
    public B(A a){
        this.a = a;
    }
}

Et voilà, nous sommes désormais sorti de ce cycle :)

DEV Community: Beugré Toussaint

Spring AOP pour la journalisation

Dépendances cycliques en spring boot