Spring AOP

1. 什么是 Spring AOP?

先说说什么是 AOP（Aspect Oriented Programming）:⾯向切⾯编程，和 OOP(面向对象编程)类似,它是⼀种思想，它是对某⼀类事情的集中处理

⽐如⽤户登录权限的效验，没学 AOP 之前，我们所有需要判断⽤户登录的⻚⾯（中的⽅法），都要各⾃实现或调⽤⽤户验证的⽅法，然⽽有了 AOP 之后，我们只需要在某⼀处配置⼀下，所有需要判断⽤户登录⻚⾯（中的⽅法）就全部可以实现⽤户登录验证了，不再需要每个⽅法中都写相同的⽤户登录验证了。

AOP 是⼀种思想，⽽ Spring AOP 是⼀个框架，提供了⼀种对 AOP 思想的实现，它们的关系和 IoC与 DI 类似。

我们学习 Spring AOP 主要分以下 3 个部分:

1. 学习 AOP 是如何组成的？也就是学习 AOP 组成的相关概念。
2. 学习 Spring AOP 使⽤。
3. 学习 Spring AOP 实现原理。

2. AOP 组成

1. 切面
2. 连接点
3. 切点
4. 通知

2.1 切面(Aspect)

定义 AOP 是针对哪个统一的功能的,这个功能就叫做一个切面,比如用户登录功能或方法的统计日志,他们各种功能代表一个切面. 切面由切点加通知组成的.

切⾯是包含了：通知、切点和切⾯的类，相当于 AOP 实现的某个功能的集合.

2.2 连接点(Join Point)

所有可能触发 AOP (拦截方法的点) 就称之为连接点.

这个点可以是⽅法调⽤时，抛出异常时，甚⾄修改字段时。切⾯代码可以利⽤这些点插⼊到应⽤的正常流程之中，并添加新的⾏为.

连接点相当于需要被增强的某个 AOP 功能的所有⽅法.

2.3 切点(Pointcut)

定义 AOP 拦截的规则的.

切点相当于保存了众多连接点的⼀个集合（如果把切点看成⼀个表，⽽连接点就是表中⼀条⼀条的数据）

2.4 通知(Advice)

切⾯也是有⽬标的 ——它必须完成的⼯作。在 AOP 术语中，切⾯的⼯作被称之为通知。

通知: 规定 AOP 执行的时机和执行的方法.

Spring 切⾯类中，可以在⽅法上使⽤以下注解，会设置⽅法为通知⽅法，在满⾜条件后会通知本⽅法进⾏调⽤：

1. 前置通知使⽤ @Before： 通知⽅法会在⽬标⽅法调⽤之前执⾏。
2. 后置通知使⽤ @After： 通知⽅法会在⽬标⽅法返回或者抛出3异常后调⽤。
3. 返回之后通知使⽤ @AfterReturning： 通知⽅法会在⽬标⽅法返回后调⽤。
4. 抛异常后通知使⽤ @AfterThrowing： 通知⽅法会在⽬标⽅法抛出异常后调⽤。
5. 环绕通知使⽤ @Around： 通知包裹了被通知的⽅法，在被通知的⽅法通知之前和调⽤之后执⾏⾃定义的⾏为。

切点相当于要增强的⽅法。

AOP 整个组成部分的概念如下图所示，以多个⻚⾯都要访问⽤户登录权限为例:

3. Spring AOP 的使用

1. 在项目中添加 Spring AOP 框架.
2. 定义切面
3. 定义切点
4. 实现通知

3.1 添加 Spring AOP 框架

在 pom.xml 中添加依赖,(去maven 中央仓库官网查找依赖)

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-aopartifactId>
        dependency>

3.2 定义切面

@Aspect //当前类是一个切面
@Component
public class UserAspect {

}

3.3 定义切点,设置拦截规则

@Aspect //当前类是一个切面
@Component
public class UserAspect {

    // 定义切点，这⾥使⽤ AspectJ 表达式语法
    @Pointcut("execution(* com.example.demo.controller.UserController.* (..))")
    public void pointcut(){

    }
}
    

其中 pointcut ⽅法为空⽅法，它不需要有⽅法体，此⽅法名就是起到⼀个“标识”的作⽤，标识下⾯的通知⽅法具体指的是哪个切点（因为切点可能有很多个）。

3.3.1 Aspect 语法中的通配符

1. * : 表示匹配任意的内容,用在返回值,包名,类名,方法都可以使用
2. .. : 匹配任意字符,可以使用在方法参数上,如果用在类上需要配合 * 一起使用
3. + : 表示匹配指定类及其它底下的所有子类,比如 com.Car+ 表示匹配 Car 及其所有子类

3.3.2 AspectJ 语法(Spring AOP 切点的匹配方法)

切点表达式由切点函数组成，其中 execution() 是最常⽤的切点函数，⽤来匹配⽅法，语法为：

execution(<修饰符><返回类型><包.类.⽅法(参数)><异常>)

修饰符: 一般省略
返回类型: 不能省略
类: 一般情况下要有,但也可以省略
方法名: 不能省略
参数: 不能省略
异常: 可省略,一般不写

示例:
execution(* com.cad.demo.User.*(..)) ：匹配 User 类⾥的所有⽅法。
execution(* com.cad.demo.User+.*(..)) ：匹配该类的⼦类包括该类的所有⽅法。
execution(* com.cad.*.*(..)) ：匹配 com.cad 包下的所有类的所有⽅法。
execution(* com.cad..*.*(..)) ：匹配 com.cad 包下、⼦孙包下所有类的所有⽅法。
execution(* addUser(String, int)) ：匹配 addUser ⽅法，且第⼀个参数类型是 String，第⼆个参数类型是 int。

3.4 通知

1. 前置通知
2. 后置通知
3. 返回之后通知
4. 抛出异常之后通知
5. 环绕通知

3.4.1 前置通知(@Before)

在执行目标方法[拦截方法]之前的通知

/**
     * 定义 pointcut 切点的前置通知
     * 在执行目标方法执行之前的方法就叫做前置通知
     */
    @Before("pointcut()")
    public void doBefore(){
        System.out.println("前置通知: 执行了");
    }

启动之后:

先执行的前置方法.

3.4.2 后置通知(@After)

执行目标方法之后执行的方法

/**
     * 针对 pointcut 切点的后置通知
     */
    @After("pointcut()")
    public void doAfter(){
        System.out.println("后置通知方法执行");
    }

3.4.3 返回之后的通知(@AfterReturning)

@AfterReturning("pointcut()")
    public void doAfterReturning(){
        System.out.println("执行了 AfterReturning 方法");
    }

3.4.4 抛出异常之后的通知(@AfterThrowing)

设置一个异常:

@AfterThrowing("pointcut()")
    public void doAfterThrowing(){
        System.out.println("执行了 AfterThrowing 方法");
    }

3.4.5 环绕通知(@Around)

@Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint){
        Object result = null;
        System.out.println("环绕通知: 前置方法");
        try {
            result = joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("环绕通知: 后置方法");
        return result;
    }

使用环绕通知实现统计每个方法的执行时间:

 @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint){
        //spring 中的时间统计对象
        StopWatch stopWatch = new StopWatch();
        Object result = null;
        try {
            stopWatch.start(); // 统计方法的执行时间,开始计时
            result = joinPoint.proceed();
            stopWatch.stop(); // 统计方法的执行时间,停止计时
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println(joinPoint.getSignature().getDeclaringTypeName() + "." +
                joinPoint.getSignature().getName() + " 方法执行花费的时间：" +
                stopWatch.getTotalTimeMillis() + "ms");

        return result;
    }

4. Spring AOP 实现原理

Spring AOP 是构建在动态代理基础上，因此 Spring 对 AOP 的⽀持局限于⽅法级别的拦截.

Spring AOP ⽀持 JDK Proxy 和 CGLIB ⽅式实现动态代理。默认情况下，实现了接⼝的类，使⽤AOP 会基于 JDK ⽣成代理类，没有实现接⼝的类，会基于 CGLIB ⽣成代理类

织⼊（Weaving）：代理的⽣成时机

织⼊是把切⾯应⽤到⽬标对象并创建新的代理对象的过程，切⾯在指定的连接点被织⼊到⽬标对象中。
在⽬标对象的⽣命周期⾥有多个点可以进⾏织⼊：

1. 编译期：切⾯在⽬标类编译时被织⼊。这种⽅式需要特殊的编译器。AspectJ的织⼊编译器就是以这种⽅式织⼊切⾯的。
2. 类加载器：切⾯在⽬标类加载到JVM时被织⼊。这种⽅式需要特殊的类加载器（ClassLoader）,它可以在⽬标类被引⼊应⽤之前增强该⽬标类的字节码。AspectJ5的加载时织⼊（load-time weaving. LTW）就⽀持以这种⽅式织⼊切⾯。
3. 运⾏期：切⾯在应⽤运⾏的某⼀时刻被织⼊。⼀般情况下，在织⼊切⾯时，AOP容器会为⽬标对象动态创建⼀个代理对象。SpringAOP就是以这种⽅式织⼊切⾯的。

动态代理: 此种实现在设计模式上称为动态代理模式，在实现的技术⼿段上，都是在 class 代码运⾏期，动态的织⼊字节码。

Spring AOP 动态代理实现:

1. JDK Proxy(JDK 动态代理): JDK 实现，要求被代理类必须实现接⼝，之后是通过 InvocationHandler 及 Proxy，在运⾏时动态的在内存中⽣成了代理类对象，该代理对象是通过实现同样的⼝实现（类似静态代理接⼝实现的⽅式），只是该代理类是在运⾏期时，动态的织⼊统⼀的业务逻辑字节码来完成。

2. CGLIB Proxy : 默认情况下 Spring AOP 都会采用 CGLIB 来实现动态代理.它的实现原理是通过继承代理对象来实现动态代理的(子类拥有父类的所有功能),但是,缺点是不能代理最终类(也就是被 final 修饰的类)