Programación Orientada a Aspectos Programación Orientada a Aspectos, en comparación con la programación orientada a objetos oop, Aop ya no se preocupa por una determinada clase o algunos métodos en el código del programa, mientras que aop considera más un corte cara a cara, a saber Una especie de corte entre capas, por eso se llama superficie de corte. Piense en la hamburguesa de todos (con carne en el medio). Entonces, ¿cómo intercepta aop toda la superficie? Teniendo en cuenta la configuración de servlet urlpattern / * aprendido, en realidad es la realización de aop.
Cómo se implementa Spring Aop
- Método de anotación
- Forma XML
Práctica de caso
Método de anotación
Introducir las coordenadas del paquete jar
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
</dependency>
configuración beans.xml
Agregar espacio de nombres
xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
Configurar el proxy Aop
<aop:aspectj-autoproxy/>
Escribir una clase de implementación aop
/**
* 声明切面组件
*/
@Component
@Aspect
public class LogCut {
/**
* 定义切入点 匹配方法规则定义
* 匹配规则表达式含义 拦截 com.xxx.service 包下 以及子包下 所有类的所有方法
*/
@Pointcut("execution (* com.xxx.service..*.*(..))")
public void cut(){
}
/**
* 声明前置通知 并将通知应用到定义的切入点上
* 目标类方法执行前 执行该通知
*/
@Before(value="cut()")
public void before(){
System.out.println("前置通知.....");
}
/**
* 声明返回通知 并将通知应用到切入点上
* 目标类方法执行完毕执行该通知
*/
@AfterReturning(value="cut()")
public void afterReturning(){
System.out.println("返回通知....");
}
/**
* 声明最终通知 并将通知应用到切入点上
* 目标类方法执行过程中是否发生异常 均会执行该通知 相当于异常中的 finally
*/
@After(value="cut()")
public void after(){
System.out.println("最终通知....");
}
/**
* 声明异常通知 并将通知应用到切入点上
* 目标类方法执行时发生异常 执行该通知
*/
@AfterThrowing(value="cut()",throwing="e")
public void afterThrowing(Exception e){
System.out.println("异常通知....方法执行异常时执行:"+e);
}
/**
* 声明环绕通知 并将通知应用到切入点上
* 方法执行前后 通过环绕通知定义相应处理
*/
@Around(value="cut()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("环绕前置...");
System.out.println("环绕通知");
System.out.println(pjp.getTarget()+"--"+pjp.getSignature());
Object result=pjp.proceed();//执行目标对象方法
System.out.println("环绕后置...");
return result;
}
}
Lenguaje de expresiones regulares del método de coincidencia de Aop (una breve comprensión)
Introducción a las expresiones de Aop Pointcut
Ejecute cualquier método público:
execution(public *(..))
Ejecuta cualquier método establecido
execution(* set*(..))
Ejecute cualquier método de cualquier clase en el paquete com.xxx.service
execution(* com.xxx.service.*.*(..))
Ejecute cualquier método de cualquier clase en el paquete y subpaquetes com.xxx.service
execution(* com.xxx.service..*.*(..))
forma xml
Aspectos de configuración, puntos de entrada, notificaciones
<!-- aop 相关配置 -->
<aop:config>
<!-- aop 切面配置 -->
<aop:aspect ref="logCut">
<!-- 定义 aop 切入点 -->
<aop:pointcut expression="execution (* com.xxx.service..*.*(..))"
id="cut"/>
<!-- 配置前置通知 指定前置通知方法名 并引用切入点定义 -->
<aop:before method="before" pointcut-ref="cut"/>
<!-- 配置返回通知 指定返回通知方法名 并引用切入点定义 -->
<aop:after-returning method="afterReturning" pointcut-ref="cut"/>
<!-- 配置异常通知 指定异常通知方法名 并引用切入点定义 -->
<aop:after-throwing method="afterThrowing" throwing="e" pointcut-ref="cut"/>
<!-- 配置最终通知 指定最终通知方法名 并引用切入点定义 -->
<aop:after method="after" pointcut-ref="cut"/>
<!-- 配置环绕通知 指定环绕通知方法名 并引用切入点定义 -->
<aop:around method="around" pointcut-ref="cut"/>
</aop:aspect>
</aop:config>
Definir frijol
/**
* 声明切面组件
*/
@Component
public class LogCut {
public void before(){
System.out.println("前置通知.....");
}
public void afterReturning(){
System.out.println("返回通知....");
}
public void after(){
System.out.println("最终通知....");
}
public void afterThrowing(Exception e){
System.out.println("异常通知....方法执行异常时执行:" + e);
}
public Object around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("环绕前置...");
System.out.println("环绕通知");
System.out.println(pjp.getTarget()+"--"+pjp.getSignature());
Object result=pjp.proceed();
System.out.println("环绕后置...");
return result;
}
}
Expandir
Conceptos básicos de AOP
JoinPoint (punto de conexión) 【dinámico】
Cada punto que se intercepta, el medio del resorte se refiere a cada método que se intercepta, y un punto de conexión del resorte aop representa la ejecución de un método.
Pointcut (punto de entrada) [estático]
Para la definición de interceptación de puntos de conexión (la definición de la regla de coincidencia especifica qué métodos se interceptan y qué métodos se procesan), Spring tiene una definición de lenguaje de expresión especial.
Asesoramiento {énfasis}
Interceptar cada punto de conexión (cada método) antes y después de la operación
- Notificación previa (mejora previa): antes () notificación antes del método de ejecución
- Notificación de devolución (mejora de devolución): la notificación después del método afterReturning finaliza normalmente y vuelve
- Notificación de lanzamiento de excepción (lanzamiento de excepción mejorado) –afetrThrow ()
- Notificación final: después de la notificación se ejecutará independientemente de si el método es anormal o no
- En torno al asesoramiento: en torno a un consejo de punto de unión (punto de unión), como las llamadas a métodos. Este es el tipo de notificación más poderoso. Las notificaciones envolventes pueden completar comportamientos personalizados antes y después de las llamadas a métodos. También elegirá si continuar ejecutando el punto de conexión o devolver directamente su propio valor de retorno o lanzar una excepción para finalizar la ejecución.
Aspecto
La combinación de punto de entrada y notificación determina la definición del aspecto. El punto de entrada define qué métodos de qué clases se van a interceptar. La notificación define qué hacer después del método de interceptación. El aspecto es una abstracción de preocupaciones transversales, similar a las clases. La clase es la abstracción de las características del objeto, mientras que el aspecto es la abstracción de preocupaciones transversales.
Objetivo
Público objetivo
Tejer (tejido en)
El proceso de aplicar el aspecto al objeto objetivo y generar el objeto proxy se denomina tejido (proceso).
Introducción
Sin modificar el código de la aplicación original, el proceso de agregar métodos o campos dinámicamente a la clase durante el tiempo de ejecución del programa se llama introducción.