我要评论前言
在oop的思想中，一切皆以对象为核心，将数据与操作数据的方法封装在一起，通过封装、继承、多态等特性实现高内聚、低耦合的代码结构。高内聚和低耦合正是我们开发程序所要遵循的两大终极目标。
试想一下，如果有一项业务开发的逻辑，此时我们实现它需要发现需要修改核心源码，这显然不利于程序的维护。那么有什么办法能实现不修改源码的情况下动态扩展功能呢，答案显而易见，通过代理模式，建立代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作。
当然在spring中已经提供了一套成熟的解决方案，无需我们手动实现代理模式，它就是大名鼎鼎的spring aop。本篇文章我将和大家一起梳理aop这种编程范式，讨论在spring boot中应用aop编程。
一、什么是aop
aop全称aspect oriented programming，直译过来是 面向切面编程。这其实是一种编程范式，它允许我们不修改源代码的情况下，给程序中动态得添加扩展功能，是作为面向对象的一个补充，方便我们去维护程序，提高模块的内聚性，降低模块间的耦合。通过预编译方式和运行期动态代理实现程序功能的统一维护。通过aop，我们就能实现给特定的方法添加特点的逻辑，比如记录方法的执行时间，操作日志。事实上spring中的事务也是spring通过aop实现的。
二、aop的核心概念
2.1 连接点（join point）
连接点指的是程序执行过程中可以插入切面代码的特定位置，在spring中简单来说就是可以被aop控制的方法，即方法调用。
比方说下面这个studentserviceimpl里的findall方法，这个findall方法的每一次调用就是一个连接点。spring aop中，默认情况下，ioc容器中bean的 public方法可作为连接点。
@service
public class studentserviceimpl implements studentservice {
private final studentmapper studentmapper;
@override
public list<student> findall() {
return studentmapper.findall();
}
}
2.2 通知（advice）
通知被定义为在特定连接点上执行的动作，像我们要织入的横切自定义逻辑，比如记录方法的执行时间，操作日志这种。spring aop中通知分为以下几类：
- 前置通知（before）：在方法执行前运行。
- 后置通知（after）：无论方法是否异常，都会在方法结束后运行。
- 返回通知（afterreturning）：方法成功返回后运行。
- 异常通知（afterthrowing）：方法抛出异常时运行。
- 环绕通知（around）：包围整个方法调用，可控制是否执行原方法
通知在spring aop中的作用是用来告诉定义的自定义逻辑应该放在什么时候执行。
2.3 切入点（pointcut）
切入点是一个表达式，用来定义匹配连接点，也就是指定哪些连接点（join point）需要应用通知（advice）。一般情况下，切入点的设置的越局限，通知的应用范围就越小，aop执行的效率就越大。所以在实际生产环境下，最好避免对所有方法都织入逻辑。切入点其实就是指定自定义逻辑在哪里执行。
在spring boot中定义切入点是通过在空方法上通过@pointcut注解来定义匹配连接点。
定义一个名为servicepointcut的切入点，匹配所有public修饰、返回值为任意类型的org.araby.blognovelink.service.impl.studentserviceimpl类下的所有方法
@pointcut("execution(public * org.araby.blognovelink.service.impl.studentserviceimpl.*(..))")
public void servicepointcut(){}
2.3.1 execution定义匹配连接点
通过execution定义匹配连接点格式是
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)
- modifiers-pattern：访问修饰符public、private这种，可选；
- ret-type-pattern：返回值类型，如void、string、*表示任意返回值，必选；
- declaring-type-pattern：全类名，…表示当前包及子包，可选；
- name-pattern：方法名称，*表示任意方法，必选；
- param-pattern：方法参数列表，…表示任意参数），必选；
- throws-pattern：异常类型，可选。
2.3.2 annotation定义匹配连接点
还有一种方式是通过注解来定义匹配连接点
自定义@log注解：
import java.lang.annotation.*;
@target(elementtype.method) // 仅作用于方法
@retention(retentionpolicy.runtime) // 运行时保留，可通过反射获取
@documented
public @interface log {
string value() default ""; // 注解属性，用于描述日志内容
}定义切入点，匹配被@log注解标记的方法
@before("@annotation(org.araby.blognovelink.annotation.log)")
public void beforeadvice(joinpoint joinpoint){
string methodname = joinpoint.getsignature().getname();
object[] args = joinpoint.getargs();
log.info("【前置通知】方法名：" + methodname + "，参数：" + arrays.tostring(args));
}
最后在方法上添加注解就能织入自定义的逻辑
@log
@override
public boolean update(student student) {
student.setupdatetime(java.time.localdate.now());
return studentmapper.update(student) > 0;
}
2.4 切面
通知加切入点的组合就是切面。前面提到’通知’是设置我们自定义逻辑应该放在什么时候执行，切入点是设置自定义逻辑在哪里执行。这两者组合起来就是切面，即在哪些地方做什么，这就是切面
在spring boot中，切面类是由@aspect 修饰，我们在里面定义切入点和通知。
比方说这个被@aspect修饰的logaspect类，它包含一个servicepointcut切入点，和一个beforeadvice()前置通知方法。
@slf4j
@aspect
@component
public class logaspect {
@pointcut("execution(public * org.araby.blognovelink.service.impl.studentserviceimpl.*(..))")
public void servicepointcut(){}
@before("servicepointcut()")
public void beforeadvice(joinpoint joinpoint){
string methodname = joinpoint.getsignature().getname();
object[] args = joinpoint.getargs();
log.info("【前置通知】方法名：" + methodname + "，参数：" + arrays.tostring(args));
}
}2.5 目标对象（target object）
目标对象既被一个或多个切面通知的对象，在spring aop中，目标对象必须是bean对象，它和切面对象一样是交由spring ioc容器管理，目标对象总是被代理包装，使用jdk动态代理或cglib。
spring aop正是通过代理模式来增强原始对象的能力。
2.6 小结
总的来说，在spiring aop中，通过切面（aspect） 通过 切入点（pointcut） 找到 连接点（join point），然后在目标对象（target object） 的方法中执行时织入通知（advice），这样就能实现原始对象的功能增强。
三、spring boot中使用aop
3.1 引入spring boot aop依赖
dependencies层级下添加spring boot aop依赖
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-aop</artifactid>
</dependency>
3.2 编写切面类
在编写切面类之前，我们假设有个名为studentserviceimpl的业务类作为目标对象，全类名为org.araby.blognovelink.service.impl.studentserviceimpl。以下的切入点都匹配的是studentserviceimpl的findbyid方法。业务类
@service
public class studentserviceimpl implements studentservice {
private final studentmapper studentmapper;
@autowired
public studentserviceimpl(studentmapper studentmapper) {
this.studentmapper = studentmapper;
}
@override
public student findbyid(integer id) {
return studentmapper.findbyid(id);
}
}然后我们编写一个切面类来实现前置通知，返回通知，异常通知，后置通知和环绕通知。
3.2.1 前置通知-@before
如果我们想在目标对象的方法前执行逻辑，可以选用@before注解修饰的前置通知，前置通知方法的参数包括joinpoint ，这个正是连接点，包含目标对象方法的元数据。比方说可以通过joinpoint的getsignature()获取方法信息。
/**
* 前置通知
* @param joinpoint
*/
@before("servicepointcut()")
public void beforeadvice(joinpoint joinpoint){
string methodname = joinpoint.getsignature().getname();
object[] args = joinpoint.getargs();
log.info("【前置通知】方法名：" + methodname + "，参数：" + arrays.tostring(args));
}[info ] [2025-12-10 21:34:59.688] [http-nio-9090-exec-2] [req-7eaebf76034c4b0aa3ef5d8bc6da1536] o.araby.blognovelink.aop.logaspect - 【前置通知】方法名：findbyid，参数：[1]
3.2.2 返回通知-@afterreturning
标记返回通知的@afterreturning注解包括一个额外的属性returning 。在下面的示例代码中相当于告诉 spring，把目标方法的返回值，赋值给通知方法中名为student的那个参数。也就是returning的值和通知方法的参数名称要一致，且参数类型需兼容目标方法的返回值类型。
/**
* 返回通知
* @param joinpoint
* @param student
*/
@afterreturning(value = "servicepointcut()",returning = "student")
public void afterreturning(joinpoint joinpoint, object student){
string methodname = joinpoint.getsignature().getname();
object[] args = joinpoint.getargs();
log.info("【返回通知】方法名：" + methodname + "，返回值：" + student);
}
[info ] [2025-12-10 21:55:53.748] [http-nio-9090-exec-7] [req-2ac8142014ae4f53af7a0d71652071cf] o.araby.blognovelink.aop.logaspect - 【返回通知】方法名：findbyid，返回值：student(id=1, name=巢治文, age=28, sex=男, classno=eu, createtime=2025-11-08, updatetime=2025-11-08)
3.2.3 异常通知-@afterthrowing
afterthrowing注解多了一个throwing属性，当目标方法执行异常触发。
/**
* 异常通知
* @param joinpoint
* @param e
*/
@afterthrowing(value = "servicepointcut()",throwing = "e")
public void afterthrowingadvice(joinpoint joinpoint,exception e){
string methodname = joinpoint.getsignature().getname();
object[] args = joinpoint.getargs();
log.info("【异常通知】方法名：" + methodname + "，异常信息：" + e.getmessage());
}
[info ] [2025-12-10 22:01:26.235] [http-nio-9090-exec-3] [req-33bd8436c6f5495bad13d924c7be1887] o.araby.blognovelink.aop.logaspect - 【异常通知】方法名：findbyid，异常信息：发生异常
3.2.4 后置通知-@after
后置通知的方法内部包含joinpoint属性，用于获取连接点信息。该逻辑是在方法执行后触发。
/**
* 后置通知
* @param joinpoint
*/
@after("servicepointcut()")
public void afteradvice(joinpoint joinpoint){
string methodname = joinpoint.getsignature().getname();
object[] args = joinpoint.getargs();
log.info("【后置通知】方法名：" + methodname + "，执行结束");
}
3.2.5 环绕通知-@around
环绕通知是这几个通知中最为强大的，因为它可以在方法执行的全部生命周期中应用。环绕通知方法有一个核心的proceedingjoinpoint参数，在我们调用proceedingjoinpoint.proceed()的时候才实际执行目标方法，获取返回值就相当于实现了返回通知的效果。在此之前是前置通知逻辑，再次之后是后置通知逻辑。如果对proceedingjoinpoint.proceed()编写异常捕捉，那就是实现了异常通知。
比方说这里我们通过环绕通知实现了一个记录方法执行时间的逻辑。
/**
* 环绕通知：记录方法执行时间
* @param proceedingjoinpoint 连接点（目标方法）
* @return 目标方法的返回值
* @throws throwable 目标方法抛出的异常
*/
@around("servicepointcut()")
public object aroundadvice(proceedingjoinpoint proceedingjoinpoint) throws throwable {
string methodname = proceedingjoinpoint.getsignature().getname();
string classname = proceedingjoinpoint.gettarget().getclass().getname();
object[] args = proceedingjoinpoint.getargs();
object result = null;
// 开始时间
long starttime = system.nanotime();
try {
// 执行目标方法
result = proceedingjoinpoint.proceed();
} catch (exception e) {
log.info("【方法执行异常】类：{}，方法：{}，参数：{}，异常信息：{}",
classname, methodname, arrays.tostring(args), e.getmessage());
throw e;
} finally {
// 结束时间
long endtime = system.nanotime();
long durationnano = endtime - starttime; // 纳秒耗时
double durationms = durationnano / 1_000_000.0; // 转换为毫秒
log.info("【方法执行时间】类：{}，方法：{}，参数：{}，执行耗时：{}毫秒",
classname, methodname, arrays.tostring(args),durationms);
}
return result;[info ] [2025-12-10 22:17:25.036] [http-nio-9090-exec-4] [req-1e52d539f11344509218706010f1e829] o.araby.blognovelink.aop.logaspect - 【方法执行时间】类：org.araby.blognovelink.service.impl.studentserviceimpl，方法：findbyid，参数：[1]，执行耗时：50.0671毫秒
四、spring aop的实现原理
spring aop的底层实现依赖于动态代理技术，主要有两种代理方式：jdk动态代理和cglib动态代理。spring会根据目标对象的类型自动选择合适的代理方式。
若目标对象实现了接口，spring默认使用jdk动态代理，若目标对象没有实现接口，spring会使用cglib动态代理。
application.yml添加配置spring.aop.proxy-target-class=true，可以强制使用cglib代理
4.1 jdk动态代理
jdk动态代理是基于java反射机制实现的，它要求目标对象必须实现一个或多个接口。spring通过java.lang.reflect.proxy类创建代理对象，代理对象会实现目标对象的所有接口，并重写接口中的方法，在重写的方法中织入切面逻辑。也就是目标对象必须实现接口，否则无法使用。
4.2 cglib动态代理
cglib（code generation library）是一个第三方字节码生成库，它通过继承目标对象的方式创建代理对象，生成目标对象的子类，并重写子类中的方法，织入切面逻辑。因此，cglib不要求目标对象实现接口，即使是没有实现任何接口的类，也能通过cglib生成代理。由于是基于继承实现的，所以目标对象的final方法无法被代理。
五、多个spring aop的执行顺序
多个aop组合在一起，若是匹配到了相同的目标方法，可以通过@order注解指定切面的执行顺序，值越小，优先级越高。我们要把这种优先级当作先进后出的栈结构。假设c的优先级高于b，b的优先级高于a。那么c的前置逻辑最先，后置逻辑最后。
前置通知、环绕通知的前置逻辑按@order值从小到大执行，order值越小越先执行；后置通知、返回通知、异常通知、环绕通知的后置逻辑按@order值从大到小执行,order值越小越后执行.
[info ] [2025-12-10 22:29:21.568] [http-nio-9090-exec-1] [req-ebd5296f7aaa4225bcea5f87a4008007] o.a.blognovelink.aop.anotheraspect - 【另一个】【前置通知】方法名：findbyid，参数：[1] [info ] [2025-12-10 22:29:21.568] [http-nio-9090-exec-1] [req-ebd5296f7aaa4225bcea5f87a4008007] o.araby.blognovelink.aop.logaspect - 【前置通知】方法名：findbyid，参数：[1] [info ] [2025-12-10 22:29:21.618] [http-nio-9090-exec-1] [req-ebd5296f7aaa4225bcea5f87a4008007] o.araby.blognovelink.aop.logaspect - 【返回通知】方法名：findbyid，返回值：student(id=1, name=巢治文, age=28, sex=男, classno=eu, createtime=2025-11-08, updatetime=2025-11-08) [info ] [2025-12-10 22:29:21.618] [http-nio-9090-exec-1] [req-ebd5296f7aaa4225bcea5f87a4008007] o.araby.blognovelink.aop.logaspect - 【后置通知】方法名：findbyid，执行结束 [info ] [2025-12-10 22:29:21.618] [http-nio-9090-exec-1] [req-ebd5296f7aaa4225bcea5f87a4008007] o.araby.blognovelink.aop.logaspect - 【方法执行时间】类：org.araby.blognovelink.service.impl.studentserviceimpl，方法：findbyid，参数：[1]，执行耗时：49.6057毫秒 [info ] [2025-12-10 22:29:21.618] [http-nio-9090-exec-1] [req-ebd5296f7aaa4225bcea5f87a4008007] o.a.blognovelink.aop.anotheraspect - 【另一个】【返回通知】方法名：findbyid，返回值：student(id=1, name=巢治文, age=28, sex=男, classno=eu, createtime=2025-11-08, updatetime=2025-11-08) [info ] [2025-12-10 22:29:21.618] [http-nio-9090-exec-1] [req-ebd5296f7aaa4225bcea5f87a4008007] o.a.blognovelink.aop.anotheraspect - 【另一个】【后置通知】方法名：findbyid，执行结束 [info ] [2025-12-10 22:29:21.618] [http-nio-9090-exec-1] [req-ebd5296f7aaa4225bcea5f87a4008007] o.a.blognovelink.aop.anotheraspect - 【另一个】【方法执行时间】类：org.araby.blognovelink.service.impl.studentserviceimpl，方法：findbyid，参数：[1]，执行耗时：50.2602毫秒
总结
本文详细介绍了spring aop的核心概念、在spring boot中的使用方式、实现原理及多切面执行顺序，aop作为面向对象编程的补充，通过横切逻辑的分离，能有效简化日志、事务、权限等功能的开发，提升代码的可维护性和复用性。在实际项目中，合理使用 aop可以让业务逻辑更专注于核心功能，同时实现横切需求的统一管理。
到此这篇关于如何使用spring aop优雅实现横切逻辑复用的文章就介绍到这了,更多相关spring aop横切逻辑复用内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论