Spring(七）基于注解的AOP

1.技术说明

动态代理：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口

cglib:通过继承被代理的目标类实现代理，所以不需要目标类实现接口

AspectJ:本质上是静态代理，将代理逻辑“织入”被代理的目标类编译得到的字节码文件，所以最终效果是动态的，weaver就是织入器，Spring只是借用了AspectJ中的注解。

2.准备工作

添加依赖

在IOC所需依赖基础上再加入下面依赖即可：

 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.1</version>
        </dependency>

 我们接下来创建接口和实现类如下所示：

package com.rgf.spring.aop.annotation;

public interface Calculator {
    int add(int i,int j);
    int sub(int i,int j);
    int mul(int i,int j);
    int div(int i,int j);
}

实现类如下所示：

package com.rgf.spring.aop.annotation;

public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result=i+j;
        System.out.println("方法内部，result:"+result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result=i-j;
        System.out.println("方法内部，result:"+result);
        return  result;
    }

    @Override
    public int mul(int i, int j) {
       int result=i*j;
       System.out.println("方法内部，result:"+result);
       return  result;
    }

    @Override
    public int div(int i, int j) {
      int result=i/j;
      System.out.println("方法内部，result:"+result);
      return  result;
    }
}

创建切面类并配置

我们要把切面类和目标类交给IOC容器来管理，我们利用注解的形式如下：

package com.rgf.spring.aop.annotation;

import org.springframework.stereotype.Component;

@Component
public interface Calculator {
    int add(int i,int j);
    int sub(int i,int j);
    int mul(int i,int j);
    int div(int i,int j);
}

package com.rgf.spring.aop.annotation;

import org.springframework.stereotype.Component;

/**
 *
 */
@Component
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result=i+j;
        System.out.println("方法内部，result:"+result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result=i-j;
        System.out.println("方法内部，result:"+result);
        return  result;
    }

    @Override
    public int mul(int i, int j) {
       int result=i*j;
       System.out.println("方法内部，result:"+result);
       return  result;
    }

    @Override
    public int div(int i, int j) {
      int result=i/j;
      System.out.println("方法内部，result:"+result);
      return  result;
    }
}

package com.rgf.spring.aop.annotation;

import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Component
@Aspect   //将当前组件标识为切面
public class LoggerAspect {

}

我们创建IOC组件如下所示：

<?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:aop="http://www.springframework.org/schema/aop"
       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/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
        <!--
         AOP的注意事项
         切面类和目标类都需要交给IOC容器管理
         切面类必须通过@Aspect注解标识为一个切面
         在spring的配置文件中设置<aop:aspectj-autoproxy/>开启基于注解的AOP
         -->
     <context:component-scan base-package="com.rgf.spring.aop.annotation"></context:component-scan>
    <!--开启基于注解的AOP功能-->
    <aop:aspectj-autoproxy/>
</beans>

我们设置前置通知如下所示：’

package com.rgf.spring.aop.annotation;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * 在切面中，需要通过指定的注解将方法标识为通知方法
 * @Before:前置通知，在目标对象方法执行之前执行
 */
@Component
@Aspect   //将当前组件标识为切面
public class LoggerAspect {
    @Before("execution(public int com.rgf.spring.aop.annotation.CalculatorImpl.add(int,int))")
//通过通知作用于连接点
     public  void  beforeAdviceMethod(){
        System.out.println("LoggerAspect,前置通知");
    }
}

我们进行测试，我们使用目标对象进行测试：

package com.rgf.spring.test;

import com.rgf.spring.aop.annotation.Calculator;
import com.rgf.spring.aop.annotation.CalculatorImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPTest {
    @Test
    public  void   testAOPByAnnotation(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        CalculatorImpl c = ioc.getBean(CalculatorImpl.class);
        c.add(1,1);
    }
}

运行完毕之后，我们发现直接报错：

 我们使用代理对象来访问目标对象中的方法。

package com.rgf.spring.test;

import com.rgf.spring.aop.annotation.Calculator;
import com.rgf.spring.aop.annotation.CalculatorImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPTest {
    @Test
    public  void   testAOPByAnnotation(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator calculator = ioc.getBean(Calculator.class);
        calculator.add(1,2);
    }
}

我们进行运行之后如下所示：

我们在切面中进行修改如下所示：

package com.rgf.spring.aop.annotation;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * 在切面中，需要通过指定的注解将方法标识为通知方法
 * @Before:前置通知，在目标对象方法执行之前执行
 */
@Component
@Aspect   //将当前组件标识为切面
public class LoggerAspect {
   // @Before("execution(public int com.rgf.spring.aop.annotation.CalculatorImpl.add(int,int))")
    //*表示任意返回修饰符和返回值类型,（）表示当前的方法的参数列表,..表示当前任意的方法中的任意的参数列表,类的位置写*，表示当前包下面所有的类，
    //即为包下所有的类和类中所有的方法。
    @Before("execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))")
     public  void  beforeAdviceMethod(){
        System.out.println("LoggerAspect,前置通知");
    }
}

我们继续进行测试：

package com.rgf.spring.test;

import com.rgf.spring.aop.annotation.Calculator;
import com.rgf.spring.aop.annotation.CalculatorImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPTest {
    @Test
    public  void   testAOPByAnnotation(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator calculator = ioc.getBean(Calculator.class);
        calculator.sub(1,2);
        calculator.add(1,2);
        calculator.mul(1,2);
    }
}

运行之后如下所示：

 我们发现此时的前置通知可作用于任何方法。

我们也可以进行获取方法名和参数：

package com.rgf.spring.aop.annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * 在切面中，需要通过指定的注解将方法标识为通知方法
 * @Before:前置通知，在目标对象方法执行之前执行
 *
 * 切入点表达式：设置在标识通知的注解的value属性中，
 * "execution(public int com.rgf.spring.aop.annotation.CalculatorImpl.add(int,int))
 * execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))
 * execution(* com.rgf.spring.aop.*.*.*(..))  (aop包下面的任何一个包，任何一个类，中的任何一个方法都会加上我们当前的通知
 * 第一个*表示任意的访问修饰符和返回值类型
 * 第二个*表示类中任意的方法
 * ..表示任意的参数列表
 * 类的地方也可以使用*，表示包下所有的类
 *
 */
@Component
@Aspect   //将当前组件标识为切面
public class LoggerAspect {
   // @Before("execution(public int com.rgf.spring.aop.annotation.CalculatorImpl.add(int,int))")
    //*表示任意返回修饰符和返回值类型,（）表示当前的方法的参数列表,..表示当前任意的方法中的任意的参数列表,类的位置写*，表示当前包下面所有的类，
    //即为包下所有的类和类中所有的方法。
    @Before("execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))")
     public  void  beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的方法名
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",参数:"+ Arrays.toString(args));
    }
}

我们运行之后如下所示：

 切面优先级及切面简介：

 我们了解的切入点的一些常规如下所示：

package com.rgf.spring.aop.annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * 1.在切面中，需要通过指定的注解将方法标识为通知方法
 * @Before:前置通知，在目标对象方法执行之前执行
 *
 * 2.切入点表达式：设置在标识通知的注解的value属性中，
 * "execution(public int com.rgf.spring.aop.annotation.CalculatorImpl.add(int,int))
 * execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))
 * execution(* com.rgf.spring.aop.*.*.*(..))  (aop包下面的任何一个包，任何一个类，中的任何一个方法都会加上我们当前的通知
 * 第一个*表示任意的访问修饰符和返回值类型
 * 第二个*表示类中任意的方法
 * ..表示任意的参数列表
 * 类的地方也可以使用*，表示包下所有的类
 *
 * 3.重用切入点表达式
 * //@Pointcut声明一个公共的切入点表达式
 * @Pointcut("execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))")
 *     public  void  pointCut(){}
 * 使用方式： @Before("pointCut()")
 * 4.获取连接点的信息
 * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息，
 *获取连接点所对应方法的签名信息
 *Signature signature = joinPoint.getSignature();
 *获取连接点所对应方法的参数
 *Object[] args = joinPoint.getArgs();
 *
 *
 */
@Component
@Aspect   //将当前组件标识为切面
public class LoggerAspect {
    @Pointcut("execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))")
    public  void  pointCut(){}

   // @Before("execution(public int com.rgf.spring.aop.annotation.CalculatorImpl.add(int,int))")
    //*表示任意返回修饰符和返回值类型,（）表示当前的方法的参数列表,..表示当前任意的方法中的任意的参数列表,类的位置写*，表示当前包下面所有的类，
    //即为包下所有的类和类中所有的方法。
    @Before("pointCut()")
     public  void  beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",参数:"+ Arrays.toString(args));
    }
    @After("pointCut()")
    public  void afterAdviceMethod(){

    }
}

测试之后如下所示：

 我们来进行测试后置通知：

package com.rgf.spring.aop.annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * 1.在切面中，需要通过指定的注解将方法标识为通知方法
 * @Before:前置通知，在目标对象方法执行之前执行
 * @After:后置通知，在目标对象方法的finally字句中执行的
 *
 * 2.切入点表达式：设置在标识通知的注解的value属性中，
 * "execution(public int com.rgf.spring.aop.annotation.CalculatorImpl.add(int,int))
 * execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))
 * execution(* com.rgf.spring.aop.*.*.*(..))  (aop包下面的任何一个包，任何一个类，中的任何一个方法都会加上我们当前的通知
 * 第一个*表示任意的访问修饰符和返回值类型
 * 第二个*表示类中任意的方法
 * ..表示任意的参数列表
 * 类的地方也可以使用*，表示包下所有的类
 *
 * 3.重用切入点表达式
 * //@Pointcut声明一个公共的切入点表达式
 * @Pointcut("execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))")
 *     public  void  pointCut(){}
 * 使用方式： @Before("pointCut()")
 * 4.获取连接点的信息
 * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息，
 *获取连接点所对应方法的签名信息
 *Signature signature = joinPoint.getSignature();
 *获取连接点所对应方法的参数
 *Object[] args = joinPoint.getArgs();
 *
 *
 */
@Component
@Aspect   //将当前组件标识为切面
public class LoggerAspect {
    @Pointcut("execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))")
    public  void  pointCut(){}

   // @Before("execution(public int com.rgf.spring.aop.annotation.CalculatorImpl.add(int,int))")
    //*表示任意返回修饰符和返回值类型,（）表示当前的方法的参数列表,..表示当前任意的方法中的任意的参数列表,类的位置写*，表示当前包下面所有的类，
    //即为包下所有的类和类中所有的方法。
    @Before("pointCut()")
     public  void  beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",参数:"+ Arrays.toString(args));
    }
    @After("pointCut()")
    public  void afterAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",执行完毕");


    }
}

我们进行测试，如下所示：

package com.rgf.spring.test;

import com.rgf.spring.aop.annotation.Calculator;
import com.rgf.spring.aop.annotation.CalculatorImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPTest {
    @Test
    public  void   testAOPByAnnotation(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator calculator = ioc.getBean(Calculator.class);
        calculator.div(1,0);
    }
}

运行之后如下所示：

 我们查看异常通知如下所示：

package com.rgf.spring.aop.annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * 1.在切面中，需要通过指定的注解将方法标识为通知方法
 * @Before:前置通知，在目标对象方法执行之前执行
 * @After:后置通知，在目标对象方法的finally字句中执行的
 * @AfterRrturning:返回通知，在目标对象方法返回值之后执行
 * @AfterThrowing:异常通知，在目标对象方法的catch字句中执行
 * 2.切入点表达式：设置在标识通知的注解的value属性中，
 * "execution(public int com.rgf.spring.aop.annotation.CalculatorImpl.add(int,int))
 * execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))
 * execution(* com.rgf.spring.aop.*.*.*(..))  (aop包下面的任何一个包，任何一个类，中的任何一个方法都会加上我们当前的通知
 * 第一个*表示任意的访问修饰符和返回值类型
 * 第二个*表示类中任意的方法
 * ..表示任意的参数列表
 * 类的地方也可以使用*，表示包下所有的类
 *
 * 3.重用切入点表达式
 * //@Pointcut声明一个公共的切入点表达式
 * @Pointcut("execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))")
 *     public  void  pointCut(){}
 * 使用方式： @Before("pointCut()")
 * 4.获取连接点的信息
 * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息，
 *获取连接点所对应方法的签名信息
 *Signature signature = joinPoint.getSignature();
 *获取连接点所对应方法的参数
 *Object[] args = joinPoint.getArgs();
 *
 *
 */
@Component
@Aspect   //将当前组件标识为切面
public class LoggerAspect {
    @Pointcut("execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))")
    public  void  pointCut(){}

   // @Before("execution(public int com.rgf.spring.aop.annotation.CalculatorImpl.add(int,int))")
    //*表示任意返回修饰符和返回值类型,（）表示当前的方法的参数列表,..表示当前任意的方法中的任意的参数列表,类的位置写*，表示当前包下面所有的类，
    //即为包下所有的类和类中所有的方法。
    @Before("pointCut()")
     public  void  beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",参数:"+ Arrays.toString(args));
    }
    @After("pointCut()")
    public  void afterAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",执行完毕");


    }

    //在异常通知中若要获取目标对象方法的异常，
    // 只需要通过@AfterThrowing注解的throwing属性
    //就可以将通知方法的某个参数指定为接受目标对象方法出现的异常的参数
    @AfterReturning(value = "pointCut()",returning = "result")
    public  void afterReturningAdviceMethod(JoinPoint joinPoint,Object result){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",结果:"+result);


    }


    @AfterThrowing(value = "pointCut()",throwing ="ex")
    public  void afterThrowingAdviceMethod(JoinPoint joinPoint,Throwable ex){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",异常:"+ex);


    }
}

进行测试如下所示：

package com.rgf.spring.test;

import com.rgf.spring.aop.annotation.Calculator;
import com.rgf.spring.aop.annotation.CalculatorImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPTest {
    @Test
    public  void   testAOPByAnnotation(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator calculator = ioc.getBean(Calculator.class);
        calculator.div(10,0);
    }
}

运行之后如下所示：

各种通知的执行顺序：

Spring版本5.3x以前：

前置通知

目标操作

后置通知

返回通知或异常通知

Spring版本5.3x以后：

前置通知

目标操作

返回通知或异常通知

后置通知

我们进行测试如下环绕通知：

package com.rgf.spring.aop.annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * 1.在切面中，需要通过指定的注解将方法标识为通知方法
 * @Before:前置通知，在目标对象方法执行之前执行
 * @After:后置通知，在目标对象方法的finally字句中执行的
 * @AfterRrturning:返回通知，在目标对象方法返回值之后执行
 * @AfterThrowing:异常通知，在目标对象方法的catch字句中执行
 * 2.切入点表达式：设置在标识通知的注解的value属性中，
 * "execution(public int com.rgf.spring.aop.annotation.CalculatorImpl.add(int,int))
 * execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))
 * execution(* com.rgf.spring.aop.*.*.*(..))  (aop包下面的任何一个包，任何一个类，中的任何一个方法都会加上我们当前的通知
 * 第一个*表示任意的访问修饰符和返回值类型
 * 第二个*表示类中任意的方法
 * ..表示任意的参数列表
 * 类的地方也可以使用*，表示包下所有的类
 *
 * 3.重用切入点表达式
 * //@Pointcut声明一个公共的切入点表达式
 * @Pointcut("execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))")
 *     public  void  pointCut(){}
 * 使用方式： @Before("pointCut()")
 * 4.获取连接点的信息
 * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息，
 *获取连接点所对应方法的签名信息
 *Signature signature = joinPoint.getSignature();
 *获取连接点所对应方法的参数
 *Object[] args = joinPoint.getArgs();
 *
 *
 */
@Component
@Aspect   //将当前组件标识为切面
public class LoggerAspect {
    @Pointcut("execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))")
    public  void  pointCut(){}

   // @Before("execution(public int com.rgf.spring.aop.annotation.CalculatorImpl.add(int,int))")
    //*表示任意返回修饰符和返回值类型,（）表示当前的方法的参数列表,..表示当前任意的方法中的任意的参数列表,类的位置写*，表示当前包下面所有的类，
    //即为包下所有的类和类中所有的方法。
    @Before("pointCut()")
     public  void  beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",参数:"+ Arrays.toString(args));
    }
    @After("pointCut()")
    public  void afterAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",执行完毕");


    }

    //在返回通知中若要获取目标对象方法的返回值，
    // 只需要通过@AfterThrowing注解的throwing属性
    //就可以将通知方法的某个参数指定为接受目标对象方法出现的返回值的参数
    @AfterReturning(value = "pointCut()",returning = "result")
    public  void afterReturningAdviceMethod(JoinPoint joinPoint,Object result){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",结果:"+result);


    }

    //在异常通知中若要获取目标对象方法的异常，
    // 只需要通过@AfterThrowing注解的throwing属性
    //就可以将通知方法的某个参数指定为接受目标对象方法出现的异常的参数
    @AfterThrowing(value = "pointCut()",throwing ="ex")
    public  void afterThrowingAdviceMethod(JoinPoint joinPoint,Throwable ex){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect,方法:"+signature.getName()+",异常:"+ex);


    }
    //环绕通知的方法的返回值一定要和目标对象方法的返回值一致
    public  Object  aroundAdviceMethod(ProceedingJoinPoint joinPoint){
       Object result=null;
        try {
            System.out.println("环绕通知-->前置通知");
            //表示目标对象方法的执行
            result = joinPoint.proceed();
            System.out.println("环绕通知-->返回通知");
        } catch (Throwable throwable) {
           throwable.printStackTrace();
            System.out.println("环绕通知-->异常通知");
        }finally {
            System.out.println("环绕通知-->后置通知");
        }
      return result;
    }
}

我们进行测试如下所示：

package com.rgf.spring.test;

import com.rgf.spring.aop.annotation.Calculator;
import com.rgf.spring.aop.annotation.CalculatorImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPTest {
    @Test
    public  void   testAOPByAnnotation(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator calculator = ioc.getBean(Calculator.class);
        calculator.div(10,1);
    }
}

运行之后如下所示： 

我们进行验证通知如下：

package com.rgf.spring.aop.annotation;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class ValidateAspect {
  //  @Before("execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))")
    @Before("com.rgf.spring.aop.annotation.LoggerAspect.pointCut()")
    public void beforeMethod(){
        System.out.println("ValidateAspect-->前置通知");
    }

}

运行之后如下所示：

我们发现日志的切面通知在验证前置通知之前，我们来进行转换位置：

package com.rgf.spring.aop.annotation;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 切面的优先级：
 * 可以通过@Order注解的value属性设置优先级，默认值Integer的最大值
 * @Order注解的value属性值越小，优先级越高
 * 
 */
@Component
@Aspect
@Order(1)
public class ValidateAspect {
  //  @Before("execution(* com.rgf.spring.aop.annotation.CalculatorImpl.*(..))")
    @Before("com.rgf.spring.aop.annotation.LoggerAspect.pointCut()")
    public void beforeMethod(){
        System.out.println("ValidateAspect-->前置通知");
    }

}

 我们继续进行运行之后如下所示：