Spring AOP für die Protokollierung

AOP (Aspect Oriented Programming) ist ein Programmierparadigma, das die Trennung von Geschäftscode von technischem Code ermöglicht. Dieses Paradigma wird von vielen Entwicklern etwas vernachlässigt, stellt aber ein sehr leistungsfähiges Werkzeug dar.
In diesem Tutorial werden wir versuchen, dieses Paradigma bei der Protokollierung unserer Dienste mit Spring Boot 3 anzuwenden.

Voraussetzungen

• JDK 17
• IDE
• Maven 3.x

Abhängigkeiten zum Hinzufügen

        <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
Diese Klasse enthält unser AOP für die Protokollierung:

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() ermöglicht es Ihnen, jedes Mal einen Abhörpunkt zu markieren, wenn eine Methode aus dem Paket dev.tuxbe.democonfig.services aufgerufen wird.
• Die mit @Before("serviceMethods()") annotierte Methode wird vor der Ausführung der Dienste aufgerufen, die Sie abhören
• Die mit AfterThrowing() annotierte Methode wird jedes Mal ausgeführt, wenn während der Ausführung des abgehörten Dienstes ein Fehler erkannt wird.
• Die mit AfterReturning() annotierte Methode wird ausgeführt, wenn die Dienstausführung ohne Fehler abgeschlossen wurde

Diese Protokollierungstechnik hilft Ihnen, wartbaren und sauberen Code zu erhalten?

Das obige ist der detaillierte Inhalt vonSpring AOP für die Protokollierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!