Habilite el soporte de anotaciones de AspectJ en Spring
Para la primavera aplicaciones de uso AspectJ anotación , debe ruta de clase contener al AspectJ biblioteca : aopalliance.jar , aspectj.weaver.jar y primavera-aspects.jar
Agregue aop Schema al elemento raíz <beans> .
Para habilitar el soporte de anotaciones de AspectJ en el contenedor Spring IOC , simplemente defina un elemento XML vacío en el archivo de configuración de bean < aop: aspectj-autoproxy >
Cuando el resorte COI contenedor detecta la haba archivo de configuración < AOP: AspectJ-autoproxy > el elemento , de forma automática con la AspectJ sección partido de la haba para crear un proxy .
Use las anotaciones de AspectJ para declarar aspectos
Para la primavera comunicado AspectJ sección , sólo el COI de corte envase en el estado de la haba de ejemplo . Cuando la primavera COI contenedor de inicialización AspectJ después del corte , Primavera COI contenedor será para aquellos con AspectJ sección para que coincida con la haba para crear un proxy .
En la anotación AspectJ , el aspecto es solo una clase Java con anotación @Aspect .
Las notificaciones son métodos simples de Java marcados con algún tipo de anotación .
AspectJ admite 5 tipos de anotaciones de notificación :
@Antes: notificación previa , ejecutada antes de la ejecución del método
@ Después : notificación posterior , ejecutada después de la ejecución del método
@ AfterReturning : notificación de devolución , ejecutada después de que el método devuelve el resultado
@ AfterThrowing : notificación de excepción , después de que el método arroje una excepción
@Around: notificación envolvente , ejecutar alrededor del método
Aviso previo
Notificación previa : una notificación que se ejecuta antes de que se ejecute el método
Previa a la notificación mediante @Before notas , valor y puntos de entrada como la expresión del valor de los billetes .
Use la firma del método para escribir la expresión de corte de punto de AspectJ
La expresión de corte de punto más típica coincide con varios métodos de acuerdo con la firma del método :
Ejecución * com.atguigu.spring.ArithmeticCalculator . * (..): Partido ArithmeticCalculator todos los métodos declarado , el primer modificador y * representa cualquier valor de retorno arbitrario . El segundo * representa cualquier método . .. partidos un número arbitrario parámetro . Si la clase de destino y la sección de interfaz en el mismo paquete , se puede omitir el nombre del paquete .
ejecución public * ArithmeticCalculator. * (..): coincide con todos los métodos públicos de la interfaz ArithmeticCalculator .
ejecución public Double ArithmeticCalculator. * (..): coincide con el método de devolver el valor de tipo doble en ArithmeticCalculator
ejecución public double ArithmeticCalculator. * ( double , ..): coincide con el método cuyo primer parámetro es de tipo double .. coincide con cualquier número de parámetros de cualquier tipo
La ejecución pública Doble ArithmeticCalculator * (. Doble , Doble ): parámetros coincidentes de tipo doble, doble método de tipo .
Fusionar expresiones de punto de corte
En AspectJ en , la expresión punto de corte por los operadores &&, || ,! combinado .
Permita que la notificación acceda a los detalles del punto de conexión actual
Se pueden declarar en un método de notificación para el tipo de puntos de inflexión parámetros . A continuación, puede acceder a enlaces con detalle . El nombre del método y los parámetros de los valores .
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd">
<!-- 开启注解扫描 -->
<context:component-scan base-package="com.learn.spring.aspectJ"></context:component-
scan>
<!-- 基于注解开发开启aop自动代理-->
<aop:aspectj-autoproxy/>
</beans>
package com.learn.spring.aspectJ;
public interface ArithmeticCalculator {
public int add(int i, int j );
public int sub(int i, int j );
public int mul(int i, int j );
public int div(int i, int j );
}
package com.learn.spring.aspectJ;
import org.springframework.stereotype.Component;
@Component
public class ArithmeticCalculatorImpl implements ArithmeticCalculator {
@Override
public int add(int i, int j) {
int result = i + j ;
return result;
}
@Override
public int sub(int i, int j) {
int result = i - j ;
return result;
}
@Override
public int mul(int i, int j) {
int result = i * j ;
return result;
}
@Override
public int div(int i, int j) {
int result = i / j ;
return result;
}
}
package com.learn.spring.aspectJ;
import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
* 日志切面
*/
@Component //标识为组件
@Aspect //标识为切面
@Order(3) //指定切面的优先级. 值越小，优先级越高. 标注@Order的切面比不标注@Order切面的优先级高
public class LoggingAspect {
/**
* 通知: 前置 后置 返回 异常 环绕
*/
/**
* 前置通知: 在方法执行之前执行.
* JoinPoint:连接点对象 包含了连接点相关的信息:方法名 方法的参数等....
*/
//@Before("execution(public int com.learn.spring.aspectJ.ArithmeticCalculator.add(int,int))")
//@Before("execution(public int com.learn.spring.aspectJ.ArithmeticCalculator.*(int,int))")
//任意修饰符任意返回值 com.learn.spring.aspectJ包下的任意类的任意方法 任意参数
//@Before("execution(* com.learn.spring.aspectJ.*.*(..))")
@Before("suibian()")
public void beforeMethod(JoinPoint joinPoint){
//获取方法名:
String methodName = joinPoint.getSignature().getName();
//获取参数
Object [] args = joinPoint.getArgs();
System.out.println("The method "+methodName+" begins with "+ Arrays.asList(args));
}
}
package com.learn.spring.aspectJ;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext ctx =
new ClassPathXmlApplicationContext("spring-aspectJ.xml");
ArithmeticCalculator ac =
(ArithmeticCalculator)ctx.getBean("arithmeticCalculatorImpl");
System.out.println(ac.getClass().getName());
int result = ac.div(2, 1);
System.out.println("AspectJ-result====>:"+result);
}
}
