Spring Boot AOP

En esta entrada de Spring Boot AOP (Aspect Oriented Programming), vamos a introducirnos en el mundo de la programación orientada a aspectos y a entender como funciona para poder aplicarlo en nuestras aplicaciones.

¿Qué es AOP?

AOP o en español programación orientada a aspectos es un paradigma de la programación que pretende aumentar la modularidad dentro de nuestras aplicaciones. La idea detrás de este tipo de programación, es poder añadir nuevos comportamientos sin tener que modificar el código existente. Spring tiene un módulo que nos va a simplificará la vida.

AOP Conceptos

¿Qué es un Aspecto en AOP?

Podríamos definir un aspecto como una funcionalidad común que tiene nuestra aplicación, por ejemplo, si cada vez que alguno de nuestros métodos devuelve una lista de un tipo en concreto queremos hacer un log de esa lista.

¿Qué es un Jointpoint en AOP?

Un jointpoint en programación orientada a aspectos podríamos decir que es un punto o controlador de la ejecución de un programa, método etc.

¿Qué es un Advice?

Un Advice o consejo en español :), es una acción que tendrá lugar en momentos concretos de nuestro código para que se pueda ejecutar un aspecto.

¿Qué es un Pointcut en AOP?

Un pointcut en AOP, es aquellas zonas de nuestro código en las que un advice se tiene que ejecutar.

¿Cuándo usar AOP?

Cómo hemos dicho antes, queremos ejecutar AOP como una funcionalidad común a nuestro código que implementaremos sin necesidad de realizar ningún cambio en nuestro código o añadir un comportamiento, por ejemplo, podríamos crear un aspecto para calcular el tiempo que se tarda en ejecutar un método, y así saber si es un tiempo demasiado largo. Vamos a verlo más claro con un ejemplo.

Ejemplo con AOP

Vamos a ver el caso de uso del que hemos hablado en el punto anterior, como calcular el tiempo de ejecución de un método.

Dependencias Maven

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.2.RELEASE<version>
</parent>
 
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
</dependencies>

Método de Ejemplo

package com.refactorizando.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
@Slf4j
public class AspectoTiempo {
 
    @Around("execution(* com.refactorizando.facade.*.*(..))")
       public Object processTime(ProceedingJoinPoint joinPoint) throws Throwable {
         
         long startTime=System.currentTimeMillis();
     
        Object methodProceed=joinPoint.proceed(); 
         
        long endTime=System.currentTimeMillis();
         
        var totalTime = startTime - endTime;

        if (totalTime > 1000) {
             
            log.debug("joinPoint.getTarget().getClass()+"."+joinPoint.getSignature().getName() +": with a total time of  "+ totalTime);
        }
         return methodProceed;
         
     }
 
}

Conclusión

En esta entrada Spring Boot AOP hemos visto una introducción sobre los conceptos básicos y para que usar este tipo de programación.

Otros artículos que te pueden interesar

Entity Graph con JPA en Spring BootEntity Graph con JPA en Spring Boot

Implementando una Cache con Spring

Spring Boot Actuator con Prometheus y Grafana