Spring AOP 2026 深度指南：爆米花AI助手带你掌握面向切面编程

北京时间 2026 年 4 月 9 日

本文由「爆米花AI助手」整理，结合最新技术动态与高频面试考点，系统梳理 Spring AOP 核心知识点，帮助技术入门与进阶学习者建立完整知识链路。

你是否遇到过这样的场景：业务代码中充斥着重复的日志记录、权限校验、性能监控代码，一个需求改动就要改十几个类？或者面试时被问到“AOP 底层用的是 JDK 还是 CGLIB”，支支吾吾答不上来？这背后的核心问题，正是只会用而不知其所以然——工具用得很熟练，概念一混淆就卡壳。

本文从痛点切入，覆盖核心概念、关联对比、代码示例、底层原理到高频面试题，帮你一次性打通 Spring AOP 的完整知识链路。

一、痛点切入：为什么需要 AOP？

传统实现方式的代码冗余

假设我们有一个用户服务，需要为每个核心方法添加日志记录：

public class UserService {
    public void saveUser(User user) {
        // 日志记录——重复代码
        System.out.println("【开始】saveUser 方法执行，参数：" + user);
        // 业务逻辑
        System.out.println("保存用户..." + user);
        // 日志记录——重复代码
        System.out.println("【结束】saveUser 方法执行");
    }
    
    public void deleteUser(Long userId) {
        System.out.println("【开始】deleteUser 方法执行，参数：" + userId);
        System.out.println("删除用户..." + userId);
        System.out.println("【结束】deleteUser 方法执行");
    }
    
    // 更多方法...每个都要重复写日志代码
}

传统方式的三大痛点

传统 OOP 擅长纵向封装，但面对横跨多个模块的通用需求时显得力不从心——日志、事务、权限、缓存等功能，天然就是“横切”在业务逻辑各层的。AOP（面向切面编程）正是为解决这一问题而生的编程范式。

二、核心概念讲解：AOP 是什么？

标准定义

AOP（Aspect-Oriented Programming，面向切面编程） 是一种编程范式，其核心思想是将横切关注点（Cross-Cutting Concerns）从核心业务逻辑中分离出来，在不修改原有代码的前提下，通过动态代理在方法执行前后织入增强逻辑。-35

拆解关键词

• 横切关注点：跨越多个模块的通用功能需求，如日志、事务、权限验证等

• 织入（Weaving） ：将切面逻辑与目标对象关联的过程

• 非侵入：业务代码本身无需感知切面的存在

生活化类比

可以把 AOP 想象成安检系统：

• 你（业务逻辑）每次进入商场（执行方法），不需要自己准备安检设备

• 安检人员（切面）在入口处（方法执行前）自动完成安全检查

• 安检逻辑集中管理，所有入口共享同一套规则，修改安检标准只需改一处

核心价值

AOP 通过将通用功能模块化为切面，实现解耦 + 复用 + 可维护三大目标，让业务代码专注于核心功能，让通用功能集中管理。-51

Spring AOP 在技术体系中的地位

Spring AOP 是 Spring 框架的两大核心技术之一（另一是 IoC），在 2025–2026 年 Java 生态中，约 78% 的企业级应用使用 AOP 解决横切关注点问题。-51当前 Spring 最新版本为 6.x，AOP 模块已支持虚拟线程（Project Loom）原生集成，大幅提升了高并发场景下的切面处理能力。-65

三、关联概念讲解：核心术语全掌握

核心术语矩阵

五种通知类型

切点表达式示例

// 匹配 service 包下所有类的所有方法
@Pointcut("execution( com.example.service..(..))")

// 匹配被 @Log 注解标记的方法
@Pointcut("@annotation(com.example.annotation.Log)")

// 匹配 UserService 类中的所有方法
@Pointcut("within(com.example.service.UserService)")

// 匹配参数类型为 String 的方法
@Pointcut("args(java.lang.String)")

四、概念关系与区别总结

切面（Aspect）vs 通知（Advice）

• 切面：是一个“模块容器”，里面装了什么？装了切点 + 通知。可以理解为整个日志模块。

• 通知：是切面里的“具体动作”，告诉系统在连接点上“做什么”。可以理解为日志模块里的“记录日志”这个具体操作。

切点（Pointcut）vs 连接点（Join Point）

• 连接点：程序运行中所有可能被增强的位置，如每个方法执行都是一个连接点

• 切点：是这些连接点的筛选规则，定义“哪些连接点需要被增强”

一句话记忆：切面是模块，通知是动作，切点是规则，连接点是候选位。

五、代码示例：用 AOP 实现日志记录

完整示例：日志切面

步骤一：添加依赖（Spring Boot 3.x）

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

步骤二：定义切面类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.;
import org.springframework.stereotype.Component;
import java.util.Arrays;

@Aspect          // ① 标记为切面类
@Component       // ② 必须交给 Spring 容器管理
public class LoggingAspect {

    // ③ 定义切点：匹配 service 包下所有类的所有方法
    @Pointcut("execution( com.example.service..(..))")
    public void serviceMethods() {}

    // ④ 前置通知：方法执行前记录日志
    @Before("serviceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("【前置】执行方法：" + joinPoint.getSignature().getName()
                + "，参数：" + Arrays.toString(joinPoint.getArgs()));
    }

    // ⑤ 环绕通知：计算执行时间（最强大）
    @Around("serviceMethods()")
    public Object measureTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.nanoTime();
        try {
            Object result = joinPoint.proceed();  // 关键：手动执行目标方法
            long duration = System.nanoTime() - start;
            System.out.println("【耗时】" + joinPoint.getSignature().getName()
                    + " 执行时间：" + duration / 1_000_000 + "ms");
            return result;
        } catch (Exception e) {
            System.out.println("【异常】" + joinPoint.getSignature().getName() 
                    + " 发生异常：" + e.getMessage());
            throw e;
        }
    }

    // ⑥ 后置通知：方法执行后（无论正常/异常）
    @After("serviceMethods()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("【后置】方法执行结束：" + joinPoint.getSignature().getName());
    }

    // ⑦ 返回通知：方法正常返回后
    @AfterReturning(pointcut = "serviceMethods()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("【返回】方法返回值：" + result);
    }
}

步骤三：开启 AOP（Spring Boot 3.x 自动配置，无需显式配置）

如需强制使用 CGLIB 代理：

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)  // 强制 CGLIB
public class AopConfig {}

执行流程示意

客户端调用 → 代理对象 → 前置通知(@Before) → 环绕通知(@Around前段)
                              ↓
                        目标方法执行
                              ↓
                    返回通知(@AfterReturning) / 异常通知(@AfterThrowing)
                              ↓
                        后置通知(@After)
                              ↓
                    环绕通知(@Around后段) → 返回结果

六、底层原理：Spring AOP 如何工作？

核心原理一句话总结

Spring AOP 的实质是：在 IoC 容器创建 Bean 的过程中，根据开发者定义的切面规则，为目标 Bean 生成一个 代理对象（替身），并将所有横切逻辑（通知）编织成一条有序的拦截器链，在代理对象执行目标方法时被逐一唤醒。-2

关键组件与执行流程

入口：AnnotationAwareAspectJAutoProxyCreator

这是一个实现了 BeanPostProcessor 的自动代理创建器，它在 Bean 的初始化阶段介入：postProcessBeforeInitialization → 目标 Bean 初始化 → postProcessAfterInitialization → 生成并返回代理 Bean。-1

核心流程：

1. Bean 完成初始化后，postProcessAfterInitialization 被调用

2. 解析 @Aspect 切面类，通过切点表达式判断当前 Bean 是否匹配

3. 若匹配，调用 createProxy 创建代理对象

4. 通过 ProxyFactory 根据目标类是否有接口，选择 JDK 或 CGLIB

5. 将通知转换为 MethodInterceptor 拦截器链，存入代理对象

6. 返回代理对象替代原始 Bean 注入容器

底层依赖知识点

JDK vs CGLIB 详细对比

Spring 的默认策略逻辑为：若目标类实现了接口 → 使用 JDK 动态代理；否则使用 CGLIB。Spring Boot 3.2+ 默认启用 CGLIB，可通过 spring.aop.proxy-target-class=false 切换回 JDK 代理。

七、高频面试题与参考答案

Q1：什么是 AOP？它的核心思想是什么？

标准答案： AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，核心思想是 “将与核心业务无关、但多个模块共有的逻辑（如日志、事务、权限）抽取为‘切面’” ，在不修改原有业务代码的前提下，通过动态代理的方式将增强逻辑织入到核心业务方法中，实现代码解耦。-35

💡 踩分点：定义（编程范式）+ 核心思想（横切关注点分离）+ 实现手段（动态代理）+ 目标（解耦）

Q2：Spring AOP 动态代理的实现方式有哪两种？区别是什么？

标准答案： 两种代理方式：JDK 动态代理和CGLIB 代理。

• JDK 动态代理：基于接口，要求目标对象实现至少一个接口，通过 Proxy 和 InvocationHandler 在运行时生成实现接口的代理类

• CGLIB 代理：基于继承，通过 ASM 字节码技术生成目标类的子类作为代理，重写父类方法并织入切面逻辑

主要区别：JDK 只能代理有接口的类，CGLIB 无此限制，但不能代理 final 类和方法。Spring 默认策略：有接口时用 JDK，无接口时用 CGLIB。-35

💡 踩分点：两种方式名称 + 各自原理 + 适用条件 + 限制

Q3：环绕通知（@Around）和其他通知（如 @Before）的核心区别是什么？

标准答案： 核心区别是 是否能控制目标方法的执行。

• 普通通知（Before/After/AfterReturning/AfterThrowing）：仅能在目标方法执行前后“附加逻辑”，无法阻止方法执行，也无法修改参数和返回值

• 环绕通知：通过 ProceedingJoinPoint 的 proceed() 方法手动触发目标方法，可实现：① 控制方法是否执行（不调用 proceed() 则不执行）；② 修改方法参数（通过 proceed(Object[] args) 传入新参数）；③ 修改返回值；④ 异常捕获与处理

Q4：Spring AOP 与 AspectJ 的关系是什么？

标准答案： Spring AOP 和 AspectJ 都是 AOP 的实现框架，但定位不同：

Spring AOP 借鉴了 AspectJ 的注解风格（如 @Aspect、@Pointcut），但底层实现完全不同。Spring AOP 适合轻量级场景，AspectJ 适合更复杂的切面需求。-11

Q5：为什么 @Before 里修改参数，目标方法收不到？

标准答案： 因为 Spring AOP 的通知方法接收到的 JoinPoint 或 ProceedingJoinPoint 中的参数是原始引用的副本，@Before 无法拦截并替换实际传入目标方法的参数。

只有 @Around 能通过 proceed(Object[] args) 显式传入新参数数组来实现参数修改。如果参数是可变对象（如 Map、DTO），在 @Before 里修改其内部字段是生效的，但这属于对象内部状态变更，不是“替换参数引用”。-4

八、结尾总结

核心知识点回顾

重点提醒

• ⚠️ @Aspect 类必须由 Spring 容器管理（加 @Component 或 @Bean），否则切面不生效

• ⚠️ 切面内部调用不生效：AOP 基于代理，同一个类内部方法调用走的是 this 而非代理对象，切面逻辑不会触发

• ⚠️ CGLIB 不能代理 final 类和方法，JDK 代理必须有接口

进阶预告

本文聚焦 Spring AOP 的核心概念与运行时原理。下一篇将深入 Spring AOP 源码级解析——从 AnnotationAwareAspectJAutoProxyCreator 到 ReflectiveMethodInvocation 拦截器链的完整调用链路，以及 Spring 6.x 在虚拟线程和 AOT 编译方向的最新演进，敬请期待。