Spring Aop: anotaciones de notificación

1. Anotaciones envolventes

Anotación envolvente

Anotación envolvente @Aroud

anotación

describir

@Alrededor

@Around es un tipo de notificación en Spring AOP, que se utiliza para realizar operaciones circundantes antes y después de que se ejecute el método de destino. Puede agregar lógica adicional antes y después de las llamadas a métodos, como registros, monitoreo del rendimiento, etc. La anotación @Around debe coincidir con la expresión AspectJ para especificar el punto de entrada, definir el método de la clase de aspecto y controlar el proceso de ejecución del método de destino a través del parámetro ProceedingJoinPoint dentro del método.

Las anotaciones envolventes permiten la integración de mejoras.

Para las anotaciones circundantes, debe crear un objeto ProceedingJoinPoint y utilizar dos métodos correspondientes.

método	describir
proceder()	Ejecute el método de destino notificado y devuelva su valor de retorno. Este método debe llamarse en un aviso circundante; de ​​lo contrario, el método de destino no se ejecutará.
obtenerArgumentos()	Obtenga la matriz de valores del parámetro del método de destino. La matriz de parámetros devuelta es de tipo Objeto.

Casos de uso de anotaciones envolventes:

@Component
@Aspect
public class RoundAdvice {

    @Around("com.alphamilk.Advice.MyPointcut.pointcut1()")
    public Object Transation(ProceedingJoinPoint joinPoint){
//        获取方法参数
        Object[] args = joinPoint.getArgs();
//        获取返回值
        Object result = null;

        try {
            System.out.println("事务开始");
//            执行对应方法
           result =  joinPoint.proceed(args);
            System.out.println("事务结束");
        } catch (Throwable e) {
            System.out.println("事务回滚");
            throw new RuntimeException(e);
        }
        return result;
    }
}

 Nota: Debe habilitar las anotaciones de notificación para utilizar las mejoras.

@ComponentScan(value = "com.alphamilk")
@Configuration
//开启增强注解
@EnableAspectJAutoProxy
public class JavaConfig {
}

 Si no utiliza anotaciones circundantes, debe utilizar @Before @After @AfterReturning, etc.

@Component
@Aspect
public class advice {
  @Before("com.alphamilk.Advice.MyPointcut.pointcut1()")
    public void Before(JoinPoint joinPoint) {
        System.out.println("事务开始");
    }

 @After("com.alphamilk.Advice.MyPointcut.pointcut1()")
    public void After(JoinPoint joinPoint) {
        System.out.println("事务结束");
    }

    @AfterReturning(value = "com.alphamilk.Advice.MyPointcut.pointcut1()",returning = "result")
    public void AfterReturning(JoinPoint joinPoint,Object result) {
        System.out.println("调用拥有返回值的方法");
    }

    @AfterThrowing(value = "com.alphamilk.Advice.MyPointcut.pointcut1()",throwing = "throwable")
    public void AfterThrowing(JoinPoint joinPoint,Throwable throwable) {
        System.out.println("调用有异常的方法");
    }
}

Ventajas y desventajas de utilizar anotaciones envolventes

ventaja:

1. Alta flexibilidad: las anotaciones envolventes proporcionan el mayor grado de flexibilidad. Se puede insertar código lógico adicional antes y después de la ejecución del método de destino para controlar completamente el proceso de ejecución del método.
2. Procesamiento unificado: a través de anotaciones circundantes, los códigos lógicos comunes se pueden extraer en aspectos para lograr una lógica de procesamiento unificada y evitar escribir repetidamente el mismo código en cada método de destino.
3. El valor de retorno se puede modificar: en los consejos circundantes, el resultado final puede verse afectado modificando el valor de retorno del método de destino.

defecto:

1. Mayor complejidad: en comparación con otros tipos de notificaciones, el uso de anotaciones circundantes es un poco más complicado y requiere más comprensión y dominio, especialmente para el uso de ProceedingJoinPoint.
2. Sobrecarga de rendimiento: dado que la anotación circundante envolverá el proceso de ejecución de todo el método de destino, puede causar una cierta sobrecarga de rendimiento en algunos casos, especialmente cuando la lógica de procesamiento es más compleja.
3. Posible introducción de efectos secundarios: al realizar modificaciones en el método de destino en una notificación envolvente, debe operar con precaución para evitar introducir efectos secundarios impredecibles, que pueden provocar un comportamiento anormal o anormal del programa.

---

 2. Anotación de prioridad

anotación

describir

@Orden

@Order es una anotación en el marco Spring que se utiliza para definir el orden de carga de los componentes. Se puede utilizar a nivel de clase o de método. Cuando varios componentes implementan la misma interfaz o heredan la misma clase principal, su orden de carga se puede especificar mediante la anotación @Order. Cuanto menor sea el valor de @Order, mayor será la prioridad y mayor el orden de carga. El valor de la anotación @Order puede ser cualquier número entero. Cabe señalar que el orden de carga de los componentes con la misma prioridad es incierto, por lo que es mejor establecer las prioridades en valores diferentes para evitar incertidumbres.

Si hay dos o más mejoras para el mismo método y es necesario especificar el orden de las mejoras, debe utilizar la anotación de prioridad @Order para configurarlo.

Para su uso, el núcleo es: especificar una prioridad, cuanto menor sea el valor de Orden, mayor será la prioridad, cuanto mayor sea la prioridad, mayor será la prioridad, el frente se ejecutará primero y el último se ejecutará.

Código de caso: (primera mejora)

@Component
@Aspect
//设置一个优先级更高注解
@Order(10)
public class advice {
  @Before("com.alphamilk.Advice.MyPointcut.pointcut1()")
    public void Before(JoinPoint joinPoint) {
        System.out.println("优先级高前置执行");
    }

 @After("com.alphamilk.Advice.MyPointcut.pointcut1()")
    public void After(JoinPoint joinPoint) {
        System.out.println("优先级高后置后执行");
    }

    @AfterReturning(value = "com.alphamilk.Advice.MyPointcut.pointcut1()",returning = "result")
    public void AfterReturning(JoinPoint joinPoint,Object result) {
        System.out.println("调用拥有返回值的方法");
    }

    @AfterThrowing(value = "com.alphamilk.Advice.MyPointcut.pointcut1()",throwing = "throwable")
    public void AfterThrowing(JoinPoint joinPoint,Throwable throwable) {
        System.out.println("调用有异常的方法");
    }
}

La segunda mejora

@Component
@Aspect
@Order(20)
public class RoundAdvice {

    @Around("com.alphamilk.Advice.MyPointcut.pointcut1()")

    public Object Transation(ProceedingJoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        Object result = null;

        try {
            System.out.println("优先级低前置后执行");
//            执行对应方法
           result =  joinPoint.proceed(args);
            System.out.println("优先级低后置先执行");
        } catch (Throwable e) {
            System.out.println("事务回滚");
            throw new RuntimeException(e);
        }
        return result;
    }
}

---