Spring AOP的实操 + 原理（动态代理）

小小小小关同学

已于 2024-11-10 00:30:55 修改

阅读量1.3k

点赞数 24

分类专栏： Spring/Spring Boot 文章标签： spring java 后端

于 2024-05-25 00:51:46 首次发布

本文链接：https://blog.youkuaiyun.com/qq_45875349/article/details/139160651

版权

Spring/Spring Boot 专栏收录该内容

17 篇文章

订阅专栏

1 什么是Spring AOP

要想知道Spring AOP那必然是是要先知道什么是AOP了:

AOP，全称为 Aspect-Oriented Programming（面向切面编程），是一种编程范式，用于提高代码的模块化，特别是横切关注点（cross-cutting concerns）的模块化。横切关注点是指那些影响多个模块的功能，比如日志记录、安全性、事务管理等。AOP 通过将这些关注点与业务逻辑分离，简化代码维护，提高代码的可读性和可重用性。

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

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

2 为什么要使用AOP？

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

如果每个 Controller 都要写⼀遍⽤户登录验证，然⽽当功能越来越多，那么要写的登录验证也越来越多，⽽这些⽅法⼜是相同的，这么多的⽅法就会代码修改和维护的成本。那有没有简单的处理⽅案呢？答案是有的，对于这种功能统⼀，且使⽤的地⽅较多的功能，就可以考虑 AOP 来统同一处理。

AOP（面向切面编程）不仅可以用于统一的用户登录判断，还可以用于处理各种横切关注点。以下是一些常见的应用场景：

1. 日志记录

AOP 可以在方法执行前后自动记录日志，无需在每个方法中显式编写日志代码，从而保持业务逻辑的简洁。例如，可以在方法调用之前记录方法名称和参数，在方法成功执行之后记录返回值。

2. 性能监控

AOP 可以用于记录方法执行时间，计算方法执行的时间，从而实现性能监控。这对于识别和优化性能瓶颈非常有用。

3. 事务管理

AOP 可以用于声明式事务管理。在方法执行前开启事务，执行成功后提交事务，发生异常时回滚事务，从而简化事务处理逻辑。

4. 安全控制

AOP 可以在方法执行前检查用户权限，如果用户没有相应权限，则抛出异常，阻止方法执行。这可以集中处理安全逻辑，避免在每个方法中重复代码。

5. 异常处理

AOP 可以在方法执行时捕获异常，并统一处理，例如记录错误日志或发送通知。这样可以提高代码的可维护性和一致性。

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

3 Spring AOP该怎么学习？

Spring AOP 学习主要分为以下 3 个部分：

学习 AOP 组成的相关概念。
学习 Spring AOP 使⽤。
学习 Spring AOP 实现原理。

3.1 相关概念

1 切面（Aspcet）

切面可以理解为某一模块化的功能的具体内容，比如登录判断就是一个切面，而是日志的统计记录又是一个切面。切面是模块化的关注点，它可以跨越多个对象。切面通常包括横切关注点的行为和逻辑，比如日志记录、性能监视、事务管理等。

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

2 切点（Pointcut）

切点用来定义一个拦截规则。

Pointcut 的作⽤就是提供⼀组规则（使⽤ AspectJ pointcut expression language 来描述）来匹配 Join Point，给满⾜规则的 Join Point 添加 Advice

3 通知（Advice）

定义了拦截规则之后肯定需要“做点什么”，这就是通知干的事情。可以理解为执行AOP的逻辑业务。通知是切面在连接点处执行的代码。通知可以在方法调用之前、之后或者异常抛出时执行。

常见的通知类型包括：

Before advice（@Before）：前置通知：在方法调用之前执行。
After advice（@After）：后置通知：在方法调用之后执行。
Around advice（@Around）：环绕通知：在方法调用之前和之后执行。
After returning advice（@AfterReturn）：返回通知：在方法成功返回之后执行。
After throwing advice（@AtferThroeing）：异常通知：在方法抛出异常之后执行。

4 连接点（Join Point）

连接点是程序执行过程中可以插入切面的一个点。这些点可以是方法调用、方法执行、对象实例化等。所有可能触发切点的点都可以叫作连接点。

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

3.2 上手使用

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

Spring AOP 的实现步骤如下：

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

3.2.1 添加Spring Boot AOP框架支持

注意在maven仓库中添加的时候，搜索的是spring-boot-starter-aop，因为目前我使用的是spring boot项目，如果是spring core项目的话就需要的是原生的spring aop依赖。他们两者是不一样的。

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

可以看到我们使用的注解是来自aspectj：

3.2.2 定义切面和切点

定义切面就是在我们需要的类上添加一个@Aspect注解，这个类可以跨越多个对象。现在我创建了一个UserAOP，就是针对UserController的一个切面。

创建切点，这里只用注解@Pointcut，后面跟的就是具体地拦截规则，代码中的规则就是拦截UserController下面的所有方法。拦截规则描述语言（aspectj语法）的使用大家感兴趣可以自己检索相关资料查看。下面是简单的介绍：

AspectJ ⽀持三种通配符

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

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

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

下面先来通过案例直接使用AOP试一试。这是讲的最原生的使用，实际开发也不会使用，这里重在AOP思想。

3.2.3 创建通知

我们创建了切面切点肯定是要执行一些事情的，这些事情就是通知要做的。代码中，简单的使用了一个前置通知和一个后置通知，通知就是做一个打印帮助观察代码的执行结果。

各种通知的创建demo

package com.example.springaopdemo.controller;


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("user")
public class UserController {

    @RequestMapping("sayhi")
    public String sayHi(){
        System.out.println("执行了 sayHi 方法");
        return "hi springboot AOP";
    }

    @RequestMapping("login")
    public String login(){
        System.out.println("执行了 login 方法");
        return "do user login";
    }

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

3.2.4 创建连接点

没有连接点，AOP就形同虚设啊，通过连接点触发切点执行各种通知。连接点是程序执行过程中可以插入切面的一个点。这些点可以是方法调用、方法执行、对象实例化等。

同时为了验证我们的切点定义的拦截规则是否起作用，在设置一个对照类，如果我们的UserController促发了切点的通知，而访问其他的Controller没有触发通知，就说明我们的AOP是可以正常Work的。

执行代码观察结果：

http://127.0.0.1:8080/user/sayhi

可以发现现在访问UserController中的方法已经成功的被拦截到，但是我们没有做拦截业务，直接放行了，如果是对于验证登陆来讲我们在拦截后可以直接返回未登陆的状态码。

那么我们现在来访问设置的对照组的Controller中的方法会不会被拦截呢？

http://127.0.0.1:8080/article/sayhi

很明显是没有促发切点执行通知时间，也就是没有被拦截。

这也说明了我们的代码逻辑是没有问题的。

3.3 Spring AOP实现原理

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

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

这里先介绍一下AOP中最后的一个关键概念： 织⼊（Weaving）：代理的生成时机

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

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

既然有 JDK Proxy 和 CGLIB 这两种方式，那就要需要了解这两种方法的不同了

JDK 和 CGLIB 实现的区别：

JDK 实现，要求被代理类必须实现接⼝，之后是通过 InvocationHandler 及 Proxy，在运⾏时动态的在内存中⽣成了代理类对象，该代理对象是通过实现同样的接⼝实现（类似静态代理接⼝实现的⽅式），只是该代理类是在运⾏期时，动态的织⼊统⼀的业务逻辑字节码来完成。也就是说没有实现接口的类就没有办法实现AOP了，没错，所以就需要CGLIB了。（底层实现原理：反射）
CGLIB 实现，被代理类可以不实现接⼝，是通过继承被代理类，在运⾏时动态的⽣成代理类对象，所以他不能代理被final修饰的类。（底层实现原理：字节码增强技术）
JDK动态代理相对性能较高，生成代理对象速度较快；CGLIB动态代理性能相对较低，生成代理速度较慢。【jdk1.7以后】

总结

AOP 是对某方面能力的统一实现，它是一种实现思想，Spring AOP 是对 AOP 的具体实现，AOP 可通过 AspectJ(注解)的方式来实现 AOP 的功能,Spring AOP的实现步骤是：

1. 添加 AOP 框架⽀持。

2. 定义切⾯和切点。

3. 定义通知。

Spring AOP 是通过动态代理的⽅式，在运⾏期将 AOP 代码织⼊到程序中的，它的实现⽅式有两种：JDK Proxy 和 CGLIB。