国庆假期，整整七天，我用76张图把Spring AOP给画明白了！

于 2022-10-28 10:00:23 发布
阅读量99 收藏
点赞数
文章标签： java spring 编程语言 aop 移动开发
原文链接：https://mp.weixin.qq.com/s?__biz=MzUzMTA2NTU2Ng==&mid=2247560563&idx=3&sn=85f14e955e4cf8a71677a8fe2b46290b&chksm=fa4b92c2cd3c1bd4f0ad15ab6b2f9ef44d1aa6e234c3bf2ec8b252f690ed0f94198a250501de&scene=126&&sessionid=0
版权

点击上方“芋道源码”，选择“设为星标”

管她前浪，还是后浪？

能浪的浪，才是好浪！

每天 10:33 更新文章，每天掉亿点点头发...

源码精品专栏

 

来源：楼仔

98335e7c735a2718a85053e00d20419b.jpeg

本文我会简单介绍一下 AOP 的基础知识，以及使用方法，然后直接对源码进行拆解。

不 BB，上文章目录。

11836714c22db9a1be14ababd258c959.png

1. 基础知识

1.1 什么是 AOP ？

AOP 的全称是 “Aspect Oriented Programming”，即面向切面编程 。

在 AOP 的思想里面，周边功能（比如性能统计，日志，事务管理等）被定义为切面 ，核心功能和切面功能分别独立进行开发，然后把核心功能和切面功能“编织”在一起，这就叫 AOP。

AOP 能够将那些与业务无关，却为业务模块所共同调用的逻辑封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

1.2 AOP 基础概念

  • 连接点(Join point) ：能够被拦截的地方，Spring AOP 是基于动态代理的，所以是方法拦截的，每个成员方法都可以称之为连接点；

  • 切点(Poincut) ：每个方法都可以称之为连接点，我们具体定位到某一个方法就成为切点；

  • 增强/通知(Advice) ：表示添加到切点的一段逻辑代码，并定位连接点的方位信息，简单来说就定义了是干什么的，具体是在哪干；

  • 织入(Weaving) ：将增强/通知添加到目标类的具体连接点上的过程；

  • 引入/引介(Introduction) ：允许我们向现有的类添加新方法或属性，是一种特殊的增强；

  • 切面(Aspect) ：切面由切点和增强/通知组成，它既包括了横切逻辑的定义、也包括了连接点的定义。

上面的解释偏官方，下面用“方言”再给大家解释一遍。

  • 切入点（Pointcut）：在哪些类，哪些方法上切入（where ）；

  • 通知（Advice）：在方法执行的什么时机（when ：方法前/方法后/方法前后）做什么（what ：增强的功能）；

  • 切面（Aspect）：切面 = 切入点 + 通知，通俗点就是在什么时机，什么地方，做什么增强；

  • 织入（Weaving）：把切面加入到对象，并创建出代理对象的过程，这个由 Spring 来完成。

5 种通知的分类：

  • 前置通知(Before Advice) ：在目标方法被调用前调用通知功能；

  • 后置通知(After Advice) ：在目标方法被调用之后调用通知功能；

  • 返回通知(After-returning) ：在目标方法成功执行之后调用通知功能；

  • 异常通知(After-throwing) ：在目标方法抛出异常之后调用通知功能；

  • 环绕通知(Around) ：把整个目标方法包裹起来，在被调用前和调用之后分别调用通知功能。

1.3 AOP 简单示例

新建 Louzai 类：

@Data
@Service
public class Louzai {

    public void everyDay() {
        System.out.println("睡觉");
    }
}

添加 LouzaiAspect 切面：

@Aspect
@Component
public class LouzaiAspect {
    
    @Pointcut("execution(* com.java.Louzai.everyDay())")
    private void myPointCut() {
    }

    // 前置通知
    @Before("myPointCut()")
    public void myBefore() {
        System.out.println("吃饭");
    }

    // 后置通知
    @AfterReturning(value = "myPointCut()")
    public void myAfterReturning() {
        System.out.println("打豆豆。。。");
    }
}

applicationContext.xml 添加：

<!--启用@Autowired等注解-->
<context:annotation-config/>
<context:component-scan base-package="com" />
<aop:aspectj-autoproxy proxy-target-class="true"/>

程序入口：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context =new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        Louzai louzai = (Louzai) context.getBean("louzai");
        louzai.everyDay();
    }
}

输出：

吃饭
睡觉
打豆豆。。。

这个示例非常简单，“睡觉” 加了前置和后置通知，但是 Spring 在内部是如何工作的呢？

1.4 Spring AOP 工作流程

为了方便大家能更好看懂后面的源码，我先整体介绍一下源码的执行流程，让大家有一个整体的认识，否则容易被绕进去。

整个 Spring AOP 源码，其实分为 3 块，我们会结合上面的示例，给大家进行讲解。

b769d3992e6c148b2956ce25833c784b.png

第一块就是前置处理 ，我们在创建 Louzai Bean 的前置处理中，会遍历程序所有的切面信息，然后将切面信息保存在缓存中 ，比如示例中 LouzaiAspect 的所有切面信息。

第二块就是后置处理 ，我们在创建 Louzai Bean 的后置处理器中，里面会做两件事情：

  • 获取 Louzai 的切面方法 ：首先会从缓存中拿到所有的切面信息，和 Louzai 的所有方法进行匹配，然后找到 Louzai 所有需要进行 AOP 的方法。

  • 创建 AOP 代理对象 ：结合 Louzai 需要进行 AOP 的方法，选择 Cglib 或 JDK，创建 AOP 代理对象。

cd74e3c5470ced5c3f8258db629c292f.png

第三块就是执行切面 ，通过“责任链 + 递归”，去执行切面。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址：https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • 视频教程：https://doc.iocoder.cn/video/

2. 源码解读

注意：Spring 的版本是 5.2.15.RELEASE，否则和我的代码不一样！！！

除了原理部分，上面的知识都不难，下面才是我们的重头戏，让你跟着楼仔，走一遍代码流程。

2.1 代码入口

c0c0e6f92d14ba05654b0a72a8b6bde0.png 829c32b9586cff53a03169059f49f746.png

这里需要多跑几次，把前面的 beanName 跳过去，只看 louzai。

c9ef5280d0cd0801c4cc3d34b8e58eeb.png 4a665666b0424d99857ed9b67234449b.png

进入 doGetBean()，进入创建 Bean 的逻辑。

3cc2c9832b4da117e3cc667b7c90dbb0.png

2.2 前置处理

9b642db63819a8b24782fbcef0266410.png

主要就是遍历切面，放入缓存。

b180f0dfbe7f7e92ef2e7a768e9d9f03.png 79ed0615684c154488acd35b568bff73.png 33cf171fa81cb5099b086c2efc966b42.png af4cc7012f233f3a191e1e229f08c144.png 4f9e5456bc3e0eb3b9063d954f765330.png c9e199aec19e41e7f04e2593a6e128cb.png

这里是重点！敲黑板！！！

  1. 我们会先遍历所有的类；

  2. 判断是否切面，只有切面才会进入后面逻辑；

  3. 获取每个 Aspect 的切面列表；

  4. 保存 Aspect 的切面列表到缓存 advisorsCache 中。

c2b256f51df1c1bbf4ad74caa43249b4.png

到这里，获取切面信息的流程就结束了，因为后续对切面数据的获取，都是从缓存 advisorsCache 中拿到。

下面就对上面的流程，再深入解读一下。

2.2.1 判断是否是切面

上图的第 2 步，逻辑如下：

d6e5c87aa92181e79c3be1ab46e8f6a4.png

2.2.2 获取切面列表

78d78040e59cd66fa03a17385652fdd9.png f9c60a0d969c1d5b2ab69f7fff46dda5.png 5bf63c26aba4e532b9c95a85f532b66e.png a57e48b26c5660f7b5012c21df467edf.png

进入到 getAdvice()，生成切面信息。

c0af8cbd6acda6484efefc1c9ac3b523.png

2.3 后置处理

50ea889fc9a38732bd9fc43461454b81.png

主要就是从缓存拿切面，和 louzai 的方法匹配，并创建 AOP 代理对象。

7d5a1a0cdf1e5f3be02506d58275a9f9.png

进入 doCreateBean()，走下面逻辑。

fa0375a2c09376eed354c980a2f53c2b.png 50b15959879f62f0d0465af96eb9c88b.png 5386f42c5d26b0631e1ea6af36ae1285.png 1f3d56235409218b4c3d76273605480d.png

这里是重点！敲黑板！！！

  1. 先获取 louzai 类的所有切面列表；

  2. 创建一个 AOP 的代理对象。

5642543ad80d6f1a5b0879458283ea86.png
2.3.1 获取切面

我们先进入第一步，看是如何获取 louzai 的切面列表。

dba541867077e2d4a57cd1b8cd81866f.png ee74086e9cc7754198665cdaee96c250.png aba32afcfe397c09a0de24e37fa94ddf.png

进入 buildAspectJAdvisors()，这个方法应该有印象，就是前面将切面信息放入缓存 advisorsCache 中，现在这里就是要获取缓存。

69b3a410dbf85759b35944fc55afe81a.png da1e1ea2961fd804fb06d34fd810b39e.png

再回到 findEligibleAdvisors()，从缓存拿到所有的切面信息后，继续往后执行。

74da906d78d33d1542017172804ef627.png ddfc531fbf342eeac7bc0006dff0fc0f.png 4096fb32bef6245763fd71527383238a.png 1b500c51cb9c208d283577ca3dc8ac1e.png 1f2283a7e178777aca6f90128e89eeeb.png
2.3.2 创建代理对象

有了 louzai 的切面列表，后面就可以开始去创建 AOP 代理对象。

a495db4c003ce28ab7907c708d17bbf5.png 90fb774eb6830670512b1c8565ae1bae.png cb23562a6b8fe88ba9e1563abcb2cd91.png

这里是重点！敲黑板！！！

这里有 2 种创建 AOP 代理对象的方式，我们是选用 Cglib 来创建。

932bd13f5aa3cd0bc3a2f9801573a1e0.png 34b1cca367cf621ee0ba4cc6e47fc3ad.png e19850601e5eda173b8ddb34a727f935.png

我们再回到创建代理对象的入口，看看创建的代理对象。

00cbf0062c82843eb79431f167edc7de.png

2.4 切面执行

3c269676b76abb07b3b0ef9ba1cb15c8.png

通过 “责任链 + 递归”，执行切面和方法。

e70eb45b7193119cb36b6264f6542db1.png ec4f2b1afd979d08820be062ac28b86c.png

前方高能！这块逻辑非常复杂！！！

d5dd2ea29f8856840a65e5ec4589ab40.png

下面就是“执行切面”最核心的逻辑，简单说一下设计思路：

  1. 设计思路 ：采用递归 + 责任链的模式；

  2. 递归 ：反复执行 CglibMethodInvocation 的 proceed()；

  3. 退出递归条件 ：interceptorsAndDynamicMethodMatchers 数组中的对象，全部执行完毕；

  4. 责任链 ：示例中的责任链，是个长度为 3 的数组，每次取其中一个数组对象，然后去执行对象的 invoke（）。

2d0ad18a1f36c19e2bb08f5a843edf7f.png

因为我们数组里面只有 3 个对象，所以只会递归 3 次，下面就看这 3 次是如何递归，责任链是如何执行的，设计得很巧妙！

2.4.1 第一次递归

数组的第一个对象是 ExposeInvocationInterceptor，执行 invoke（），注意入参是 CglibMethodInvocation。

db9eb168ad0131d80b6fc73bb8cc8b05.png

里面啥都没干，继续执行 CglibMethodInvocation 的 process()。

39699ca0e33b562c5fca99be52b6221d.png 8fa8a59bee592bd6c98a1e4efcde11eb.png
2.4.2 第二次递归

数组的第二个对象是 MethodBeforeAdviceInterceptor，执行 invoke（）。

acffaa540a10a16a7627eb8918a72c37.png 42ae206f3e341cffcb3d8d7d10359368.png 0a2d1691da1f26bbe3e4280489d79bc0.png a921f1f71e5a33574a4d45cf733f18d3.png 2739e6d02cde33079677d9f78ddd206a.png ea32f4b077bb101c99ec304e82b8cbc0.png 0351623f8332721e5cd857837ee0c512.png aa114a99b21d93ff7c8ef24da6ae47f9.png 7c25a1bf41b300630f705a0c32986e6d.png
2.4.3 第三次递归

数组的第二个对象是 AfterReturningAdviceInterceptor，执行 invoke（）。

4976b57867ce5cc21c4af20b1915d421.png c5a61f9b7cc1360f0b1f92df2a2d841a.png 03e166d7edfce7d5532d36d63cd0813d.png

执行完上面逻辑，就会退出递归，我们看看 invokeJoinpoint() 的执行逻辑，其实就是执行主方法。

041cf02e84815e1d34d111521e0c265c.png 18f3dead9c167c0637fe58fc36ecba8b.png b858b17da9ae7b67f49804caa6a98536.png

再回到第三次递归的入口，继续执行后面的切面。

fcb6d23f63272428e545d62ad359d920.png

切面执行逻辑，前面已经演示过，直接看执行方法。

0016644e2d3d53f69bec00a2671831b6.png

后面就依次退出递归，整个流程结束。

2.4.4 设计思路

这块代码，我研究了大半天，因为这个不是纯粹的责任链模式。

纯粹的责任链模式，对象内部有一个自身的 next 对象，执行完当前对象的方法末尾，就会启动 next 对象的执行，直到最后一个 next 对象执行完毕，或者中途因为某些条件中断执行，责任链才会退出。

这里 CglibMethodInvocation 对象内部没有 next 对象，全程是通过 interceptorsAndDynamicMethodMatchers 长度为 3 的数组控制，依次去执行数组中的对象，直到最后一个对象执行完毕，责任链才会退出。

这个也属于责任链，只是实现方式不一样，后面会详细剖析 ，下面再讨论一下，这些类之间的关系。

我们的主对象是 CglibMethodInvocation，继承于 ReflectiveMethodInvocation，然后 process() 的核心逻辑，其实都在 ReflectiveMethodInvocation 中。

ReflectiveMethodInvocation 中的 process() 控制整个责任链的执行。

ReflectiveMethodInvocation 中的 process() 方法，里面有个长度为 3 的数组 interceptorsAndDynamicMethodMatchers，里面存储了 3 个对象，分别为 ExposeInvocationInterceptor、MethodBeforeAdviceInterceptor、AfterReturningAdviceInterceptor。

注意！！！这 3 个对象，都是继承 MethodInterceptor 接口。

1ce38e8aa155e2faa3a58027c7bb1068.png

然后每次执行 invoke() 时，里面都会去执行 CglibMethodInvocation 的 process()。

是不是听得有些蒙圈？甭着急，我重新再帮你梳理一下。

对象和方法的关系：

  • 接口继承 ：数组中的 3 个对象，都是继承 MethodInterceptor 接口，实现里面的 invoke() 方法；

  • 类继承 ：我们的主对象 CglibMethodInvocation，继承于 ReflectiveMethodInvocation，复用它的 process() 方法；

  • 两者结合（策略模式） ：invoke() 的入参，就是 CglibMethodInvocation，执行 invoke() 时，内部会执行 CglibMethodInvocation.process()，这个其实就是个策略模式。

可能有同学会说，invoke() 的入参是 MethodInvocation，没错！但是 CglibMethodInvocation 也继承了 MethodInvocation，不信自己可以去看。

执行逻辑：

  • 程序入口 ：是 CglibMethodInvocation 的 process() 方法；

  • 链式执行（衍生的责任链模式） ：process() 中有个包含 3 个对象的数组，依次去执行每个对象的 invoke() 方法。

  • 递归（逻辑回退） ：invoke() 方法会执行切面逻辑，同时也会执行 CglibMethodInvocation 的 process() 方法，让逻辑再一次进入 process()。

  • 递归退出 ：当数字中的 3 个对象全部执行完毕，流程结束。

所以这里设计巧妙的地方，是因为纯粹责任链模式，里面的 next 对象，需要保证里面的对象类型完全相同。

但是数组里面的 3 个对象，里面没有 next 成员对象，所以不能直接用责任链模式，那怎么办呢？就单独搞了一个 CglibMethodInvocation.process()，通过去无限递归 process()，来实现这个责任链的逻辑。

这就是我们为什么要看源码，学习里面优秀的设计思路！

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址：https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程：https://doc.iocoder.cn/video/

3. 总结

我们再小节一下，文章先介绍了什么是 AOP，以及 AOP 的原理和示例。

之后再剖析了 AOP 的源码，分为 3 块：

  • 将所有的切面都保存在缓存中；

  • 取出缓存中的切面列表，和 louzai 对象的所有方法匹配，拿到属于 louzai 的切面列表；

  • 创建 AOP 代理对象；

  • 通过“责任链 + 递归”，去执行切面逻辑。

这篇文章，是 Spring 源码解析的第 3 篇，也是感觉最难的一篇 ，光图解代码就扣了 6 个小时 ，整个人都被扣麻了。

最难的地方还不是抠图，而是 “切面执行”的设计思路 ，虽然流程能走通，但是把整个设计思想能总结出来，并讲得能让大家明白，还是非常不容易的。

欢迎加入我的知识星球，一起探讨架构，交流源码。加入方式，长按下方二维码噢：

29e32485d35b1a27b840eda341dfa93d.png

已在知识星球更新源码解析如下：

25b4191ae46a0167e3e26d0bc83678e5.jpeg

7d80f02afecf233aff218840931fe3cb.jpeg

ae54da505ea5839a1321d8d404dca0b7.jpeg

cd88388118b7d2d6016b2c81c0e6dcd1.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列，已经 101 余篇，覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例，以及超 4W 行代码的电商微服务项目。

获取方式：点“在看”，关注公众号并回复 666 领取，更多内容陆续奉上。

文章有帮助的话，在看，转发吧。
谢谢支持哟 (*^__^*）
公众号-芋道源码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值