news 2026/5/11 5:01:36

简单学习 --＞ SpringAOP

作者头像

张小明

前端开发工程师

1.2k 24
文章封面图
简单学习 --＞ SpringAOP

spring 两大核心: ioc 和 aop ; (ioc : 控制反转 , aop : 面相切面编程)

AOP

AOP: 面向切面编程 , 可以看作是面向对象编程的补充 ;

aop是一种思想,是对某一类事情的集中处理(例如: 统一功能处理(拦截器,统一结果,统一异常) , 统一功能处理事AOP 的实现 )

切面: 某一类公共的事情 ;

使用AOP

场景: 某一个接口慢,需要时间多(例如: 500ms以内,但他却需要800ms)

方法: 打印时间戳, 判断哪里慢了 ,通过log.info打印时间戳 ;

每个接口里都有许多方法在调用, 都需要 记录 方法调用前的时间戳 和 方法 调用后的时间戳 , 然后计算方法 所消耗的时间

这样的事情,都是相同的事情, 符合 AOP , 对某一类的事情集中处理 ;

实现AOP

  1. 引入依赖 ( AOP的实现方式很多,例如: AspectJ , 这里用 Spring AOP)

  2. 实现切面逻辑 (切面: 就是某一类公共的事情)

AOP依赖
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency>
实现切面逻辑

切面逻辑:

  1. 记录开始时间

  2. 执行目标方法

  3. 记录结束时间

  4. 记录消耗时间

设置controller包里的所有类,所有方法 生效 , 当这些方法运行时就会将消耗的时间打印出来 ;

获取到是 哪个方法打印的日志

使用 getSignature() 获取目标方法的签名,就可以知道是哪个方法打印的消耗时间

代码解释

1.

2. 返回结果 :接口的返回结果必须将其返回, 如果不返回 ,那么接口也不会返回结果 (这里设置成void ,不返回结果, 导致 所有生效范围内的接口都不会返回结果 ;)

总步骤

  1. 切面: 切点+通知 (一个切面类里可以有多个切面)

  2. 切点: 切面执行的范围 ;

  3. 连接点,切面作用到的地方,亦可以说是目标方法;

  4. 通知: 切面具体要做的事情 ;

  5. 通知类型 : 什么时间执行 通知内容 ;

通知类型 :

  1. @Around: 环绕通知 : 通知在 目标方法执行前, 目标方法执行后 执行 ; (常用)

  2. @Before : 前置通知 , 通知 在目标方法执行前执行 ;

  3. @After : 后置通知 , 通知在目标方法执行后执行 ;

  4. @AfterReturnning : 返回通知 , 在目标方法返回后通知 ;

  5. @AfterThrowing : 异常后通知 , 在目标方法发生异常后 通知 ;

AOP优势

代码无入侵,不修改原来代码,就可以对原来的业务进行功能的增强

通知详解

@Around是环绕通知,所以需要有连接点 ,需要将目标方法返回 , 而其他 通知则不能使用 ProceedingJoinPoint 连接点 ;

通知执行顺序

当一个切面里同时存在 多个通知类型(有@Around , @Before...) , 执行的顺序

  1. 正常响应时

从最外层进入,执行目标方法,然后出来; @Around是在最外层 ;

2. 发生异常时

原来执行目标方法后的Around通知不执行了, 目标方法正常返回后的AfterReturning通知也不执行了 ;

处理异常

切点定义 @Pointcut

将切点 提取出来,定义好, 就可以直接用定义好的切点, 而不是每个切面都用 切点表达式 ;

其他类里使用切点

在不同类里使用切点,需要用到定义切点的全限定类名.切点名() ;

不同的切面类里有相同的切点

多个切面类里有相同的切点,那么执行通知的顺序:

切面里抛异常应该try catch (Throwable 异常)

多个切面类有相同的切点时执行顺序按类名来排序

设置切面类的执行顺序 @Order

@Order不止可以在AOP里使用 , 也适用于其他方面 , 可以用来排序不同类的Bean (例如:拦截器,有多个拦截器也可以通过Order排序)

@Order(排序值): order里的值越小 ,执行的优先级越大, order值越大, 执行优先级越小;

切点表达式

execution (根据方法的签名匹配)

execution(<访问限定修饰符> <返回类型> <包名.类名.方法(方法参数) <异常> ) ; 访问限定修饰符 , 和异常可以省略 ;

通配符

  1. "*" 匹配一个元素

一个 * 表示包名: 任意一个包名

类: 表示任意类

返回值: 表示任意返回值 ;

方法名: 表示任意方法 ;

参数: 一个任意类型的参数 ;

  1. ".." 匹配多个连续的任意字符

包名 xx/.. : 表示 xx包下的任意包和所有子包 ;

参数 : 可以表示 任意个 任意类型的 参数

@annotation (根据注解匹配)

根据方法所使用的注解来匹配 : @annotaion(注解全限定类名)

但是这样会导致原本的注解(@RequestMapping)多出不必要的功能 ; 像@RequestMapping本来就是设置路径的,加了@annotation又多出了其他功能 ;

例如: 原本我只需要 t1 切点有切面逻辑处理 , 但是因为@annotation ,导致其他的使用@RequestMapping注解的地方也被处理了,例如t2 ;

使用自定义注解实现AOP

上面通过@annotation来匹配切点, 类似与@Controller,@ResponseBody这些注解,已经有他们固定的作用,如果加上AOP,加上一段切面逻辑,会影响使用这些注解的接口 ;

通过自定义注解 , 来实现AOP ;

  1. 定义注解

  2. 实现注解要完成的功能

  3. 使用注解

定义注解

自定义注解可以参考 其他注解的定义 ; (@注解的定义,注解的属性)

创建一个自定义注解

实现注解功能

使用注解

使用 t1和 t2 接口(t1和t2有自定义注解@TimeRecord,其他没有注解的就不会有这个计算耗时的逻辑)

AOP面试题

SpringAOP的实现方式

  1. 基于注解@Aspect实现

  2. 自定义注解实现(@annotation实现)

  3. 基于Spring api实现(通过配置xml的方式)

  4. 基于代理实现(最低层的,即上面的都是通过代理实现的)

SpringAOP原理(重点)

SpringAOP是基于动态代理实现的AOP ;

代理模式(重点)

代理模式(也叫委托模式),也是经典设计模式;

有些时候,一个调用方对象 不适合 或 不能 直接 调用 一个目标对象 , 而代理对象可以 在 调用方 和 目标方 起到中介作用 ;

海外代理 ; 买一个国外的产品 我 不能直接去 国外买产品 ; 但 可以通过 代理商 买到 ; 代理商 有 国外厂商授权允许; 代理商 并不会生产产品 , 真正生产产品的 还是 国外厂商;

代理模式里的关键对象 : 代理类 , 目标类(被代理对象) , 我们是和 代理类打交道 , 但是代理类 的 底层是有 目标类 实现的 ;

例如: A 类 是 B类的代理类 , 我们通过 调用 A 类 间接 去调用 B类 ;

proxy实现 (代理实现)

代理类不仅有 目标类的功能 , 并且还有对目标类进行功能的增强(加了一些功能) ; (例如: AOP就是在 目标的基础上 加上了自己的功能)

这里代理模式的实现方式和 适配器的实现方式一样

(设计模式主要是思想,它的实现方式有多种多样)

当 如果房东有任何的变动 , 例如: 加了售卖房子,装修等服务, 相对的 中介类也要有对应的改变 , 加上各种服务 ;

但其实 中介的工作流程都是 : 中介代理服务... => 房东服务 => 中介结束代理.. ;

总不能房东每变动一个方法, 中介就跟着变动一个方法 ;

中介就可以指定一套规范的标准 , 把这些重复的一类流程提出了

这就是 AOP

SpringAOP的底层就是 通过代理模式实现的 ;

根据代理的创建时期 , 分为静态代理 和 动态代理 ;

静态代理

静态代理就是 每有一个目标类 , 都有一个对应的 代理对象 ; (像上面的房东和中介一样 , 有一个房东就有一个中介类 )

有一个目标类 , 就有一个 代理类 , 在程序运行前 ,代理类就有.class文件

动态代理

在程序运行时, 运用反射机制动态创建 代理 ; (在运行时动态的生成代理 , 而不是提前全部写好)

动态代理实现

动态代理实现方式有:

  1. JDK动态代理

  2. CGlib

JDK 动态代理

jdk代理的缺点

只能代理接口 , 不能代理普通类

( 即使是 实现接口的类,可以代理 , 但是没有实现接口的不能; 例如: A接口 , B类实现了A 接口 , 所以可以代理 B类, c类谁都没有实现 , 无法代理c类 ;)

CGlib代理

  1. 引入依赖

<dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>3.3.0</version> </dependency> ​

CGlib动态代理的实现和jdk动态代理类似 ;

CGlib 代理 和 jdk代理 的主要区别

CGlib动态代理 可以 代理 没有实现接口的 普通类 ;

总结

AOP是什么?

AOP是一种思想 , 是对一类事情进行统一处理 ;

SpringAOP 是怎么实现的

SpringAOP是通过 动态代理实现的 ;

什么时候使用jdk , 什么时候使用 CGlib ,

jdk代理是什么 ? CG代理是什么 ;

SpringAOP主要 基于 JDK动态代理 和 CGlib动态代理实现 ,

什么时候使用 JDK代理 什么时候使用 CGlib代理 , 也看程序员的配置 ;

SpringAOP 的 代理工厂 里有一个属性: proxyTargetClass , 默认值是 false; (实现接口的 ,统一使用 JDK动态代理 , 普通类 ,使用CGlib动态代理) , 通过 配置 把proxyTargetClass 设置为 true , 则 无论是实现了接口的类 还是 普通类 , 都使用CGlib 动态代理的方式实现 ;

代理工厂创建 代理时, 有一条if( isProxyTargetClass) {} else {创建JDK代理} , 所以 当proxyTargetClass为false使 , 默认创建的都是JDK代理

Springboot 2.x 以后, 默认都使用 CGlib动态代理, 也可以通过配置 , 设置为 默认 JDK动态代理, 普通类使用 CGlib

application配置项 , 配置默认为JDK代理 ;

Spring AOP 使用什么代理?

(大体分两个情况, 两个稍微有些地方不同)

  1. Spring framework :

  2. SpringBoot

共同点: 两者底层实现都用的 JDK 代理 和 CGlib代理

不同点:

Spring framework

代理的是接口, 使用 JDK代理 , 代理没有实现接口的类 , 使用 CGlib 代理;

Spring Boot

2.x之后的版本:

默认配置都使用 CGlib 代理, 无论有没有实现接口 , 都用CGlib代理 ,需要用 JDK代理 , 可以在 application配置 ;

2.x之前的版本:

默认使用 JDK代理 , 和 Springframework 保持一致 ;

为什么两这会不同:

proxyTargetClass的默认值配置不同 , SpringBoot在2.x之后的版本里, proxyTargetClass的值默认配置为 true ;

Spring怎么判断 接口和 没有实现接口的普通类

接口里最少要有一个 自定义的方法:

没有实现接口的类 , 或是 实现了接口的类 , 但是接口里没有一个方法 , 这些 都划分为 没有实现接口的普通类 , 都使用 CGlib ;

实现了接口的类 , 同时接口了 至少有一个自定义方法 , 这些才算是 : 实现接口的类

代码细节

使用Test1和Test2来测试 SpringAOP 到底使用的是哪个代理;

  1. 在没有任何配置的默认情况下 ;

  1. 通过application配置修改 为 JDK代理;

需要调整代码,改成使用 接口类型来接收bean , 就可以正常使用 JDK代理 ;

public class SpringAopApplication { ​ public static void main(String[] args) { ApplicationContext context = SpringApplication.run(SpringAopApplication.class, args); // 1.在没有任何配置修改的情况下: 两种情况都能够正常代理 // Test1 t1 = context.getBean(Test1.class); // t1.say(); // System.out.println(t1.getClass().toString()); // System.out.println("--------------------------------"); // Test2 t2 = context.getBean(Test2.class); // t2.say(); // System.out.println(t2.getClass().toString()); ​ // 2. 修改配置为 JDK代理 ​ // 这个实现了接口的已经不能打印了 ,因为JDK要用的是接口这里应该改成接口来用 // Test1 t1 = context.getBean(Test1.class); // t1.say(); // System.out.println(t1.getClass().toString()); // 改成接口 来接收bean , 同时bean也改成用 bean名字作为参数 , // 能够正常使用 JDK代理 TestIntFace testIntFace = (TestIntFace) context.getBean("test1"); testIntFace.say(); System.out.println(testIntFace.getClass().toString()); ​ // 普通类能够正常被 CGlib代理 // System.out.println("--------------------------------"); // Test2 t2 = context.getBean(Test2.class); // t2.say(); // System.out.println(t2.getClass().toString()); ​ } ​ }
判断是否为接口

1. 当接口中有自定义的方法时 , 使用的是JDK代理

2. 当接口里没有自定义方法 ;

版权声明: 本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！
网站建设 2026/5/11 5:00:10

PGlite Explorer：浏览器端PostgreSQL图形化管理工具开发指南

1. 项目概述&#xff1a;一个轻量级的浏览器端数据库管理工具如果你在前端开发中&#xff0c;或者正在构建一个需要本地数据存储的Web应用&#xff0c;那么你一定对IndexedDB、localStorage这些浏览器内置的存储方案不陌生。它们各有优劣&#xff0c;但总感觉缺少点什么——比如…

作者头像 李华
网站建设 2026/5/11 4:58:46

数字信号处理实战：从零极点图到系统特性分析

1. 零极点图&#xff1a;数字信号处理的"X光片" 第一次接触零极点图时&#xff0c;我完全不明白这些散落在复平面上的小圆圈和叉叉有什么用。直到有次调试音频滤波器&#xff0c;当我把一个极点的位置向单位圆外移动了0.1&#xff0c;喇叭里立刻传出刺耳的啸叫声——…

作者头像 李华
网站建设 2026/5/11 4:55:48

GPU并行计算：SIMT架构与性能优化实践

1. SIMT架构的本质与硬件挑战 在GPU计算领域&#xff0c;单指令多线程&#xff08;SIMT&#xff09;执行模型是实现大规模并行的核心机制。与传统的SIMD&#xff08;单指令多数据&#xff09;不同&#xff0c;SIMT允许同一warp&#xff08;通常包含32个线程&#xff09;中的每个…

作者头像 李华
网站建设 2026/5/11 4:55:11

Python静态分析利器Scalpel：基于AST的精准代码查询与安全审计实战

1. 项目概述&#xff1a;一把精准的代码“手术刀”在软件开发的日常维护、代码审计或者遗留系统重构中&#xff0c;我们常常会面对一个令人头疼的场景&#xff1a;一个庞大的代码库&#xff0c;动辄几十万行&#xff0c;而你只需要找到其中与某个特定功能、某个API调用或者某个…

作者头像 李华
网站建设 2026/5/11 4:52:56

嵌入式系统任务调度器原理与应用指南

1. 嵌入式系统任务调度器概述 在嵌入式系统开发中&#xff0c;任务调度器扮演着系统"交通警察"的角色。想象一下繁忙的城市十字路口&#xff0c;没有红绿灯和交警指挥&#xff0c;车辆就会陷入混乱。同样&#xff0c;在嵌入式系统中&#xff0c;调度器负责协调多个任…

作者头像 李华
网站建设 2026/5/11 4:52:27

大模型训练中静默数据损坏的检测与恢复技术

1. 大模型训练中的静默数据损坏问题在大型语言模型&#xff08;LLM&#xff09;训练过程中&#xff0c;硬件故障导致的静默数据损坏&#xff08;Silent Data Corruption&#xff0c;SDC&#xff09;是一个常被忽视但影响深远的问题。与显性错误不同&#xff0c;SDC不会导致程序…

作者头像 李华