分析 Spring 的 AOP 实现原理与切点表达式

于 2025-05-26 23:02:46 发布
阅读量781 收藏 25
点赞数 36
分类专栏： Java知识 文章标签： spring python java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73355603/article/details/148241458
版权

 

目录

一、AOP 核心概念

1.1 基本术语

二、Spring AOP 实现原理

2.1 代理机制

2.1.1 JDK 动态代理

2.1.2 CGLIB 代理

2.1.3 代理选择策略

2.2 AOP 处理流程

三、切点表达式详解

3.1 切点表达式语法

3.2 常见切点类型

3.2.1 方法执行（execution）

3.2.2 注解匹配（@annotation）

3.2.3 类型匹配（within）

3.2.4 Bean 名称匹配（bean）

3.2.5 参数匹配（args）

四、复合切点表达式

五、通知参数绑定

5.1 JoinPoint

5.2 返回值绑定（AfterReturning）

5.3 异常绑定（AfterThrowing）

5.4 环绕通知（Around）

六、AOP 实现示例

6.1 定义切面

6.2 启用 AOP

七、AOP 应用场景

7.1 事务管理

7.2 权限验证

7.3 日志记录

7.4 性能监控

八、最佳实践

8.1 切点表达式优化

8.2 通知类型选择

8.3 性能考虑

8.4 调试技巧

九、总结

一、AOP 核心概念

1.1 基本术语

  • 切面（Aspect）：封装横切关注点的模块，包含通知和切点。
  • 通知（Advice）：切面在特定连接点执行的增强逻辑，包括：
    • 前置通知（Before）：方法调用前执行
    • 后置通知（After）：方法调用后执行（无论是否异常）
    • 返回通知（AfterReturning）：方法正常返回后执行
    • 异常通知（AfterThrowing）：方法抛出异常后执行
    • 环绕通知（Around）：包围方法调用，可自定义执行时机
  • 切点（Pointcut）：定义匹配连接点的规则，确定通知何时执行。
  • 连接点（Join Point）：程序执行过程中的特定点（如方法调用、异常抛出）。
  • 织入（Weaving）：将切面逻辑插入目标对象的过程，分为编译时、类加载时和运行时织入。

二、Spring AOP 实现原理

2.1 代理机制

Spring AOP 基于动态代理实现，支持两种代理方式：

2.1.1 JDK 动态代理
  • 基于接口：代理对象实现目标接口，通过 InvocationHandler 拦截方法调用。
  • 限制：只能代理实现了接口的类。
// JDK 动态代理示例
interface UserService {
    void createUser(String username);
}

class UserServiceImpl implements UserService {
    @Override
    public void createUser(String username) {
        System.out.println("Creating user: " + username);
    }
}

// 代理处理器
class LoggingInvocationHandler implements InvocationHandler {
    private final Object target;
    
    public LoggingInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

// 创建代理
UserService target = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(
    UserService.class.getClassLoader(),
    new Class<?>[]{UserService.class},
    new LoggingInvocationHandler(target)
);
2.1.2 CGLIB 代理
  • 基于子类：通过继承目标类生成子类，重写方法实现拦截。
  • 限制：无法代理 final 类或 final 方法。
// CGLIB 代理示例
class ProductService {
    public void updatePrice(String productId, double price) {
        System.out.println("Updating price for " + productId + " to " + price);
    }
}

// 方法拦截器
class TransactionInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Begin transaction");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("Commit transaction");
        return result;
    }
}

// 创建代理
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(ProductService.class);
enhancer.setCallback(new TransactionInterceptor());
ProductService proxy = (ProductService) enhancer.create();
2.1.3 代理选择策略
  • 默认规则：
    • 若目标对象实现了接口，使用 JDK 动态代理。
    • 若目标对象未实现接口，使用 CGLIB 代理。
  • 强制 CGLIB：通过 @EnableAspectJAutoProxy(proxyTargetClass = true) 配置。

2.2 AOP 处理流程

  1. 定义切面：通过 @Aspect 注解标记切面类，定义通知和切点。
  2. 创建代理：容器启动时，根据切点匹配规则为目标 Bean 创建代理对象。
  3. 方法调用：客户端调用代理对象的方法。
  4. 拦截处理：代理对象根据切面配置，在连接点执行通知逻辑。
  5. 目标方法执行：通知逻辑中调用目标方法或直接返回结果。

三、切点表达式详解

3.1 切点表达式语法

Spring AOP 使用 AspectJ 切点表达式语言，主要通配符：

  • *：匹配任意数量字符（不含包路径分隔符）。
  • ..：匹配任意数量字符（含包路径分隔符），或任意参数。
  • +：匹配指定类及其子类。

3.2 常见切点类型

3.2.1 方法执行（execution）
// 匹配 com.example.service 包下所有类的所有方法
execution(* com.example.service.*.*(..))

// 匹配 UserService 接口的所有方法
execution(* com.example.service.UserService.*(..))

// 匹配以 "get" 开头的方法
execution(* com.example.service.*.get*(..))

// 匹配返回类型为 String 的方法
execution(String com.example.service.*.*(..))

// 匹配带两个参数的方法
execution(* com.example.service.*.*(java.lang.String, int))
3.2.2 注解匹配（@annotation）

java

// 匹配带 @Transactional 注解的方法
@annotation(org.springframework.transaction.annotation.Transactional)

// 自定义注解示例
@annotation(com.example.annotation.Loggable)
3.2.3 类型匹配（within）
// 匹配指定包下的所有类
within(com.example.service.*)

// 匹配指定包及其子包下的所有类
within(com.example.service..*)

// 匹配特定类
within(com.example.service.UserServiceImpl)
3.2.4 Bean 名称匹配（bean）
// 匹配名称以 "service" 结尾的 Bean
bean(*Service)

// 匹配特定 Bean
bean(userService)

3.2.5 参数匹配（args）

// 匹配参数类型为 String 和 Integer 的方法
args(java.lang.String, java.lang.Integer)

// 匹配实现 Serializable 接口的参数
args(java.io.Serializable)

四、复合切点表达式

通过逻辑运算符组合多个切点：

  • &&：与
  • ||：或
  • !：非

// 匹配 UserService 接口的所有方法，且不带 @ReadOnly 注解
execution(* com.example.service.UserService.*(..)) && !@annotation(com.example.annotation.ReadOnly)

// 匹配 service 包下的所有方法，或带 @Loggable 注解的方法
within(com.example.service.*) || @annotation(com.example.annotation.Loggable)

五、通知参数绑定

通知方法可通过参数获取连接点信息：

5.1 JoinPoint

@Before("execution(* com.example.service.*.*(..))")
public void beforeAdvice(JoinPoint joinPoint) {
    // 获取方法签名
    Signature signature = joinPoint.getSignature();
    // 获取方法参数
    Object[] args = joinPoint.getArgs();
    // 获取目标对象
    Object target = joinPoint.getTarget();
}

5.2 返回值绑定（AfterReturning）

@AfterReturning(pointcut = "execution(* com.example.service.*.get*(..))", returning = "result")
public void afterReturning(JoinPoint joinPoint, Object result) {
    // 处理返回值
}

5.3 异常绑定（AfterThrowing）

@AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "ex")
public void afterThrowing(JoinPoint joinPoint, Exception ex) {
    // 异常处理
}

5.4 环绕通知（Around）

@Around("execution(* com.example.service.*.*(..))")
public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
    // 前置处理
    Object result = joinPoint.proceed(); // 调用目标方法
    // 后置处理
    return result;
}

六、AOP 实现示例

6.1 定义切面

@Aspect
@Component
public class LoggingAspect {
    
    // 定义切点
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethods() {}
    
    // 前置通知
    @Before("serviceMethods()")
    public void beforeServiceMethod(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }
    
    // 环绕通知
    @Around("serviceMethods()")
    public Object aroundServiceMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long endTime = System.currentTimeMillis();
        System.out.println("Method " + joinPoint.getSignature().getName() + " executed in " + (endTime - startTime) + "ms");
        return result;
    }
}

6.2 启用 AOP

@SpringBootApplication
@EnableAspectJAutoProxy
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

七、AOP 应用场景

7.1 事务管理

@Transactional
public void transferFunds(String fromAccount, String toAccount, double amount) {
    // 业务逻辑
}

7.2 权限验证

@Before("@annotation(com.example.annotation.RequiresAdmin)")
public void checkAdminPermission(JoinPoint joinPoint) {
    // 验证用户权限
}

7.3 日志记录

@Around("execution(* com.example.repository.*.*(..))")
public Object logRepositoryMethods(ProceedingJoinPoint joinPoint) throws Throwable {
    Logger logger = LoggerFactory.getLogger(joinPoint.getTarget().getClass());
    logger.debug("Calling method: {}", joinPoint.getSignature().getName());
    Object result = joinPoint.proceed();
    logger.debug("Method returned: {}", result);
    return result;
}

7.4 性能监控

@Around("execution(* com.example.service.*.*(..))")
public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
    long startTime = System.currentTimeMillis();
    Object result = joinPoint.proceed();
    long endTime = System.currentTimeMillis();
    System.out.printf("Method %s.%s took %d ms%n", 
        joinPoint.getTarget().getClass().getName(),
        joinPoint.getSignature().getName(),
        endTime - startTime);
    return result;
}

八、最佳实践

8.1 切点表达式优化

  • 避免过于宽泛的切点：如 execution(* *(..))，可能导致意外拦截。
  • 使用命名切点：提高表达式复用性。
  • 优先使用注解：通过自定义注解标记需要增强的方法。

8.2 通知类型选择

  • 环绕通知慎用：功能强大但易出错，优先使用其他通知类型。
  • 异常处理：确保 @AfterThrowing 通知捕获特定异常类型。

8.3 性能考虑

  • 减少反射调用：环绕通知中避免多次调用 proceed()。
  • 代理创建开销：大量 Bean 被代理时可能影响启动性能。

8.4 调试技巧

  • 启用调试日志：配置 org.springframework.aop 日志级别为 DEBUG。
  • 使用 @Order 注解：控制多个切面的执行顺序。

九、总结

Spring AOP 通过动态代理机制实现横切关注点的模块化，结合 AspectJ 切点表达式提供了强大的方法拦截能力。理解其实现原理和切点表达式语法，有助于开发者在事务管理、权限控制、日志记录等场景中合理应用 AOP，提升代码的可维护性和复用性。

Spring——AOP原理及流程详解
共勉
11-28 1万+
基于5.3.9 版本的Spring源码，对AOP原理及流程详解，AOP是在Bean生成流程中什么位置介入处理的？各个通知方法又是怎么组装的？AOP真的只是动态代理这么简单吗？
Spring的Aop原理
qq_59438034的博客
11-20 656
Aop(Aspect Oriented Programming)是一种的编程思想，是面向对象（OOP）编程的一种补充和完善。它通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一的添加额外的功能的一种技术。
Spring框架系列之第三章 AOP
qq_36595761的博客
09-09 588
AOP前奏 提出问题 情景：数学计算器 1) 要求   ①执行加减乘除运算   ②日志：在程序执行期间追踪正在发生的活动   ③验证：希望计算器只能处理正数的运算 2) 常规实现 3) 问题   ①代码混乱：越来越多的非业务需求(日志和验证等)加入后，原有的业务方法急剧膨胀。每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点。   ②代码分散: 以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里多次重复相同的日志代码。如果日志需求发生变化，必须修改所有模块。 动态代理 动态代理的原
AOP技术原理详解
最新发布
sen_ice的专栏
04-20 976
Java AOP技术通过动态代理和字节码增强等机制，实现了横切关注点的模块化管理。Spring AOP作为最流行的AOP框架之一，提供了丰富的功能和灵活的配置方式。通过合理应用AOP，可以显著提高代码的可维护性和复用性。然而，AOP也存在一定的性能开销和调试难度，因此在实际开发中需要权衡使用。希望本文能够帮助小伙伴深入理解Java AOP技术的实现原理和应用场景。
一篇文章详细解读Spring的AOP原理过程（Spring面向切面详解）
qq_39746820的博客
04-28 8046
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
AOP原理
努力努力小张的博客
10-09 2563
一、AOP（概念） 1. 面向切面编程(方面)，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个部分之间的耦合度降低，提高程序的可重用性，同时提高了开发效率。 2. 通俗描述：不通过修改源码的方式，在主干功能里面添加新功能 二、AOP（底层原理） 1.AOP底层使用动态代理 1）有两种情况动态代理 第一种：有接口情况（JDK动态代理） 第二种：没有接口情况（cglib动态代理） ...
Spring AOP的实现原理
weixin_74268571的博客
08-18 3400
Spring AOP的底层实现原理及详细介绍以及适配器和常用通知的使用
【SpringAOP】Spring AOP 底层逻辑：切点表达式与原理简明阐述
m0_74824123的博客
02-07 661
/定义自己的注解@Target 标识了 Annotation 所修饰的对象范围, 即该注解可以在什么地.@Retention 指Annotation被保留的时间短, 标明注解的命周期spring AOP原理，是要从源码进行解读的，但是源码过于复杂，最终的情况就是如下所示：在源码中的代理有个重要的属性: proxyTargetClass, 默认值为false. 也可以通过程序设置（这里的默认值是根据不同情况来进行定义的）
Spring学习之AOP的切点表达式详解
rambo_csdn_123的博客
01-09 3132
1.背景知识 在Sping中使用AOP的主要工作是配置织入关系，使用<aop:config>标签代表这一段是织入关系的配置 首先，用<aop:aspect>标签声明一个切面，这里要引用我们之前编写好的切面类极其在配置文件中注册的id(myAspect) 然后，通过<aop:[aopMethod]>标签对各种类型的增强进行配置，前置增强用before,后置增强用after 切面=增强+切点，所以在对应的增强类型中我们还要指定具体的增强方法和切点，配置切点就需要切点表达式 &
Spring AOP切点表达式语法
weixin_44201223的博客
05-27 399
AOP切点表达式（Pointcut Expression）是一种用于指定切点的语言，它可以通过定义匹配规则，来选择需要被切入的目标对象。注意：提取切点注解使用@Pointcut(切点表达式) ， 需要添加到一个无参数无返回值方法上即可！上面案例，是我们之前编写切点表达式的方式，发现， 所有增强方法的切点表达式相同！建议：将切点表达式统一存储到一个类中进行集中管理和维护！不同类在引用切点，只需要添加类的全限定符+方法名即可！出现了冗余，如果需要切换也不方便统一维护！我们可以将切点提取，在增强上进行引用即可！
Spring AOP中定义切点的实现方法示例
08-25
其中，定义切点是 AOP 中最为关键的一步骤，本文将主要介绍 Spring AOP 中定义切点的实现方法，并结合实例形式分析了 Spring 面向切面 AOP 定义切点的具体步骤、实现方法与相关操作技巧。 首先，在 Spring AOP 中，...
Spring中的AOP原理
weixin_44117767的博客
07-10 1724
0 为什么需要AOP 现在有一个情景： 我们要把大象放进冰箱，步骤为：打开冰箱->放入大象->关闭冰箱 如果再把大象拿出来，步骤为：打开冰箱->拿出大象->关闭冰箱 代码如下： public void put() { System.out.println("打开冰箱..."); System.out.println("放入大象..."); System.out.println("关闭冰箱..."); } publi
Spring中AOP的实现原理
qq_44918331的博客
03-11 1万+
一、什么是 AOP ？ AOP（Aspect-Oriented Programming，面向方面编程），对 OOP（Object-Oriented Programming，面向对象编程） 【OOP与AOP】 概念 AOP（Aspect-Oriented Programming，面向方面编程） OOP（Object-Oriented Programming，面向对象编程） 方向 OOP 定义从上到下的关系 AOP 定义从左到右的关系 【两个部分】 核心关注点 业务处理的主要流程
Spring 之 AOP 原理详解
爱老婆爱生活~
04-13 1604
AOP 是 Spring 框架中的一个核心概念。本文将介绍 Spring AOP的底层实现原理，并通过源代码解析来详细阐述其实现过程。
Spring AOP 切点 Pointcut 表达式介绍与使用
weixin_62636680的博客
11-27 2929
this指示符就是用来匹配基于CGLIB的代理类，通俗的来讲就是，如果当前要代理的类对象没有实现某个接口的话，则使用this；如果需要对现有类增加新的方法，可以通过 @DeclareParents 注解可以实现，DeclareParents 是一种 引入 (Introduction ) 类型的模型，在属性声明上使用，主要用于为指定的业务模块添加新的接口和相应的实现。this 用来匹配的连接点所属的对象引用是某个特定类型的实例，target 用来匹配的连接点所属目标对象必须是指定类型的实例；
Spring之AOP的切点、通知、切点表达式以及知识要点
热门推荐
楠黎倾风的博客
11-25 1万+
Spring之AOP的切点、通知、切点表达式以及知识要点
AOP原理及实现
weixin_47067171的博客
04-06 1万+
1.1 AOP简介 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 1.2 AOP的思想 其思想是，不去动原来的代码，而是基于原来代码产生代理对象，通过代理
Spring的AOP流程
行而不辍，未来可期 - King
05-07 2196
一种技术的诞生，主要是思维模式的改变，有C的面向过程，到C++/java的面向对象，到面向类，面向方法编程的AOP，最后到面向服务编程的微服务。
JAVA面试题分享二百二十六：IoC & AOP详解
之乎者也·的博客
12-13 1113
IoC （Inversion of Control ）即控制反转/反转控制。它是一种思想不是一个技术实现。描述的是：Java 开发领域对象的创建以及管理的问题。例如：现有类 A 依赖于类 B传统的开发方式：往往是在类 A 中手动通过 new 关键字来 new 一个 B 的对象出来使用 IoC 思想的开发方式：不通过 new 关键字来创建对象，而是通过 IoC 容器(Spring 框架) 来帮助我们实例化对象。我们需要哪个对象，直接从 IoC 容器里面过去即可。
Python蓝桥算法
01-20
### Python蓝桥杯算法题目与解决方案 #### 2020年第11届蓝桥杯Python大学组省赛真题解析 针对2020年的第11届蓝桥杯Python大学组省赛，存在详细的真题解答资料[^1]。这些解答不仅提供了每道题目的具体描述，还附带了完整的Python实现方法以及思路分析。 #### 数据结构与算法练习 对于希望提升数据结构和算法能力的学生而言，有专门整理的一系列简单题目集合。此资源涵盖了多种经典算法的应用实例，并且每一个案例均配有原始题目链接及其对应的Python解法说明。 #### 掌握基础算法模板的重要性 为了更好地应对竞赛中的挑战，在准备过程中熟悉常用的基础算法模板是非常重要的[^2]。通过反复练习并理解前缀和等基本概念和技术手段，可以有效提高解决问题的速度和准确性。 ```python def prefix_sum(nums): n = len(nums) pre_sums = [0] * (n + 1) for i in range(1, n + 1): pre_sums[i] = pre_sums[i - 1] + nums[i - 1] return pre_sums nums_example = [1, 2, 3, 4, 5] print(prefix_sum(nums_example)) ``` 上述代码展示了如何计算数组`nums`的前缀和列表`pre_sums`。这是一类典型的预处理技术，能够加速某些区间查询操作的时间复杂度至O(1)，而构建该表本身只需要线性的扫描时间开销。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

潜意识Java

源码一定要私信我，有问题直接问

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值