Java框架 Spring-AOP

​

	
	
	<context:component-scan base-package="com.chenyixin.ssm.annotation"/>
	
	<aop:aspectj-autoproxy/>

③ 测试

    @Pointcut(value = "execution(* com.chenyixin.ssm.annotation.imp.CalculatorPureImpl.*(..))")
    public void pointCut() {}

@Component
@Aspect // @Aspect表示这个类是一个切面类
public class LogAspect {
 
    @Pointcut(value = "execution(* com.chenyixin.ssm.annotation.imp.CalculatorPureImpl.*(..))")
    public void pointCut() {}
 
    // @Before注解：声明当前方法是前置通知方法
    // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
    @Before(value="pointCut()")
    public void add() {
        System.out.println("[LogAspect --> 前置通知] 方法执行了");
    }
 
    @AfterReturning("pointCut()")
    public void printLogAfterSuccess() {
        System.out.println("[LogAspect --> 返回通知] 方法成功返回了");
    }
 
    @AfterThrowing("pointCut()")
    public void printLogAfterException() {
        System.out.println("[LogAspect --> 异常通知] 方法抛异常了");
    }
 
    @After("pointCut()")
    public void printLogFinallyEnd() {
        System.out.println("[LogAspect --> 后置通知] 方法最终结束了");
    }
}

@Component
@Aspect
public class ValidateAspect {
    
    // 相当于调用 ：全类名.方法名
    @Before(value="com.chenyixin.ssm.annotation.LogAspect.pointCut()")
    public void beforeMethod() {
 
    }
}

@Component
public class AtguiguPointCut {
    
    @Pointcut(value = "execution(public int *..Calculator.sub(int,int))")
    public void atguiguGlobalPointCut(){}
    
    @Pointcut(value = "execution(public int *..Calculator.add(int,int))")
    public void atguiguSecondPointCut(){}
    
    @Pointcut(value = "execution(* *..*Service.*(..))")
    public void transactionPointCut(){}
}

    // @Before注解：声明当前方法是前置通知方法
    // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
    // 在前置通知方法形参位置声明一个JoinPoint类型的参数，Spring就会将这个对象传入
    // 根据JoinPoint对象就可以获取目标方法名称、实际参数列表
    @Before(value = "pointCut()")
    public void add(JoinPoint joinPoint) {
        // 1.通过JoinPoint对象获取目标方法签名对象
        // 方法的签名：一个方法的全部声明信息
        Signature signature = joinPoint.getSignature();
 
        // 2.通过方法的签名对象获取目标方法的详细信息
        // 获取方法名
        String name = signature.getName();
 
        int modifiers = signature.getModifiers();
        // System.out.println(modifiers);
        String declaringTypeName = signature.getDeclaringTypeName();
        // System.out.println(declaringTypeName);
        Class declaringType = signature.getDeclaringType();
        // System.out.println(declaringType);
 
        // 3.通过JoinPoint对象获取外界调用目标方法时传入的实参列表
        Object[] args = joinPoint.getArgs();
 
        System.out.println("[LogAspect --> 前置通知] 方法" + name + "执行了,参数为：" + Arrays.toString(args));
    }

    // @AfterReturning注解标记返回通知方法
    // 在返回通知中获取目标方法返回值分两步：
    // 第一步：在@AfterReturning注解中通过returning属性设置一个名称
    // 第二步：使用returning属性设置的名称在通知方法中声明一个对应的形参
    @AfterReturning(value = "pointCut()", returning = "result")
    public void printLogAfterSuccess(JoinPoint joinPoint, Object result) {
        String name = joinPoint.getSignature().getName();
        System.out.println("[LogAspect --> 返回通知] 方法" + name + "成功返回了,返回值为:" + result);
    }

    // @AfterThrowing注解标记异常通知方法
    // 在异常通知中获取目标方法抛出的异常分两步：
    // 第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称
    // 第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们
    @AfterThrowing(value = "pointCut()", throwing = "exception")
    public void printLogAfterException(JoinPoint joinPoint, Exception exception) {
        String name = joinPoint.getSignature().getName();
        System.out.println("[LogAspect --> 异常通知] 方法" + name + "抛异常了,异常为：" + exception);
    }

    @Test
    public void testAnnotationAOP() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator calculator = ioc.getBean(Calculator.class);
        System.out.println("测试1：");
        calculator.add(1, 2);
        System.out.println();
        System.out.println("测试2：");
        calculator.div(1, 0);
    }

//使用@Around注解标明环绕通知方法
    @Around("pointCut()")
    public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint) {
        // 声明变量用来存储目标方法的返回值
        Object result = null;
        // 获取参数列表
        Object[] args = joinPoint.getArgs();
        try {
            // 在目标方法执行前执行
            System.out.println("环绕通知 --> 前置位置");
 
            // 过ProceedingJoinPoint对象调用目标方法
            // 目标方法的返回值一定要返回给外界调用者
            result = joinPoint.proceed(args);
 
            // 在目标方法成功返回后执行
            System.out.println("环绕通知 --> 返回位置");
 
        } catch (Throwable e) {
            // e.printStackTrace();
            // 在目标方法抛异常后执行
            System.out.println("环绕通知 --> 异常位置");
 
        }finally {
            // 在目标方法最终结束后执行
            System.out.println("环绕通知 --> 后置位置");
 
        }
        return result;
    }

public class AOPTest {
 
    @Test
    public void testAnnotationAOP() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator calculator = ioc.getBean(Calculator.class);
        System.out.println("测试1：");
        calculator.add(1, 2);
        System.out.println();
        System.out.println("测试2：");
        calculator.div(1, 0);
    }
}

​

​

@Component
@Aspect
@Order(1)
public class ValidateAspect {
 
    // 相当于调用 ：全类名.方法名
    @Before(value = "com.chenyixin.ssm.annotation.LogAspect.pointCut()")
    public void beforeMethod(JoinPoint joinPoint) {
        String name = joinPoint.getSignature().getName();
        List