【Spring AOP】Spring AOP 详解

Spring AOP 详解

一. 什么是 AOP
二. AOP 组成
- 切面（Aspect）
- 连接点（Join Point）
- 切点（Pointcut）
- 通知（Advice）
三. Spring AOP 实现
- 1. 添加 AOP 框架⽀持
- 2. 定义切面和切点
- 3. 定义相关通知
四. Spring AOP 实现原理
- 动态代理
- JDK 和 CGLIB 实现的区别

一. 什么是 AOP

AOP（Aspect Oriented Programming）：⾯向切⾯编程，它是⼀种思想，它是对某⼀类事情的集中处理。

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

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

除了统⼀的⽤户登录判断之外，AOP 还可以实现：

统⼀⽇志记录
统⼀⽅法执⾏时间统计
统⼀的返回格式设置
统⼀的异常处理
事务的开启和提交等

也就是说使⽤ AOP 可以扩充多个对象的某个能⼒，所以 AOP 可以说是 OOP（Object Oriented Programming，⾯向对象编程）的补充和完善。

二. AOP 组成

切面（Aspect）

可以简单理解为一个解决某方面具体问题的一个类，类里面包含很多方法，这些方法就是切点和通知。

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

切⾯（Aspect）由切点（Pointcut）和通知（Advice）组成，它既包含了横切逻辑的定义，也包括了连接点的定义。

连接点（Join Point）

简单理解就是被拦截，触发动态代理的方法。
应⽤执⾏过程中能够插⼊切⾯的⼀个点，这个点可以是⽅法调⽤时，抛出异常时，甚⾄修改字段时。切⾯代码可以利⽤这些点插⼊到应⽤的正常流程之中，并添加新的⾏为。
连接点相当于需要被增强的某个 AOP 功能的所有⽅法。（即被增强的方法）

切点（Pointcut）

简单理解就是所有连接点的集合。
Pointcut 是匹配 Join Point 的谓词。
Pointcut 的作⽤就是提供⼀组规则（使⽤ AspectJ pointcut expression language 来描述）来匹配 Join Point，给满⾜规则的 Join Point 添加 Advice。
切点相当于保存了众多连接点的⼀个集合（如果把切点看成⼀个表，⽽连接点就是表中⼀条⼀条的数据）。

通知（Advice）

简单理解就是要增加的具体内容。

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

通知：定义了切⾯是什么，何时使⽤，其描述了切⾯要完成的⼯作，还解决何时执⾏这个⼯作的问题。
Spring 切⾯类中，可以在⽅法上使⽤以下注解，会设置⽅法为通知⽅法，在满⾜条件后会通知本⽅法进⾏调⽤：

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

具体执行的先后顺序：

在这里插入图片描述

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

在这里插入图片描述

三. Spring AOP 实现

接下来我们使⽤ Spring AOP 来实现⼀下 AOP 的功能，完成的⽬标是拦截所有 UserController ⾥⾯的⽅法，每次调⽤ UserController 中任意⼀个⽅法时，都执⾏相应的通知事件。
Spring AOP 的实现步骤如下：

添加 Spring AOP 框架⽀持。
定义切⾯和切点。
定义通知。

1. 添加 AOP 框架⽀持

在 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. 定义切面和切点

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

@Aspect // 表明此类为⼀个切⾯
@Component
public class UserAspect {
    // 定义切点，这⾥使⽤ AspectJ 表达式语法
    @Pointcut("execution(* com.example.springboot3.controller.UserController.* (..))")
    public void pointcut(){ }
}

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

切点表达式说明:

AspectJ ⽀持三种通配符
*：匹配任意字符，只匹配⼀个元素（包，类，或⽅法，⽅法参数）
. .：匹配任意字符，可以匹配多个元素，在表示类时，必须和 * 联合使⽤。
+：表示按照类型匹配指定类的所有类，必须跟在类名后⾯，如 com.cad.Car+ ,表示继承该类的所有⼦类包括本身

切点表达式由切点函数组成，其中 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. 定义相关通知

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

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

具体实现如下：

@Aspect
@Component
public class UserAspect {
    // 定义切点⽅法
    @Pointcut("execution(* com.example.springboot3.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 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 的理解：
在这里插入图片描述

你可能有点疑惑, 为什么这个 @Around 环绕通知不一样, 代码这么多, 需要执行被拦截的方法, 而其他通知不用 ?

因为其他的通知虽然在方法执行前后会执行一些特定的逻辑, 但是不会阻止目标方法的执行.

而这个 @Around 环绕通知就不一样了, 他会阻止目标方法的执行, 所以他需要自己在合适的时机调用目标方法，方法执行完还有有一个返回值，我们还要将这个值返回出去。

四. Spring AOP 实现原理

Spring AOP 是构建在动态代理基础上，代理对象通过运行时生成，这些代理对象会包装目标对象。当客户端调用代理对象的方法时，代理对象可以在方法执行前、方法执行后或抛出异常时执行额外的逻辑。因为代理对象不能直接操作目标对象的字段或属性。因此 Spring 对 AOP 的⽀持局限于⽅法级别的拦截。

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

在这里插入图片描述

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

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

织⼊是把切⾯应⽤到⽬标对象并创建新的代理对象的过程，切⾯在指定的连接点被织⼊到⽬标对象中。

在⽬标对象的⽣命周期⾥有多个点可以进⾏织⼊：

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

动态代理

在运行期织入这种设计模式上称为动态代理模式，在实现的技术⼿段上，都是在 class 代码运⾏期，动态的织⼊字节码，因此叫做动态代理。
Spring 框架中的AOP，主要基于两种⽅式：JDK 及 CGLIB 的⽅式。这两种⽅式的代理⽬标都是被代理类中的⽅法，在运⾏期，动态的织⼊字节码⽣成代理类。（并且都是基于反射）

JDK 动态代理实现:

JDK 实现时，先通过实现 InvocationHandler 接⼝创建⽅法调⽤处理器，其中的参数是被代理对象，所以实现 InvocationHandler 接口的类中含有被代理对象。
通过 Proxy 来创建代理类。参数为被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建一个代理类。
代理类和被代理类实现了相同的接口，那么代理类就可以有与被代理类相同的方法，因为调用被代理类是通过接口调用的，所以完全可以像调用被代理类一样去调用代理类。（注意并没有方法的真正实现，只是对外表现出具有相同的方法，当调用时会触发 InvocationHandler 的 invoke 方法去真正执行）
当调用代理类时，将触发 InvocationHandler 的 invoke 方法，并将被调用的方法传过去，然后在 invoke 中会执行额外的逻辑以及被代理类真正要执行的方法。

在这里插入图片描述

所以代理类并没有真正实现这些方法，而是对外表现出具有与代理类相同的方法，当被调用时，触发 InvocationHandler 去真正执行，执行额外的逻辑以及被代理类真正要执行的方法。

以下为伪代码实现：

public class PayServiceJDKInvocationHandler implements InvocationHandler {

    //⽬标对象即就是被代理对象
    private Object target;

    public PayServiceJDKInvocationHandler( Object target) {
        this.target = target;
    }

    //proxy代理对象
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //1.安全检查
        System.out.println("安全检查");
        //2.记录⽇志
        System.out.println("记录⽇志");
        //3.时间统计开始
        System.out.println("记录开始时间");
        //通过反射调⽤被代理类的⽅法
        Object retVal = method.invoke(target, args);
        //4.时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }
    public static void main(String[] args) {
        PayService target= new AliPayService();
        //⽅法调⽤处理器
        InvocationHandler handler =
                new PayServiceJDKInvocationHandler(target);
        //创建⼀个代理类：通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建
        PayService proxy = (PayService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class[]{PayService.class},
                handler
        );
        proxy.pay();
    }
}

CGLIB 实现动态代理：
CGLIB 实现动态代理的原理与 JDK 动态代理有相似之处，但也有一些关键区别。以下是类似的描述 CGLIB 实现动态代理的过程：

创建代理类：在CGLIB中，首先通过字节码生成库创建一个代理类。这个代理类是被代理类的子类，不需要实现接口。CGLIB会生成代理类的字节码，这个字节码包含了代理类的方法和属性。
重写方法： CGLIB会在代理类中重写被代理类的方法。这些重写的方法将委托给代理处理器（通常是用户自定义的MethodInterceptor）来处理方法调用。
代理对象的创建：当你使用CGLIB创建代理对象时，CGLIB会生成一个代理类的实例。这个代理对象是代理类的一个实例，因此它继承了被代理类。
方法调用的委托：当客户端代码调用代理对象的方法时，方法在内部会委托给代理处理器，也就是MethodInterceptor，来处理方法调用。代理处理器决定如何处理方法调用，可以在方法调用前后添加额外的逻辑，也可以选择调用被代理对象的方法。

在这里插入图片描述

以下为伪代码实现：

public class PayServiceCGLIBInterceptor implements MethodInterceptor {
    //被代理对象
    private Object target;

    public PayServiceCGLIBInterceptor(Object target){
        this.target = target;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //1.安全检查
        System.out.println("安全检查");
        //2.记录⽇志
        System.out.println("记录⽇志");
        //3.时间统计开始
        System.out.println("记录开始时间");
        //通过cglib的代理⽅法调⽤
        Object retVal = methodProxy.invoke(target, args);
        //4.时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }

    public static void main(String[] args) {
        PayService target= new AliPayService();
        PayService proxy= (PayService) Enhancer.create(target.getClass(),
                new PayServiceCGLIBInterceptor(target));
        proxy.pay();
    }
}

JDK 和 CGLIB 实现的区别

JDK 实现，要求被代理类必须实现接⼝，之后是通过 InvocationHandler 及 Proxy，在运⾏时动态的在内存中⽣成了代理类对象，该代理对象是通过实现同样的接⼝实现（类似静态代理接⼝实现的⽅式），只是该代理类是在运⾏期时，动态的织⼊统⼀的业务逻辑字节码来完成。
CGLIB 实现，被代理类可以不实现接⼝，是通过继承被代理类，那么子类就拥有父类的所有方法，在运⾏时动态的⽣成代理类对象。所以被 final 修饰的最终类不能通过 CGLIB 实现动态代理。

总的来说，CGLIB与JDK动态代理的主要区别在于代理方式。CGLIB创建一个子类来充当代理对象，该子类继承自被代理类，而JDK动态代理则创建一个实现相同接口的代理类。CGLIB通过字节码生成技术实现，因此能够代理普通类，而不仅限于实现接口的类。与JDK动态代理相比，CGLIB的动态代理方式更加灵活，但也更复杂。

好啦！以上就是对 Spring AOP 的讲解，希望能帮到你！
评论区欢迎指正 !