Spring AOP 学习笔记之 Advice详解

已于 2025-04-26 18:39:41 修改
阅读量1.2k 收藏 22
点赞数 29
CC 4.0 BY-SA版权
分类专栏： Java 代理 文章标签： Spring AOP Advice执行顺序
于 2025-04-15 14:15:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/adorechen/article/details/147220277

学习材料：https://docs.spring.io/spring-framework/reference/core/aop/ataspectj/advice.html

1. 什么是 Advice（通知）

定义：Advice 是 AOP 的核心概念之一，表示在特定的连接点（Join Point）上执行的代码逻辑。
作用：通过 Advice，可以在方法调用前后、异常抛出时等位置插入自定义逻辑。

2. Advice 的类型

Spring AOP 提供了以下几种类型的 Advice：

2.1 @Before Advice

@Before 注解用于声明前置通知（Before Advice），即在目标方法执行之前执行自定义逻辑。
使用场景：适用于需要在方法执行前进行某些操作的场景，例如日志记录、权限检查等。
参数：@Before 注解可以接受一个切入点表达式，用于指定哪些方法执行前需要应用该Advice。
方法签名：@Before 方法可以有参数，但这些参数必须是Spring AOP支持的参数类型，例如 JoinPoint、ProceedingJoinPoint（仅用于 @Around）、JoinPoint.StaticPart 等。

Pointcut表达式包含在注解里的liline版示例：

@Aspect
public class BeforeExample {

	@Before("execution(* com.xyz.dao.*.*(..))")
	public void doAccessCheck() {
		// ...
	}
}

Before注解里包含的是Pointcut的signature，真正的Pointcut表达式在@Pointcut注解里定义。

@Aspect
public class BeforeExample {

	@Before("com.xyz.CommonPointcuts.dataAccessOperation()")
	public void doAccessCheck() {
		// ...
	}
}


@Aspect
public CommonPointcuts {

    @Pointcut("execute * com.xyz.dao.*.*(..)")
    public void dataAccessOperation() {
    
    }

}

2.2 @AfterReturing, @AfterThrowing, @After Advice

在Spring AOP中，@AfterReturning、@AfterThrowing 和 @After 是三种不同的通知（Advice）类型，用于在连接点（Join Point）的不同阶段执行自定义逻辑。以下是它们的详细说明：


@AfterReturning
作用：在目标方法成功执行并返回结果后执行。
使用场景：适用于需要在方法成功执行后进行日志记录、资源清理等操作的场景。
参数：可以接收返回值作为参数，通过returning属性指定参数名。

    @Pointcut("execution(* org.derek.ctroller.*.*(..))")
    public void log() {

    }

    @AfterReturning(pointcut = "log()", returning = "result")
    public void afterReturning(Object result) {
        log.info("LogAspect afterReturning ..., result: {}", result);
    }

@AfterThrowing
作用：在目标方法抛出异常后执行。
使用场景：适用于需要在方法抛出异常时进行异常处理、日志记录等操作的场景。
参数：可以接收异常对象作为参数，通过throwing属性指定参数名。

    @Pointcut("execution(* org.derek.ctroller.*.*(..))")
    public void log() {

    }

    @AfterThrowing(pointcut = "log()", throwing = "exception")
    public void afterThrowing(Exception exception) {
        log.info("LogAspect afterThrowing ...", exception);
    }

@After
作用：无论目标方法是否成功执行，都会在方法执行后执行。
使用场景：适用于需要在方法执行后进行资源清理、日志记录等操作的场景，不关心方法的执行结果。
参数：不接收任何特定参数。

@Slf4j
@Aspect
@Component
public class LogAspect {

    @Pointcut("execution(* org.derek.ctroller.*.*(..))")
    public void log() {

    }

    @After("log()")
    public void after() {
        log.info("LogAspect after ...");
    }
}

2.3 @Around Advice

Around Advice 是一种特殊的Advice，它会在匹配的方法执行前后运行。它有机会在方法执行前后执行自定义逻辑，并且可以决定方法是否执行、何时执行以及如何执行。
使用场景：Around Advice通常用于需要在方法执行前后共享状态的场景，例如启动和停止计时器。
最佳实践：总是使用满足需求的最弱形式的Advice。如果Before Advice已经足够满足需求，则不要使用Around Advice。


返回类型：Around Advice方法的返回类型应为Object。
参数：方法的第一个参数必须是ProceedingJoinPoint类型。
执行方法：在Around Advice方法体内，必须调用proceed()方法来执行目标方法。调用proceed()方法时，如果不带参数，会将调用者原始的参数传递给目标方法。

@Slf4j
@Aspect
@Component
public class LogAspect {

    @Pointcut("execution(* org.derek.ctroller.*.*(..))")
    public void log() {

    }

    @Around("log()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("LogAspect around start ...");
        long start = System.currentMillis();
        Object result = joinPoint.proceed();
        log.info("LogAspect around end ...");
        long end = System.currentMillis();
        System.out.println("cost time: " + (end-start) + "ms");
        return result;
    }
}

3 Advice的执行顺序

3.0 测试环境

使用的springboot测试依赖如下：

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>3.3.6</version>
        </dependency>

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

下面测试的Aspect准备拦截Controller的方法，Controller代码如下： 

@Slf4j
@RestController
public class HelloCtroller {

    @GetMapping("/hello")
    public String hello() {
        log.info("execute method: hello()");
        return "hello";
    }

    @GetMapping("/divide")
    public Integer divide(@RequestParam("a") Integer a, @RequestParam("b") Integer b) {
        log.info("execute method: divide(), a: {}, b: {}", a, b);
        return a/b;
    }
}

3.1 单个Aspect的各Advice执行顺序

可以看到我们LogAspect的整体代码如下：

@Slf4j
@Aspect
@Component
public class LogAspect {

    @Pointcut("execution(* org.derek.ctroller.*.*(..))")
    public void log() {

    }

    @Around("log()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("LogAspect around start ...");
        Object result = joinPoint.proceed();
        log.info("LogAspect around end ...");
        return result;
    }

    @Before("log()")
    public void before() {
        log.info("LogAspect before ...");
    }

    @AfterReturning(pointcut = "log()", returning = "result")
    public void afterReturning(Object result) {
        log.info("LogAspect afterReturning ..., result: {}", result);
    }

    @AfterThrowing(pointcut = "log()", throwing = "exception")
    public void afterThrowing(Exception exception) {
        log.info("LogAspect afterThrowing ...", exception);
    }

    @After("log()")
    public void after() {
        log.info("LogAspect after ...");
    }
}

3.1.1 方法正常返回的执行顺序

HelloController.hello() 方法会正常执行，并返回String结果。

我们执行 /hello地址的请求：

http://localhost:8080/hello

后台打印的切面日志如下：

2025-04-15T13:58:26.858+08:00  INFO 25536 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 1 ms
2025-04-15T13:58:26.888+08:00  INFO 25536 --- [nio-8080-exec-1] org.derek.aspect.LogAspect               : LogAspect around start ...
2025-04-15T13:58:26.889+08:00  INFO 25536 --- [nio-8080-exec-1] org.derek.aspect.LogAspect               : LogAspect before ...
2025-04-15T13:58:26.889+08:00  INFO 25536 --- [nio-8080-exec-1] org.derek.ctroller.HelloCtroller         : execute method: hello()
2025-04-15T13:58:26.889+08:00  INFO 25536 --- [nio-8080-exec-1] org.derek.aspect.LogAspect               : LogAspect afterReturning ..., result: hello
2025-04-15T13:58:26.889+08:00  INFO 25536 --- [nio-8080-exec-1] org.derek.aspect.LogAspect               : LogAspect after ...
2025-04-15T13:58:26.889+08:00  INFO 25536 --- [nio-8080-exec-1] org.derek.aspect.LogAspect               : LogAspect around end ...

调用方法的正常返回顺序如下：

@Around start --> @Before advice --> orginal method  --> @AfterReturing --> @After --> @Around end.

3.1.2 方法碰到异常的执行顺序

HelloController.divide(Integer a, Integer b)方法, 当b=0的时候，就会抛出除零异常。

http://localhost:8080/divide?a=2&b=0

执行的Aspect拦截日志如下：

2025-04-15T14:05:03.612+08:00  INFO 25536 --- [nio-8080-exec-5] org.derek.aspect.LogAspect               : LogAspect around start ...
2025-04-15T14:05:03.613+08:00  INFO 25536 --- [nio-8080-exec-5] org.derek.aspect.LogAspect               : LogAspect before ...
2025-04-15T14:05:03.613+08:00  INFO 25536 --- [nio-8080-exec-5] org.derek.ctroller.HelloCtroller         : execute method: divide(), a: 2, b: 0
2025-04-15T14:05:03.613+08:00  INFO 25536 --- [nio-8080-exec-5] org.derek.aspect.LogAspect               : LogAspect afterThrowing ...

java.lang.ArithmeticException: / by zero
    at org.derek.ctroller.HelloCtroller.divide(HelloCtroller.java:25) ~[classes/:na]
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:na]
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:77) ~[na:na]
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:na]
    at java.base/java.lang.reflect.Method.invoke(Method.java:568) ~[na:na]
    at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:355) ~[spring-aop-6.1.15.jar:6.1.15]

2025-04-15T14:05:03.620+08:00  INFO 25536 --- [nio-8080-exec-5] org.derek.aspect.LogAspect               : LogAspect after ...
2025-04-15T14:05:03.622+08:00 ERROR 25536 --- [nio-8080-exec-5] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed: java.lang.ArithmeticException: / by zero] with root cause

java.lang.ArithmeticException: / by zero
 

可以看到异常情况下，拦截执行顺序如下：

@Around start --> @Before Advice --> orginal method --> @AfterThrowing --> @After （--> @Around end  因为抛出异常这里不再执行）

3.2 多个Aspect的各Advice的执行顺序

1. 默认执行顺序
在 Spring AOP 中，默认情况下，Aspect 的执行顺序是未定义的。如果多个 Aspect 匹配同一个连接点（Join Point），它们的执行顺序可能会根据依赖注入的顺序、类加载顺序或其他因素动态决定。

2. 通过 @Order 注解控制顺序
可以使用 @Order 注解来显式指定 Aspect 的优先级。
数字越小，优先级越高，越先执行。
示例代码：

import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.annotation.Order;

@Aspect
@Order(1) // 优先级最高
public class FirstAspect {
    // 定义切入点和通知逻辑
}

@Aspect
@Order(2) // 次优先级
public class SecondAspect {
    // 定义切入点和通知逻辑
}

3. 通过实现 Ordered 接口
如果不想使用 @Order 注解，可以实现 org.springframework.core.Ordered 接口，并重写 getOrder() 方法。
示例代码：

import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.Ordered;

@Aspect
public class FirstAspect implements Ordered {
    @Override
    public int getOrder() {
        return 1; // 优先级最高
    }
}

@Aspect
public class SecondAspect implements Ordered {
    @Override
    public int getOrder() {
        return 2; // 次优先级
    }
}

这里为了测试实际的Aspect执行顺序，我们使用注解@Order的方式定义了两个切面：

 ControllerAspect.java, 顺序为1.

@Slf4j
@Aspect
@Component
@Order(1) // 优先级，越小越先执行
public class CtrollerAspect {

    @Pointcut("execution(* org.derek.ctroller.*.*(..))")
    public void controller() {
        System.out.println("log");
    }

    @Around("controller()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("around advice start ...");
        Object proceed = joinPoint.proceed();
        log.info("around advice end ...");
        return proceed;
    }

    @Before("controller()")
    public void before() {
        log.info("before advice ...");
    }

    @AfterReturning(pointcut = "controller()", returning = "result")
    public void afterReturning(Object result) {
        log.info("afterReturning advice ..., result: {}", result);
    }

    @AfterThrowing(pointcut = "controller()", throwing = "exception")
    public void afterThrowing(Exception exception) {
        log.info("afterThrowing advice ...", exception);
    }

    @After("controller()")
    public void after() {
        log.info("after advice ...");
    }
}

LogAspect.java, 顺序为2.

@Slf4j
@Aspect
@Component
@Order(2)
public class LogAspect {

    @Pointcut("execution(* org.derek.ctroller.*.*(..))")
    public void log() {

    }

    @Around("log()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("LogAspect around start ...");
        Object result = joinPoint.proceed();
        log.info("LogAspect around end ...");
        return result;
    }

    @Before("log()")
    public void before() {
        log.info("LogAspect before ...");
    }

    @AfterReturning(pointcut = "log()", returning = "result")
    public void afterReturning(Object result) {
        log.info("LogAspect afterReturning ..., result: {}", result);
    }

    @AfterThrowing(pointcut = "log()", throwing = "exception")
    public void afterThrowing(Exception exception) {
        log.info("LogAspect afterThrowing ...", exception);
    }

    @After("log()")
    public void after() {
        log.info("LogAspect after ...");
    }
}

执行相同的hello方法，调用日志如下：

2025-04-15T13:52:45.672+08:00  INFO 32288 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 0 ms
2025-04-15T13:52:45.705+08:00  INFO 32288 --- [nio-8080-exec-1] org.derek.aspect.CtrollerAspect          : around advice start ...
2025-04-15T13:52:45.705+08:00  INFO 32288 --- [nio-8080-exec-1] org.derek.aspect.CtrollerAspect          : before advice ...
2025-04-15T13:52:45.705+08:00  INFO 32288 --- [nio-8080-exec-1] org.derek.aspect.LogAspect               : LogAspect around start ...
2025-04-15T13:52:45.705+08:00  INFO 32288 --- [nio-8080-exec-1] org.derek.aspect.LogAspect               : LogAspect before ...
2025-04-15T13:52:45.705+08:00  INFO 32288 --- [nio-8080-exec-1] org.derek.ctroller.HelloCtroller         : execute method: hello()
2025-04-15T13:52:45.705+08:00  INFO 32288 --- [nio-8080-exec-1] org.derek.aspect.LogAspect               : LogAspect afterReturning ..., result: hello
2025-04-15T13:52:45.707+08:00  INFO 32288 --- [nio-8080-exec-1] org.derek.aspect.LogAspect               : LogAspect after ...
2025-04-15T13:52:45.707+08:00  INFO 32288 --- [nio-8080-exec-1] org.derek.aspect.LogAspect               : LogAspect around end ...
2025-04-15T13:52:45.707+08:00  INFO 32288 --- [nio-8080-exec-1] org.derek.aspect.CtrollerAspect          : afterReturning advice ..., result: hello
2025-04-15T13:52:45.707+08:00  INFO 32288 --- [nio-8080-exec-1] org.derek.aspect.CtrollerAspect          : after advice ...
2025-04-15T13:52:45.707+08:00  INFO 32288 --- [nio-8080-exec-1] org.derek.aspect.CtrollerAspect          : around advice end ...

执行的时序图如下：

可以看到，多个切面执行顺序如下：

1) @Order（1）的切面方法  @Around start --> @Before Advice

2) @Order（2）的切面方法 @Around start --> @Before Advice 

3) 执行原始的方法 original method

4) @Order（2）的切面方法 @AfterReturning/@AfterThrowing --> @After --> @Adround end

5)@Order（1）的切面方法 @AfterReturning/@AfterThrowing --> @After --> @Adround end

【Spring】AOP——通知（Advice）
wosixiaokeai的博客
05-23 1195
1.1简介1.2常见的通知类型。
AOP Advice，Pointcut，Joinpoint和Advisor
最新发布
weixin_43970625的博客
05-12 842
定义：Advice是一个接口，是AOP中的一个核心概念，表示切面在连接点（程序执行的特定点，如方法的调用或异常的抛出）上执行的操作。用于定义在连接点上执行的增强逻辑。它本身不是连接点，而是在连接点触发时执行的一段代码。作用：Advice用于在方法执行前、执行后、抛出异常时等不同的执行点插入额外的逻辑，类似于AOP中的切面。它可以用于在不修改原始方法的情况下，实现一些横切关注点的功能，比如日志记录、性能监控、事务管理等。是程序执行过程中某个特定的位置，例如方法调用前、调用后或抛出异常后等。
Spring AOP名词解释Advice,Pointcut,Advisor,Joinpoint,Advised是什么？
yangzsirr的博客
10-22 3710
Advice advice解释为通知，需要执行的增强逻辑方法。 advice规范接口如图，分为了before，after等等，为什么没有around呢，因为是通过interceptor实现的。 这里可以看出，AfterAdvice最终会被转换包装成MethodBeforeAdviceInterceptor实现类进行适配桥接，同理BeforeAdvice也会被包装成MethodBeforeAdviceInterceptor最终调用MethodIntercepter#invoke()方法进行适配。
4种实例 advice aop_面试官经常问AOP，那到底啥是AOP？
weixin_39581652的博客
12-27 292
1. 定义AOP意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。我的理解是纵向关系是OOP，横向角度是 AOP。2.OOP 与 AOP 的区别面向目标不同：简单来说 OOP 是面向名词领域，AOP 面向动词领域。思想结构不同：OOP 是纵向结...
Spring源码分析----AOP概念(Advice,Pointcut,Advisor)和AOP的设计与实现
a657281084的博客
11-13 5002
一、基本知识 1.1.AOP基本概念： Aspect-Oriented Programming，面向方面编程的简称，Aspect是一种新的模块化机制，用来描述分散在对象、类或方法中的横切关注点(crosscutting concern)，从关注点中分离出横切关注点是面向方面程序设计的核心所在。分离关注点使得解决特定领域问题的代码从业务逻辑中独立出来，业务逻辑的代码中不再含有针对特定领域
Spring Advice 全局异常处理
howeres的博客
04-29 1436
Advice类 由 @ControllerAdvice 和 多个@ExceptionHandler 组成 @ControllerAdvice 只作用于 控制器 相关的功能。默认是全局应用。 通过 @ControllerAdvice 的属性 value / basePackages = {"com.didi.controller"} 代表范围限定在某个包，basePackageClasses 是前面的类型安全写法，表示类所在的包。 通过 @ControllerAdvice 的属性 assignableTyp
SpringAop学习笔记以及实现Demo
06-17
**Spring AOP 学习笔记及实现Demo** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架中的一个重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。AOP的主要目的...
Spring学习笔记——AOP
qq_47102228的博客
04-11 824
Spring AOP，AspectJ
Spring 2.5 学习笔记：IOC, AOP, 注解配置详解
"这篇学习笔记主要涵盖了Spring框架2.5版本的相关知识，包括面向抽象编程、JDOM的使用、Spring环境搭建、IOC(DI)配置、注解方式的Spring使用、AOP概念与配置以及Spring与其他框架SSH的整合。笔记详细讲解了Spring的...
Spring 2.5 学习：IOC, DI, AOP, 注解详解
"Spring2.5 学习笔记" 在学习Spring框架的2.5版本时，我们会接触到一系列关键概念和技术。以下是对这些知识点的详细解释： 1. 面向抽象编程：这是软件设计的一个基本原则，它提倡在设计时考虑接口而非具体的实现，...
狂神说Java-Spring学习笔记
05-17
### 知识点详解 #### 1. 什么是Spring？ Spring是一个开源的Java平台框架，由Rod Johnson在2002年创立，并于2004年发布首个正式版本。Spring最初被称为Interface21框架，随后经过重设计并扩展功能，成为了一个功能...
spring Aop 中 Advice, advisor和Advised关系
面朝大海，春暖花开
10-18 462
使用 spring Aop 定义增强,而不是用 AspectJ@Slf4j@Override@Bean@Bean。
Spring AOP源码篇一之 PointCut、Advice、Advisor学习
Deep Water Slow
06-30 1318
Spring Aop 之 Pointcut、Advice、Advisor
【ZT】Spring 3 AOP 总结
laetitia_wang记事本
07-04 366
概念 AOP（Aspect Oriented Programming），即面向切面编程（也叫面向方面编程，面向方法编程）。其主要作用是，在不修改源代码的情况下给某个或者一组操作添加额外的功能。像日志记录，事务处理，权限控制等功能，都可以用AOP来“优雅”地实现，使这些额外功能和真正的业务逻辑分离开来，软件的结构将更加清晰。AOP是OOP的一个强有力的补充。 术语 AOP的术语不太直观，Spr...
Spring Advice
weixin_30732825的博客
10-16 167
SpringAOP(面向方面编程)框架，用于在模块化方面的横切关注点。简单得说，它只是一个拦截器拦截一些过程，例如，当一个方法执行，SpringAOP 可以劫持一个执行的方法，在方法执行之前或之后添加额外的功能。 在SpringAOP中，有 4 种类型通知(advices)的支持： 通知(Advice)之前-该方法执行前运行 通知(Advice)返回之后–运...
@ControllerAdvice 的介绍及三种用法
热门推荐
fadai
09-23 10万+
@ControllerAdvice 的介绍及三种用法 浅析@ControllerAdvice 首先，ControllerAdvice本质上是一个Component，因此也会被当成组建扫描，一视同仁，扫扫扫。 然后，我们来看一下此类的注释： 这个类是为那些声明了（@ExceptionHandler、@InitBinder 或 @ModelAttribute注解修饰的）方法的类而提供的专业化的...
AOP，动态切面 ~ advice
Java博客
01-19 746
AOP，动态切面~advice对象
Spring AOP，Before Advices、After Advice、Around Advice、Throw Advice的解析与使用。
hjw0505521的博客
03-17 951
AOP是一个横向的关系：如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将空心圆柱体剖开，以获得其内部的消息。而剖开的切面又能将剖开的切面复原，不留痕迹。 AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离”。 切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象（比如事务管理）； 在Spring ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值