Spring AOP

什么是 Spring AOP

AOP（Aspect Oriented Programming）：面向切面编程，它是一种思想，它是对某一类事情的集中处理。
废话不说第二遍，老规矩，直接来看一张图

如上图所示，三个 service 对象执行过程中都存在安全，事务，缓存，性能等相同行为，这些相同的行为显然应该在同一个地方管理，切面就是为了解决此类问题应运而生的，能做到相同功能的统一管理，对业务代码无侵入。(引入一个自定义的无关工具类也可)

---

AOP 组成

切面（Aspect）、连接点（Join Point） 、切点（Pointcut）、通知（Advice）

切面（Aspect）

切面（Aspect）由切点（Pointcut）和通知（Advice）组成，它既包含了横切逻辑的定义，也包括了连接点的定义。
切面是包含了：通知、切点和切面的类，相当于 AOP 实现的某个功能的集合。

连接点（Join Point）

应用执行过程中能够插入切面的一个点，这个点可以是方法调用时，抛出异常时，甚至修改字段时。切面代码可以利用这些点插入到应用的正常流程之中，并添加新的行为。
连接点相当于需要被增强的某个 AOP 功能的所有方法。

切点（Pointcut）

Pointcut 的作用就是提供一组规则（使用 AspectJ pointcut expression language 来描述）来匹配 Join Point，给满足规则的 Join Point 添加 Advice。
切点相当于保存了众多连接点的一个集合（如果把切点看成一个表，而连接点就是表中一条一条的数据）。

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

通知（Advice）

定义了切面是什么，何时使用，其描述了切面要完成的工作，还解决何时执行这个工作的问题。Spring 切面类中，可以在方法上使用以下注解，会设置方法为通知方法，在满足条件后会通知本方法进行调用。

• 前置通知使用 @Before：通知方法会在目标方法调用之前执行。
• 后置通知使用 @After：通知方法会在目标方法返回或者抛出异常后调用。
• 返回之后通知使用 @AfterReturning：通知方法会在目标方法返回后调用。
• 抛异常后通知使用 @AfterThrowing：通知方法会在目标方法抛出异常后调用。
• 环绕通知使用 @Around：通知包裹了被通知的方法，在被通知的方法通知之前和调用之后执行自定义的行为。

举个（以多个页面都要访问用户登录权限为）：

---

Spring AOP 实现

1. 添加 Spring AOP 框架支持。

在 pom.xml 中添加支持：

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2. 定义切面和切点。

切点指的是具体要处理的某一类问题，比如用户登录权限验证就是一个具体的问题，记录所有方法的执行日志就是一个具体的问题，切点定义的是某一类问题。
Spring AOP 切点的定义如下，在切点中我们要定义拦截的规则，具体实现如下：

package com.example.demo;

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

@Aspect
// 表明此类为一个切面
@Component
public class UserAspect {
    // 定义切点，这里使用 AspectJ 表达式语法
    @Pointcut("execution(* com.example.demo.UserController.*(..))")
    public void pointcut() {
    }
}

不要着急看execution，这个再往后看60秒保证你就懂了

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

AspectJ 支持三种通配符：

• * ：匹配任意字符，只匹配一个元素（包，类，或方法，方法参数）。
• * . . ：匹配任意字符，可以匹配多个元素 ，在表示类时，必须和 * 联合使用。
• + ：表示按照类型匹配指定类的所有类，必须跟在类名后面，如 com.cad.Car+ ,表示继承该类的所有子类包括本身。

切点表达式由切点函数组成，其中 execution() 是最常用的切点函数，用来匹配方法，修饰符和异常可以省略。语法为：
execution(<修饰符><返回类型><包.类.方法(参数)><异常>)

废话不说第二遍，给大家几个：

3. 定义通知。

通知定义的是被拦截的方法具体要执行的业务，比如用户登录权限验证方法就是具体要执行的业务。
Spring AOP 中，可以在方法上使用以下注解，会设置方法为通知方法，在满足条件后会通知本方法进行调用：

• 前置通知使用@Before：通知方法会在目标方法调用之前执行。
• 后置通知使用@After：通知方法会在目标方法返回或者抛出异常后调用。
• 返回之后通知使用@AfterReturning：通知方法会在目标方法返回后调用。
• 抛异常后通知使用@AfterThrowing：通知方法会在目标方法抛出异常后调用。
• 环绕通知使用@Around：通知包裹了被通知的方法，在被通知的方法通知之前和调用之后执行自定义的行为。

老规矩完善上面的那个：

package com.example.demo;

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

@Aspect
// 表明此类为一个切面
@Component
public class UserAspect {
    // 定义切点，这里使用 AspectJ 表达式语法
    @Pointcut("execution(* com.example.demo.UserController.*(..))")
    public void pointcut() {
    }
    // 前置通知
    @Before("pointcut()")
    public void doBefore() {
        System.out.println("执行 Before 方法");
    }

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

    // return 之前通知
    @AfterReturning("pointcut()")
    public void doAfterReturning() {
        System.out.println("执行 AfterReturning 方法");
    }

    // 抛出异常之前通知
    @AfterThrowing("pointcut()")
    public void doAfterThrowing() {
        System.out.println("执行 doAfterThrowing 方法");

    }

    // 添加环绕通知
    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) {
        Object obj = null;
        System.out.println("Around 方法开始执行");
        try {
            // 执行拦截方法
            obj = joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("Around 方法结束执行");
        return obj;
    }

}

对比感受一下。。。

---

Spring AOP 实现原理

Spring AOP 是构建在动态代理基础上，因此 Spring 对 AOP 的支持局限于方法级别的拦截。
Spring AOP 支持 JDK Proxy 和 CGLIB 方式实现动态代理。默认情况下，实现了接口的类，使用 AOP 会基于 JDK 生成代理类，没有实现接口的类，会基于 CGLIB 生成代理类。
来看一张图：

织入（Weaving）

即代理的生成时机，织入是把切面应用到目标对象并创建新的代理对象的过程，切面在指定的连接点被织入到目标对象中。在目标对象的生命周期里有多个点可以进行织入：

• 编译期：切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的。
• 类加载期：切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器（ClassLoader）,它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ5的加载时织入（load-timeweaving. LTW）就支持以这种方式织入切面。
• 运行期：切面在应用运行的某一时刻被织入。一般情况下，在织入切面时，AOP> 容器会为目标对象
  动态创建一个代理对象。SpringAOP就是以这种方式织入切面的。

动态代理

此种实现在设计模式上称为动态代理模式，在实现的技术手段上，都是在 class 代码运行期，动态的织入字节码。我们学习 Spring 框架中的AOP，主要基于两种方式：JDK 及 CGLIB 的方式。这两种方式的代理目标都是被代理类中的方法，在运行期，动态的织入字节码生成代理类。

• CGLIB是Java中的动态代理框架，主要作用就是根据目标类和方法，动态生成代理类。
• Java中的动态代理框架，几乎都是依赖字节码框架（如 ASM，Javassist 等）实现的。
• 字节码框架是直接操作 class 字节码的框架。可以加载已有的class字节码文件信息，修改部分信息，或动态生成一个 class。

JDK 和 CGLIB 的区别:

1. JDK 实现，要求被代理类必须实现接口，之后是通过 InvocationHandler 及 Proxy，在运行时动态的在内存中生成了代理类对象，该代理对象是通过实现同样的接口实现（类似静态代理接口实现的方式），只是该代理类是在运行期时，动态的织入统一的业务逻辑字节码来完成。
2. CGLIB 实现，被代理类可以不实现接口，是通过继承被代理类，在运行时动态的生成代理类对象。

---