Spring AOP

1. 什么是Spring AOP?

OOP想必都很熟悉了，也就是我们所说的面向对象编程，而AOP又是什么呢？它也是一种编程思想，AOP是面向切面编程，面向切面编程思想是对程序的某一类(某一方面)的功能进行统一处理。如果没有使用AOP做登录的校验，那么每一个需要判断用户是否的登录的地方都需要进行判断是否登录，就算把判断登录封装成一个函数，也要在不同的地方就行调用，同样是多次调用，而如果使用AOP那么只需要在一个地方统一配置需要判断是否登录的方法，就可以实现用户登录判断了，不用再去每个方法里重复调用登录判断函数了。所以AOP思想就是对某一类事情的集中处理。

AOP是一种编程思想，而SpringAOP是一个框架，是AOP思想的具体实现。

2. 为什么要使用AOP？

假设我们要实现一个网页后台代码，处了登录和注册等几个特殊功能不需要进行登录验证，其它的所有页面和功能都需要调用Controller控制器进行用户登录验证，如果后面的功能越来越多验证的代码也越写越多，每个Controller中写的都是同样一份验证代码，就会导致的代码的冗余和维护成本变高。对于这种统一的功能，就可以使用AOP处理了。

除了登录的统一处理以外，AOP还可以实现：

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

也就是说AOP可以对对个对象的某个能力进行扩充，所以AOP可以说是OOP的补充和完善。

3. AOP的组成

切面(Aspect)

切面(Aspect)由切点(Pointcut)和通知(Advice)组成，它既包含了横切逻辑的定义，也包含连接点的定义。

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

连接点(Join Point)

应用执行过程中能够插入切面的一个点，这个点可以是方法调用时，抛出异常时，甚至修改字段数时。切面代码可以利用这些插入点插入到应用的正常执行流程之中，并添加新的行为。

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

切点(Pointcut)

Pointcut是匹配JoinPoint的谓词

切点的作用就是提供一组规则(使用 AspectJ来描述)来匹配连接点，给满足规则的连接点添加通知。

切点相当于保存了众多连接点的一个集合(如果把切点看成一个表，而连接点就是表中一条一条的数据)

通知

切面也是有目标的，它必须完成的工作，在AOP术语中，切面的工作被称之为通知

通知：定义了切面是什么，什么时候使用，描述了了切面要完成的工作，还解决何时执行这个工作的问题。

Spring切面类中，可以在方法上使用一下注解，会设置方法为通知方法，在满足条件后会通知本方法进行调用：

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

总结

• 切点：假设做做用户登录验证的，切点就是一个空方法
• 而通知就是用户登录验证方法的具体实现
• 连接点：用来匹配切面的多个点，就是需要调用登录验证的多个外部方法
• 而切面就是由切点、通知和连接点组成一个切面，组成了一个功能。
• 通过通知还可以规定方法的执行时机

• 整个切面就是一个类
• 切点是一个方法的定义，也就是一个空方法
• 而通知就是空方法的具体实现
• 连接点就是外部调用切点的方法

4. Spring AOP实现

SpringAOP的实现步骤：

1. 添加SpringAOP框架支持
2. 定义切面和切点
3. 定义通知

1)添加AOP依赖

去Maven中央仓库找到SpringBootAOP依赖，添加到pom.xml

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-aop -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2)定义切面和切点

切点指的是具体要处理的某一类问题，比如用户登录权限验证就是一个具体的问题。比如登录权限验证就是一个具体的问题，记录所有方法的执行日志就是一个具体的问题，切点定义的就是某一类问题。

• 给某一个类添加一个@Aspect注解，就说明这个类是一个AOP
• 使用@Pointcut注解定义一个空方法，这个空方法就是一个切点
• 通过@Pointcut注解里的值,定义试用的连接点都有哪些，也就是在哪些场景下我会调用这个切点

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

其中 pointcut方法为空方法，它不需要有方法体，此方法名就是起到一个标识的作用，标识下面的通知方法具体指定的是哪个切点，因为切点是会有多个的

切点的AspectJ表达式语法说明：

AspectJ支持三种通配符

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

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

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

修饰符和异常是可以省略的

示例：

• excution(* com.demo.controller.UserController.*(..))：匹配UserController类里的所有方法
• excution(* com.demo.controller.UserControler+.*(..))：匹配该类的子类包括该类的所有方法
• excution(* com.demo.*.*(..))：匹配 com.demo包下的所有类的所有方法
• excution(* com.demo..*.*(..))：匹配com.demo包下、子孙包下所有类的所有方法
• excution(* login(String,String))：配置login方法。并且方法两个参数都是String

3)定义相关通知

通知定义的是被拦截的方法具体要执行的业务，比如登录权限验证方法就是具体要执行的业务。定义通知有5大注解

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

具体实现代码

@Aspect // 说明该类为一个切面
@Component
public class UserAspect {

    // 定义切点,使用 AspectJ表达式语法
    @Pointcut("execution(* com.example.demo.controller.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 result = null;
        System.out.println("执行环绕通知的前置方法");

        try {
            // 执行(拦截的)业务方法
            result = joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("执行环绕通知的后置方法");

        return result;
    }
}

当我们访问UserController下的方法时就会先执行对应的通知方法，其中比较特别就是环绕通知，它是在执行业务方法前和执行业务方法后都会执行通知。

5. Spring AOP实现原理

SpringAOP是构建在动态代理基础上的，因此Spring对AOP的支持局限于方法级别的拦截。

SpringAOP支持JDKProxy和CGLIB方式实现动态代理，默认情况下，实现了接口的类或者被final修饰的类，使用AOP会基于JDK来生成代理类，没有实现接口的类，会基于CGLIB来生成代理类。

Spring的切面由包裹了目标对象的代理类实现、代理类处理方法调用，执行额外的切面逻辑，并调用目标方法。

织入：代理的生成时机

织入是把切面应用到目标对象并创建的代理对象的过程，切面在指定的连接点被织入到目标对象中。

在目标对象的生命周期里有多个点可以进行织入：

• 编译期：切面在目标类编译时被织入。这种方式需要特殊的编译器，AspectJ的织⼊编译器就
  是以这种⽅式织⼊切⾯的。
• 类加载器：切面在目标类被引入应用之前增强该目标类的字节码，AspectJ5的加载时织入就支持以这种方式织入切面
• 运行期：切面在应用运行的某一时刻被织入。一般情况下，在织入切面时，AOP容器会以目标对象动态创建一个代理对象，SpringAOP 就是以这种方式织入切面的。

动态代理

这种实现在设计模式上称为动态代理模式，在实现的技术手段上，都是在class代码运行期间，动态的织入字节码。

Spring框架中的AOP，主要基于两种方式：JDK以及CGLIB的方式。这两种方式都是被代理类中的方法，在运行期间，动态的织入字节码生成代理类。

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

JDK 和 CGLIB 实现的区别

1. JDK 实现，要求被代理类必须实现接⼝，之后是通过 InvocationHandler 及 Proxy，在运⾏时
   动态的在内存中⽣成了代理类对象，该代理对象是通过实现同样的接⼝实现（类似静态代理
   接⼝实现的⽅式），只是该代理类是在运⾏期时，动态的织⼊统⼀的业务逻辑字节码来完
   成。
2. CGLIB 实现，被代理类可以不实现接⼝，是通过实现被代理类，在运⾏时动态的⽣成代理类
   对象。
   s字节码的框架，可以加载已有的class字节码文件信息，修改部分信息，或者动态生成一个class

JDK 和 CGLIB 实现的区别

1. JDK 实现，要求被代理类必须实现接⼝，之后是通过 InvocationHandler 及 Proxy，在运⾏时
   动态的在内存中⽣成了代理类对象，该代理对象是通过实现同样的接⼝实现（类似静态代理
   接⼝实现的⽅式），只是该代理类是在运⾏期时，动态的织⼊统⼀的业务逻辑字节码来完
   成。
2. CGLIB 实现，被代理类可以不实现接⼝，是通过实现被代理类，在运⾏时动态的⽣成代理类
   对象。
3. 针对于不同的代理类，使用的技术是不一样的，如果被代理的对象是一个普通类那么使用的就是CGLIB ,CGLIB不能代理被final修饰和没有实现接口的类，这个时候就要使用JDK官方的动态代理，当然CGLIB不是官方提供的，它的性能计较高。