Primavera AOP – Anotación AspectJ

AOP, es decir , la Programación Orientada a Aspectos complementa la programación orientada a objetos al permitir la modularidad de las preocupaciones transversales. @AspectJ se usa principalmente para declarar aspectos como clases regulares de Java anotadas con anotaciones. La implementación de Spring AspectJ AOP tiene muchas anotaciones. Se explican a continuación:

• @Aspect : Declara la clase como un aspecto.
• @Pointcut : Declara la expresión pointcut.

Las anotaciones comunes de AspectJ utilizadas para crear consejos son las siguientes:

• @Before : se ejecuta antes de la ejecución del método.
• @AfterReturning : se ejecuta después de que el método devuelva el resultado.
• @AfterThrowing : se ejecuta después de que el método lanza una excepción.
• @After(Finally) : se ejecuta después de la ejecución del método o después de que se lanza una excepción o el método devuelve el resultado.
• @Around : puede realizar el comportamiento antes y después de la invocación del método.
• @Pointcut : Pointcut es una firma que coincide con los puntos de unión.

@Punto de corte

Ejemplo de expresión de corte de punto con consejo anterior es el siguiente:

// Annotation
@Before("execution(* abc.def.gettingstarted.dao.*.add(..))")
public void allMethods(Point Point)
{
  // Aspect body 
}

@Antes (Antes del Consejo)

Antes de que se ejecute el consejo antes de la ejecución del método de destino. Antes de que el consejo pueda acceder a todos los argumentos del método Target. No puede alterar los valores de los argumentos al método original. Antes del consejo, debe especificar una expresión Pointcut a menos que usemos un proveedor de expresión @Pointcut separado. 

Ejemplo : método beforeAdvice() anotado como antes de que se ejecute el consejo antes de que se ejecute el método selectGetName()

@Aspect
public class Logging {
  
   @PointCut("execution(* com.gfg.Student.getName(..))")
   private void selectGetName(){}
    
   @Before("selectGetName()")
   public void beforeAdvice(){
      System.out.println("Going to setup student profile.");
   }  
    
}

@AfterReturning(Consejos después de la devolución)

Después de devolver el consejo es un método Java normal, excepto que tenemos que agregar la anotación @AfterReturning y una expresión Pointcut. La expresión Pointcut se asigna a la firma, la clase y el paquete del método de destino, y el consejo se aplica a todos esos métodos de coincidencia.

Ejemplo : en el siguiente ejemplo, el método methodCall se ejecuta cuando el método readFile devuelve algo.

@Slf4j
@Aspect
@Component
public class LoggingAspect {
    
    @AfterReturning("execution(* com.gfg.spring.aop.service.FileSystemStorageService.readFile(..))")
    public void methodCall(JoinPoint jp, Exception ex) {
        log.error("Target method is successfully completed!!");
    }
    
}

@AfterThrowing(Después de lanzar consejos)

Como sugiere el nombre, el consejo AfterThrowing se ejecuta cuando el método de destino genera una excepción. No se ejecutará si el método finaliza correctamente o si el método se traga la excepción lanzada. Por lo tanto, el consejo de AfterThrowing es útil cuando queremos crear un controlador de excepciones común que pueda capturar diferentes excepciones lanzadas por un método de destino diferente y tomar una acción.

Ejemplo : en el siguiente ejemplo, el método throwingAdvice se ejecuta cuando cualquier método de la clase Student arroja una excepción.

@AfterThrowing(PointCut = "execution(* com.gfg.Student.*(..))", throwing = "error")
public void throwingAdvice(JoinPoint jp, Throwable error){
   System.out.println("Method Signature: "  + jp.getSignature());  
   System.out.println("Exception: "+error);  
}

@Después(Después/Finalmente Consejo)

Un consejo posterior se ejecuta después de que finaliza el método de destino o se incluye cuando el método de destino da como resultado una excepción. Este consejo es similar al bloque final en Java que siempre se ejecuta independientemente del resultado.

Ejemplo : después de que se ejecute el consejo después de la ejecución del método o después de que se produzca una excepción o el método devuelva el resultado.

@After("execution(* com.gfg.saop.after.dao.*.*(..))")
public void logResult(JoinPoint joinPoint)
{
    System.out.println(
        "After advice executed: "
        + joinPoint.getSignature().toShortString());
}

@Alrededor (Asesoramiento alrededor)

Spring AOP admite varios tipos de consejos y el consejo around es uno de esos consejos. Este consejo rodea la ejecución del método de destino. Eso significa que, en la ejecución de un método de destino, el consejo se ejecuta y llama al método de destino. por lo tanto, el consejo obtiene control total sobre la aplicación de código adicional antes y después de la ejecución del método. El consejo Around es muy popular debido a su flexibilidad. Sin embargo, Spring recomienda que utilicemos el tipo de consejo que sea más específico según el requisito. Realiza el comportamiento igual que antes y después de los consejos combinados.