一文读懂Spring AOP：手把手教你优雅实现“无侵入”代码增强

目录

1.什么是Spring AOP?

2.SpringAOP优点与上手

Spring AOP 的核心术语

3.通知类型注解

4.@PointCut+@Order

5.切点表达式

6.代理模式

7.Spring AOP原理

1.什么是Spring AOP?

AOP=>面向切片编程思想,是一种对一类问题集中处理的思想,比如拦截器,统一返回结果管理,统一异常处理,登录校验......如果使用OOP(面向结果编程)会让相同的代码重复多次出现,业务方法中混杂着非核心的逻辑。

Spring AOP就是为了解决这些问题存在,是AOP思想的其中一种实现方式

2.SpringAOP优点与上手

优点:

• 不影响原有代码,解耦
• 便于维护功能
• 提高开发效率
• 减少重复代码

快速上手SpringAOP

编写一个使用SpringAOP计算所有方法的运行时长的例子

1.在pom.xml文件引入依赖

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

注意:SpringBoot使用版本号为4.x.x, AOP依赖需要添加版本号

2.编写AOP程序

package com.example.springbookdemo.aspect; import lombok.extern.slf4j.Slf4j; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.springframework.stereotype.Component; @Slf4j @Aspect @Component public class TimeRecordAspect {  @Around("execution(* com.example.springbookdemo.controller.*.*(..))")//该注解()中是要执行方法的路径 //参数部分的ProceedingJoinPoint joinPoint即要执行的方法 //不确定执行方法的返回类型,因此在这里设返回类型为Object public Object timeRecord(ProceedingJoinPoint joinPoint) throws Throwable { long start=System.currentTimeMillis();//记录方法执行前时间 //执行方法 Object proceed = joinPoint.proceed();//proceed()方法返回类型固定为Object long end=System.currentTimeMillis();//记录方法执行完的时间 log.info(joinPoint.getSignature()+"方法耗时:"+(end-start)+"ms");//getSignature()用于获取执行方法名 return proceed; } }

注解解释:

• Aspect=>标识切面类
• Component=>将该类交给Spring容器管理,使其能自动扫描并注入
• Around=>指明对哪些方法生效
• Slf4j=>自动生成日志对象,可调用log.info()等方法打印日志

Spring AOP 的核心术语

理解这些术语是掌握 AOP 的关键：

1. Aspect（切面）：
   • 是什么：横切关注点的模块化。它是一个类，里面包含了需要被织入到业务代码中的各种通知（Advice）。包含了切点,通知,连接点
2. Join Point（连接点）：
   • 是什么：程序执行过程中可以插入切面的点。在 Spring AOP 中，连接点总是代表执行的方法。
3. Pointcut（切点）：
   • 是什么：一个表达式，用于定义在哪些连接点上应用通知。它告诉 AOP：“在哪里” 执行切面代码。例如，你可以定义一个切点，匹配所有 com.example.service包下以 delete开头的方法。
4. Advice（通知）：
   • 是什么：切面在特定连接点上执行的动作。指具体要做的⼯作, 指哪些重复的逻辑,它回答了 “什么时候” 和 “做什么” 的问题。
   • 类型：
     • @Before：在目标方法执行之前执行。
     • @After：在目标方法执行之后执行（无论是否成功完成）。
     • @AfterReturning：在目标方法成功执行并返回结果后执行。
     • @AfterThrowing：在目标方法抛出异常后执行。
     • @Around：最强大的通知，它包围了连接点。可以在方法调用前后执行自定义行为，并决定是否继续执行方法、返回值或抛出异常。

用上面的例子来区分

3.通知类型注解

写两个方法,用于测试

package com.example.springaopdemo.controller; @Slf4j @RestController @RequestMapping("/test") public class TestController { @RequestMapping("/t1") public String t1(){ log.info("执行t1"); return "t1"; } @RequestMapping("/t2") public boolean t2(){ log.info("执行t2"); return true; } }

编写AOP

package com.example.springaopdemo.aspect; @Aspect @Component @Slf4j public class TestAspect { //抽取切点 @Pointcut("execution(* com.example.springaopdemo.controller.*.*(..))") public void pt(){} //前置通知 @Before("pt()") public void doBefore() { log.info("执行doBefore方法"); } //后置通知 @After("pt()") public void doAfter() { log.info("执行 After 方法"); } //返回后通知 @AfterReturning("pt()") public void doAfterReturning() { log.info("执行 AfterReturning 方法"); } //抛出异常后通知 @AfterThrowing("pt()") public void doAfterThrowing() { log.info("执行 doAfterThrowing 方法"); } //添加环绕通知 @Around("pt()") public Object doAround(ProceedingJoinPoint joinPoint) { log.info("Around 方法开始执行"); Object result = null; try { result = joinPoint.proceed(); } catch (Throwable e) { throw new RuntimeException(e); } log.info("Around 方法结束执行"); return result; } } 

结果展示:

访问t1=>即接口正常访问

访问t2=>即接口发生异常且不捕获

访问t2=>即接口发生异常且捕获不throw

4.@PointCut+@Order

@PointCut

在上面中存在大量的同样的切点表达式,使用该注解能够定义可重用的切点表达式，避免在多个通知中重复编写相同的表达式。

通过@PointCut注解定义一个公共切点方法，该方法本身没有实现，仅作为切点表达式的载体：

@PointCut("execution(* com.example.service.*.*(..))") public void serviceLayer() {} 

重用切点表达式

定义好的切点可以在其他通知中通过方法名引用，避免重复编写表达式：

@Before("serviceLayer()") public void beforeService() { // 前置通知逻辑 } @After("serviceLayer()") public void afterService() { // 后置通知逻辑 } 

@Order用于设置优先级,控制多个切面的执行顺序,@Order(),()中的数字越小,优先级越高

@Component @Aspect @Slf4j public class TestAspect2 { @Before("com.example.springaopdemo.aspect.TestAspect.pt()") public void doBefore() { log.info("执行doBefore2方法"); } } @Component @Aspect @Slf4j public class TestAspect3 { @Before("com.example.springaopdemo.aspect.TestAspect.pt()") public void doBefore() { log.info("执行doBefore3方法"); } } @Aspect @Component @Slf4j public class TestAspect { //抽取切点 @Pointcut("execution(* com.example.springaopdemo.controller.*.*(..))") public void pt(){} //前置通知 @Before("pt()") public void doBefore() { log.info("执行doBefore方法"); } }

执行结果:也就是切面默认执行顺序(按照类名排序)

通过添加@Order注解可以人为控制切面执行顺序

@Order(3)

public class TestAspect(){}

@Order(2)

public class TestAspect2(){}

@Order(1)

public class TestAspect3(){}

添加之后执行结果:

5.切点表达式

有两种

第一种execution(<访问修饰符><返回类型><包名.类名.方法名(方法参数)><异常>)

其中访问修饰符和异常可以省略," * "匹配任意字符," .. "匹配多个连续符号

第二种@annotation=>自定义注解

相比较第一种有一定规律来说,想要执行的方法没有规律可以使用这种

//自定义注解 @Retention(RetentionPolicy.RUNTIME)//设置生命周期 @Target({ElementType.METHOD})//设置注解使用位置 public @interface TimeRecord { }

//注解通过切面实现 @Aspect @Component @Slf4j public class TimeRecordAspect { @Around("@annotation(com.example.springaopdemo.aspect.TimeRecord)") public Object timeRecord(ProceedingJoinPoint joinPoint) throws Throwable { long start = System.currentTimeMillis(); Object result = joinPoint.proceed(); long end = System.currentTimeMillis(); log.info(joinPoint.getSignature() + "耗时" + (end - start) + "ms"); return result; } }

注解完成自定义之后,只要在对应方法添加该注解即可实现计算方法运行时间的功能

6.代理模式

它为另一个对象提供一个替身或占位符，以控制对这个对象的访问。其核心目的是：在不修改原始对象（目标对象）代码的前提下，通过代理对象来增强或控制对目标对象的访问。

一个标准的代理模式通常包含三个角色：

• 抽象主题 (Subject)： 定义了目标对象和代理对象的公共接口。这样在任何使用目标对象的地方都可以透明地使用代理对象。
• 真实主题 (Real Subject)： 即“目标对象”，是业务逻辑的真正执行者。
• 代理 (Proxy)： 持有对真实主题的引用，客户端直接与代理交互。代理可以在调用真实主题的前后，添加额外的处理逻辑。

分为静态代理和动态代理,区别在于代理对象的class文件生成的时机

静态代理:程序运行之前就创建好了代理对象

动态代理:程序运行时动态生成代理对象

其中动态代理有两种

• jdk动态代理=>要求目标类必须实现至少一个接口。代理对象会实现与目标类相同的接口。
• cGlib字节码增强=>当目标类没有实现接口时，Spring会使用CGLIB。它通过生成目标类的子类来创建代理，因此不能代理 final类或方法。

7.Spring AOP原理

Spring AOP是通过动态代理将横切关注点(如日志,事务)模块化,并织入到目标方法的编程范式

它的实现同时使用了jdk和CGlib

工作流程

1. Spring容器启动时,会自动扫描被@Aspect注解的类
2. 通过扫描切点表达式,找到所有匹配的Bean（即目标对象）
3. 通过ProxyFactory创建目标对象对应的代理对象(jdk/cglib)并将通知封装成拦截器链
4. 在调用代理对象方法时,拦截器链被触发,按顺序执行通知逻辑,最终调用目标方法

此外ProxyFactory有个很重要的属性proxyTargetClass,

SpringBoot默认为true,Spring默认为false

可以通过在application.properties中进行配置:spring.aop.proxy-target-class=true/false