Spring AOP for logging

AOP (Aspect Oriented programming) is a programming paradigm that allows the separation of business code from technical code. This paradigm is somewhat neglected by many developers but constitutes a very powerful tool.
In this tutorial we will try to apply this paradigm in logging our services with spring boot 3.

Prerequisites

• JDK 17
• IDE
• maven 3.x

Dependencies to add

        <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
This class will contain our AOP for logging:

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() allows you to mark a listening point each time a method found in the dev.tuxbe.democonfig.services package is called.
• The method annotated with @Before("serviceMethods()") is called before the execution of the services you are listening to
• The method annotated with AfterThrowing() is executed each time an error is detected during the execution of the listened service.
• The method annotated with AfterReturning() is executed when the service execution was completed without errors

This logging technique helps you have maintainable and clean code?

The above is the detailed content of Spring AOP for logging. For more information, please follow other related articles on the PHP Chinese website!