文章目录

AOP概念及相关术语
- - 概述
  - 为什要用 AOP
- 相关术语
- - 横切关注点
  - Advice通知
  - Join Point连接点
  - Point CUT 切入点
  - 切面
  - 目标
  - 代理
基于注解的SpringAOP
- - 准备工作
- 切入点表达式语法
- 重用切入点表达式
- 对应的切面
- - 前置通知
  - 返回通知
  - 异常通知
  - 后置通知
  - 环绕通知
- 切面的优先级
- 总结Spring AOP 的实现步骤

AOP概念及相关术语

概述

AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

能将哪些与核心业务无关的，却为业务模块所共同调用的逻辑或者责任（事务管理，日志管理，权限控制等）封装起来（这些是不能依靠面对对象的思想进行封装复用的），便于减少系统的重复代码，降低模块间的耦合度

比如用户获奖权限的效验，没学 AOP 之前，我们所有需要判断用户获奖权限的页面（中的方法），都要各自实现或调用用户验证的方法，然而有了 AOP 之后，我们只需要在某一处配置一下，所有需要判断用户中将权限页面（中的方法）就全部可以实现用户用户中将权限验证了，不再需要每个方法中都写相同的用户登录验证了。

为什要用 AOP

为什要用 AOP？想象一个场景，我们在做后台系统时，除了登录和注册等几个功能不需要做用户登录验证之外，其他几乎所有页面调用的前端控制器（ Controller）都需要先验证用户登录的状态，那这个时候我们要怎么处理呢？

我们之前的处理方式是每个 Controller 都要写一遍用户登录验证，然而当你的功能越来越多，那么你要写的登录验证也越来越多，而这些方法又是相同的，这么多的方法就会代码修改和维护的成本。那有没有简单的处理方案呢？答案是有的，对于这种功能统一，且使用的地方较多的功能，就可以考虑 AOP来统一处理了。在不惊动原始设计的基础上进行功能增强
除了统一的用户登录判断之外，AOP 还可以实现

统一日志记录
统一方法执行时间统计
统一的返回格式设置
统一的异常处理
事务的开启和提交等

也就是说使用 AOP 可以扩充多个对象的某个能力，所以 AOP 可以说是 OOP（Object OrientedProgramming，面向对象编程）的补充和完善。

基于注解的SpringAOP

AOP 是一种思想，而 Spring AOP 是一个框架，提供了一种对 AOP 思想的实现

Spring下的AOP,Java AOP做的比较早的AspectJ库，是相当于做的比较早，Spring的AOP的在使用方式的时候，很多也延续了AspectJ的方式技术说明

Spring AOP是基于动态代理的

如果它要代理的对象实现了某个接口，那么Spring AOP就会使用JDK的动态代理去创建代理对象，
- 因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）。
而对没有实现接口的对象，就无法使用JDK的动态代理，转而使用CGLIB动态代理生成一个被代理对象子类来作为代理
- 通过继承被代理的目标类（认干爹模式)实现代理，所以不需要目标类实现接口
AspectJ：本质上是静态代理，将代理逻辑“织入”被代理的目标类编译得到的字节码文件，所以最终效果是动态的。weaver就是织入器。
- Spring只是借用了AspectJ中的注解

Aspectl是Java的AOP领域的领头羊，所以它的方案基本就称为Java AOP的标准存在了，所以AspectJ定义了一组表达式的语法，来描述Pointcut（切入点）,所以Spring AOP也使用这种表达式，Spring AOP和AspectJ（也是一种AOP框架）之间其实是没有关系的
就像我们很多聊天软件都采用了这种聊天框

准备工作

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

<!-- spring-aspects会帮我们传递过来aspectjweaver -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.3.1</version>
</dependency>

准备被代理的目标资源

接口：

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);

}

实现类

@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;
    }
}

对应的xml文件配置

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

    <!--开启基于注解的AOP-->
    <aop:aspectj-autoproxy />
</beans>

我们的Spring AOP功能还是基于我们的IOC容器，IOC容器是我们最核心的功能
- 我们的切面类和目标类都需要交给我们的IOC容器进行管理
需要在xml中开启注解AOP的功能

切入点表达式语法

作用

语法细节

用*号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限
在包名的部分，一个“*”号只能代表包的层次结构中的一层，表示这一层是任意的。
- 例如：*.Hello匹配com.Hello，不匹配com.lsc.Hello
- 在包名的部分，使用“*…”表示包名任意、包的层次深度任意
在类名的部分，类名部分整体用*号代替，表示类名任意
- 在类名的部分，可以使用*号代替类名的一部分
  - 例如：*Service匹配所有名称以Service结尾的类或接口
在方法名部分，可以使用*号表示方法名任意
- 在方法名部分，可以使用*号代替方法名的一部分
  - 例如：*Operation匹配所有方法名以Operation结尾的方法
在方法参数列表部分，使用(…)表示参数列表任意
- 在方法参数列表部分，使用(int,…)表示参数列表以一个int类型的参数开头
- 在方法参数列表部分，基本数据类型和对应的包装类型是不一样的
  - 切入点表达式中使用 int 和实际方法中 Integer 是不匹配的
在方法返回值部分，如果想要明确指定一个返回值类型，那么必须同时写明权限修饰符
- 例如：execution(public int …Service.*(…, int)) 正确
- 例如：execution(* int …Service.*(…, int)) 错误

AspectJ 支持三种通配符：

*：匹配任意字符，只匹配一个元素（包，类，或方法，方法参数）。

… ：匹配任意字符，可以匹配多个元素，在表示类时，必须和 * 联合使用。

+: 表示按照类型匹配指定类的所有类，必须跟在类名后面，如 com.cad.Car+ ,表示继承该类的所有子类包括本身

重用切入点表达式

声明

@Pointcut("execution(* com.atguigu.aop.annotation.*.*(..))")
public void pointCut(){}

在同一个切面中使用

@Before("pointCut()")
public void beforeMethod(JoinPoint joinPoint){
	String methodName = joinPoint.getSignature().getName();
	String args = Arrays.toString(joinPoint.getArgs());
	System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
}

在不同切面中使用

@Before("com.atguigu.aop.CommonPointCut.pointCut()")
public void beforeMethod(JoinPoint joinPoint){
	String methodName = joinPoint.getSignature().getName();
	String args = Arrays.toString(joinPoint.getArgs());
	System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
}

对应的切面

前置通知

前置通知：使用@Before注解标识，在被代理的目标方法前执行

@Component//保证这个切面类能够放入IOC容器
@Aspect//将当前组件标识为切面
public class LoggerAspect {
    @Pointcut("execution(* com.lsc.spring.aop.annotation.CalculatorImpl.*(..))")
    public void pointCut(){}
    //@Before("execution(public int com.lsc.spring.aop.annotation.CalculatorImpl.add(int, int))")
    //@Before("execution(* com.lsc.spring.aop.annotation.CalculatorImpl.*(..))")
    @Before("pointCut()")
    public void beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature=joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect，方法："+signature.getName()+"，参数："+ Arrays.toString(args));
    }
}

测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator bean = ioc.getBean(Calculator.class);
        bean.add(1,2);
    }
}
//输出结果
LoggerAspect，方法：add，参数：[1, 2]
方法内部，result：3

返回通知

@after-returning 返回通知：在被代理的目标方法成功结束后执行（寿终正寝）

测试

  @AfterReturning(value = "execution(* com.lsc.spring.aop.annotation.CalculatorImpl.*(..))",
    returning = "result")
    public void afterReturnMethod(JoinPoint joinPoint,Object result){
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect，方法："+signature.getName()+"，参数："+ Arrays.toString(args)+
                "结果为"+result);

    }
//结果    
方法内部，result：3
LoggerAspect，方法：add，参数：[1, 2]结果为3

returning = “result”,将方法返回的结果存储到result

异常通知

在被代理的目标方法异常结束后执行（死于非命）

  @AfterThrowing(value = "pointCut()" ,throwing = "ex")
    public void afterThrowMethod(JoinPoint joinPoint,Exception ex){
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect，方法："+signature.getName()+"，参数："+ Arrays.toString(args)+
                "异常为"+ex);
    }

throwing表示发生的异常类型

public class Test {
    public static void main(String[] args) {
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator bean = ioc.getBean(Calculator.class);
        bean.div(1,0 );//1/0会爆出异常
    }
}
LoggerAspect，方法：div，参数：[1, 0]异常为java.lang.ArithmeticException: / by zero

后置通知

后置通知：在被代理的目标方法最终结束后执行（盖棺定论）类似我们在finally里面的语句

public class Test {
    public static void main(String[] args) {
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator bean = ioc.getBean(Calculator.class);
        bean.div(1,0 );
    }
}
//输出结果
Logger-->后置通知，方法名：div

虽然报了异常，但是还是会输出
- 不管是正常结束，还是异常结束，都会执行

环绕通知

使用try…catch…finally结构围绕整个被代理的目标方法，能用一个环绕通知实现上面四个类型

 @Around("pointCut()")
    public Object aroundMethod(ProceedingJoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        String args = Arrays.toString(joinPoint.getArgs());
        Object result = null;
        try {
            System.out.println("环绕通知-->目标对象方法执行之前——>这个位置类似@before");
            //目标对象（连接点）方法的执行
            result = joinPoint.proceed();
            System.out.println("环绕通知-->目标对象方法返回值之后——>这个位置类似@afterReturning");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("环绕通知-->目标对象方法出现异常时——>这个位置类似@afterThrowing");
        } finally {
            System.out.println("环绕通知-->目标对象方法执行完毕——>这个位置类似@after");
        }
        return result;
    }

测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator bean = ioc.getBean(Calculator.class);
        bean.add(1,2);
    }
}
//输出结果
环绕通知-->目标对象方法执行之前——>这个位置类似@before
方法内部，result：3
环绕通知-->目标对象方法返回值之后——>这个位置类似@afterReturning
环绕通知-->目标对象方法执行完毕——>这个位置类似@after

切面的优先级

相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。

优先级高的切面：外面
优先级低的切面：里面

使用@Order注解可以控制切面的优先级：

@Order(较小的数)：优先级高
@Order(较大的数)：优先级低
默认是int的最大值

ValidateAspect切面

@Component
@Order(1)
@Aspect
public class ValidateAspect {
    @Pointcut("execution(* com.lsc.spring.aop.annotation.CalculatorImpl.*(..))")
    public void pointCut(){}
    @Before("pointCut()")
    public void beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature=joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("ValidateAspect，方法："+signature.getName()+"，参数："+ Arrays.toString(args));
    }
    @After("pointCut()")
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("ValidateAspect-->后置通知，方法名："+methodName);
    }
}

LoggerAspect切面

@Component
@Aspect//将当前组件标识为切面
public class LoggerAspect {
    @Pointcut("execution(* com.lsc.spring.aop.annotation.CalculatorImpl.*(..))")
    public void pointCut(){}
    @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 afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("LoggerAspect-->后置通知，方法名："+methodName);
    }
}

测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator bean = ioc.getBean(Calculator.class);
        bean.add(1,2);
    }
}
//输出结果
ValidateAspect，方法：add，参数：[1, 2]
LoggerAspect，方法：add，参数：[1, 2]
方法内部，result：3
LoggerAspect-->后置通知，方法名：add
ValidateAspect-->后置通知，方法名：add

总结Spring AOP 的实现步骤

添加 Spring AOP 框架支持。导入相应的jar包
定义接口和相应的实现类，也就是我们的程序，程序中的方法可以作为切入点，进行功能增强
定义通知类（存放我们的切面）@Aspect修饰类，并且让这个通知类被SpringIoc容器管理，生产对应的bean，我们的被切入的类也需要被SpringIoc容器管理
在通知类（切面）定义切入点，用PointCut()进行匹配对应的连接点
进行我们的通知的定义（具体的增强功能的逻辑，用方法的形式实现），然后跟对应的切入点建立对应的联系 @Before之类
开启对Aop注解驱动支持 (SpringBoot会自动帮我们做这些配置)