Configuración de anotaciones de Spring AOP
(1) Breve descripción
La última vez que hablamos sobre el principio de implementación de Spring AOP, descubrimos que implementar esta función a través de nuestra propia programación sigue siendo muy engorroso. Por lo tanto, Spring nos proporciona un método de configuración correspondiente, que nos ayuda a simplificar el proceso de desarrollo, de modo que nuestra atención se pueda centrar completamente en la lógica empresarial.
Antes de comprender la configuración de anotaciones de AOP, primero debemos prestar atención a algunos términos profesionales en AOP:
Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中，这些点指的是方法，因为spring只支持方法类型的连接点。
Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。
Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知，通知分为：前置通知，后置通知，异常通知，最终通知，环绕通知。
Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下，Introduction可以在运行期为类动态地添加一些方法或Field。
Target(目标对象):代理的目标对象。
Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。
Proxy(代理):一个类被AOP织入增强后，就产生一个代理类。
Aspect(切面): 是切入点和通知的结合。
Echemos un vistazo a estos conceptos, solo necesitamos recordar algunos puntos. El primero es el concepto de aspecto, que es la A (Aspecto) en AOP. Es una combinación de punto de entrada y notificación. En términos sencillos, es la función adicional del programa y la posición de esta función. El punto de entrada es la posición de la notificación de la entrada y el punto de conexión es la posición que se puede utilizar como punto de entrada (pero no necesariamente se corta). Tenga en cuenta que una mejor comprensión debería llamarlo mejora, que es la función que queremos agregar (como la función de escribir registros), que es el núcleo de la programación orientada a aspectos. Resolvamos los puntos clave de los que acabamos de hablar, puntos de conexión, puntos de entrada, notificaciones y aspectos.
En este artículo, hablaremos sobre el método de configuración de anotaciones basado en @Aspect en lugar del método de configuración XML tradicional. Debido a que la configuración XML es demasiado engorrosa y difícil de entender, el método de configuración de anotaciones es más fácil de entender. Sin embargo, la premisa de la comprensión es comprender completamente los conceptos anteriores, porque esto estará estrechamente relacionado con la elección de las anotaciones más adelante.
(2) Ejemplos simples
Echemos un vistazo a un ejemplo sencillo para estudiar cómo se debe configurar AOP. En primer lugar, necesitamos importar dependencias, tenemos que agregar dependencias en el archivo pom.xml:
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>com.springsource.org.aspectj.weaver</artifactId>
<version>1.6.4.RELEASE</version>
</dependency>
Esta es la dependencia necesaria para usar la anotación @Aspect. Por supuesto, también se necesitan algunas dependencias del marco de primavera. No las escribiré aquí.
Luego, debe escribir el archivo de configuración, aquí es principalmente para agregar el espacio de nombres AOP y las restricciones, y abrir el método de configuración de anotaciones @AspectJ:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:bean="http://www.springframework.org/schema/context"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"
xmlns:aop="http://www.springframework.org/schema/aop">
<aop:aspectj-autoproxy/>
<context:component-scan base-package="com.test"/>
</beans>
Escribe el método principal, que es el método en el que seremos cortadas:
package com.test;
import org.springframework.stereotype.Component;
@Component("Hello")
public class Hello {
void sayHello(String s){
System.out.println("hello " + s);
}
}
Luego escribe el aspecto, que es la parte más crítica. Como se mencionó anteriormente, el aspecto se divide en dos partes, una es el punto de entrada y la otra es la notificación. Primero, necesitamos agregar anotaciones @Aspect a la clase de aspecto para indicar que este es un aspecto (nota: solo los objetos Bean que se han incluido en el contenedor IOC se pueden anotar con @Aspect). Luego escribimos nuestro método de notificación, es decir, las funciones adicionales que necesitamos, en este caso, los métodos antes y después. Un método por sí solo definitivamente no es suficiente. Necesitamos agregar una anotación al método para que Spring sepa que se trata de una notificación. Hay cinco notas que describen el tipo de notificación:
Estas cinco anotaciones corresponden a cinco métodos de notificación: notificación previa, notificación posterior, notificación final, notificación de excepción y notificación envolvente. En realidad, estos son los tiempos para las notificaciones, por lo que todos pueden intentar averiguar qué hacen. El momento de la notificación no es suficiente y también se requiere el punto de entrada específico (punto de entrada), que es el papel de la cadena en la anotación. El término técnico para esta cadena se llama indicador. Veamos cuántos tipos de indicadores hay:
El indicador más comúnmente utilizado es el indicador de ejecución (), que representa la ejecución del método. Los parámetros del indicador deben completarse con el nombre completo de la clase + el nombre del método para determinar un método, y los valores de retorno y los parámetros también se pueden agregar si es necesario. Lo que completamos en este caso es el nombre completo de la clase + el nombre del método, de modo que podamos ubicar un método de forma única en un proyecto. Esto también muestra claramente un principio: solo los métodos se pueden usar como puntos de entrada, en otras palabras, todos los métodos son puntos de conexión que se pueden ingresar.
package com.test;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Aspect
@Component("Logger")
public class Logger {
@Before("execution(* com.test.Hello.sayHello(..))")
void before(){
System.out.println("before hello");
}
@After("execution(* com.test.Hello.sayHello(..))")
void after(){
System.out.println("after hello");
}
}
De esta manera, podemos resumir la fórmula de la configuración de AOP: la notificación XX (uno de los cinco tipos de notificación, configurado con anotaciones) corta en el método de destino en XX (la cadena en la anotación del tipo de notificación) y ejecuta la función XX (método de notificación, arrogante). Intente corresponder con el código anterior para ver si este es el caso.
30 de julio de 2020