【VIV AI助手整理】Spring AOP 2026：从原理到面试的全链路指南

AOP（Aspect-Oriented Programming，面向切面编程）是 Spring 框架的两大核心技术之一，与 IoC 共同构成了 Spring 的基石。在企业级开发中，AOP 长期稳居面试高频考点前列，但很多开发者存在“只会用注解却说不清原理”的困境——日志切面配得顺手，面试问到动态代理与 CGLIB 的区别时却支支吾吾。本文由 VIV AI助手 整理最新资料，将从痛点切入，系统拆解 Spring AOP 的核心概念、实现机制与面试要点，兼顾原理深度与实践落地，力求让你真正“看明白、记得住、讲得出”。

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

先来看一段典型的“反面教材”——没有 AOP 时的业务代码：

@Service

public class UserServiceImpl implements UserService {
    
    @Override
    public User getUserById(Long id) {
        // 日志记录——重复代码
        System.out.println("【日志】调用 getUserById，参数：" + id);
        long start = System.currentTimeMillis();
        
        // 业务逻辑
        User user = userDao.findById(id);
        
        // 性能监控——重复代码
        long cost = System.currentTimeMillis() - start;
        System.out.println("【性能】耗时：" + cost + "ms");
        
        return user;
    }
    
    @Override
    public void updateUser(User user) {
        // 日志记录——又写一遍
        System.out.println("【日志】调用 updateUser，参数：" + user);
        // 性能监控——又写一遍
        // 事务管理——又写一遍
        // 权限校验——又写一遍
        // 业务逻辑...
    }
}

这段代码暴露了传统 OOP（Object-Oriented Programming，面向对象编程）在处理横切关注点时的典型困境：

AOP 正是为解决这些问题而生的编程范式——它允许在不修改源代码的情况下，为程序动态添加扩展功能，方便维护程序、提高模块内聚性并降低模块间的耦合-。它通过预编译方式或运行期动态代理实现程序功能的统一维护-。

二、核心概念讲解

AOP 包含五个核心概念，用一个“餐厅点餐”的类比可以帮助快速理解：

一句话记忆：切点选位置，通知定动作，切面打包二者，织入执行整合。

Spring AOP 支持五种通知类型，直接对比更清晰：

其中 @Around 功能最为强大，通过 ProceedingJoinPoint 可完全控制方法执行链路。

三、关联概念讲解：Spring AOP vs AspectJ

在实际开发中，Spring AOP 和 AspectJ 经常被一同提及，但二者的定位存在本质差异：

关系速记：AspectJ 是 AOP 的“完整版”，Spring AOP 是“简化版”——两者通过 @AspectJ 注解风格实现了语法统一，但底层机制截然不同。

四、概念关系与区别总结

理清以下三层关系，AOP 的知识体系就建立起来了：

1. AOP（思想） → Spring AOP（框架实现） ：AOP 是一种编程范式，Spring AOP 是 Spring 框架对这种范式的具体实现。

2. Spring AOP（框架） → AspectJ（语法） ：Spring AOP 借用了 AspectJ 的 @Aspect 注解风格作为声明方式，但底层仍是动态代理-。

3. AspectJ 语法（声明方式） → AspectJ 框架（完整实现） ：使用 @Aspect 注解不等于使用 AspectJ 框架——Spring 中的 @Aspect 只是“语法糖”。

一句话总结：AOP 是思想，Spring AOP 是轻量级实现，AspectJ 是重量级完整方案，三者共享 @AspectJ 风格的注解语法。

五、代码示例：从零实现一个性能监控切面

5.1 添加依赖

<!-- Maven 依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

Spring Boot 已为 AOP 提供了自动配置支持，添加依赖后即可直接使用-59。

5.2 创建自定义注解（可选但推荐）

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Monitor {
}

通过自定义注解标记需要监控的方法，比 execution 表达式更灵活、更可维护。

5.3 编写切面类

@Aspect                    // 声明为切面类
@Component                 // 交由 Spring 容器管理
public class PerformanceAspect {
    
    // 定义切点：匹配被 @Monitor 注解标记的方法
    @Pointcut("@annotation(com.example.Monitor)")
    public void monitorPointcut() {}
    
    // 环绕通知：统计方法执行耗时
    @Around("monitorPointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        
        // 前置增强：记录开始时间
        long start = System.currentTimeMillis();
        System.out.println("【监控】" + methodName + " 开始执行，参数：" + Arrays.toString(args));
        
        try {
            // 执行目标方法（关键步骤）
            Object result = joinPoint.proceed();
            
            // 后置增强：计算耗时
            long cost = System.currentTimeMillis() - start;
            System.out.println("【监控】" + methodName + " 执行完成，耗时：" + cost + "ms，返回值：" + result);
            return result;
        } catch (Exception e) {
            // 异常增强：记录异常信息
            long cost = System.currentTimeMillis() - start;
            System.out.println("【监控】" + methodName + " 执行异常，耗时：" + cost + "ms，异常：" + e.getMessage());
            throw e;
        }
    }
}

5.4 使用切面

@Service
public class UserService {
    
    @Monitor   // 只需添加一个注解，横切逻辑自动生效
    public User getUserById(Long id) {
        // 纯粹的业务逻辑
        return userDao.findById(id);
    }
}

执行流程说明：Spring 容器在初始化 UserService 时，检测到 @Monitor 注解的存在，自动生成一个代理对象。当外部调用 getUserById 方法时，实际调用的是代理对象，代理对象先执行 @Around 通知的前半部分，然后通过 joinPoint.proceed() 调用原始业务方法，最后执行后半部分通知并返回结果。

六、底层原理：Spring AOP 的代理机制

Spring AOP 的底层实现本质上是代理模式的应用——通过引入代理对象作为目标对象的中间层，实现对目标对象访问的控制与增强，其核心价值在于解耦核心业务逻辑与横切关注点-40。

Spring 根据目标对象的特征自动选择代理方式-45：

⚠️ 重要区别：Spring MVC 中的 AOP 底层实现默认是 JDK 动态代理；而 Spring Boot 中的 AOP 底层实现默认是 CGLIB-。在 Spring Boot 3.2+ 中，默认启用了 CGLIB 代理，支持更细粒度的代理配置-13。

底层依赖的技术支撑：Spring AOP 的代理机制依赖两个基础能力——Java 反射机制（JDK 代理的核心）和 CGLIB 字节码操作库（CGLIB 代理的核心）。理解这两者，后续深入学习源码时就有了明确的方向。

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

Q1：什么是 AOP？为什么要用它？

标准答案：AOP（面向切面编程）是在不修改业务代码的情况下，为方法统一添加横切逻辑（如日志、事务、权限）的编程范式，通过动态代理在方法执行前后织入增强-52。它解决了 OOP 在处理横切关注点时的代码冗余、耦合度高、维护困难等问题，是 Spring 框架的核心特性之一。

Q2：Spring AOP 底层是如何实现的？

标准答案：Spring AOP 基于动态代理机制实现：目标类有接口时使用 JDK 动态代理，无接口时使用 CGLIB 生成子类代理-52。Spring 容器最终注入的是代理对象而非原始对象。在 Spring Boot 3.2+ 中，默认使用 CGLIB 代理。

Q3：JDK 动态代理和 CGLIB 有什么区别？

标准答案：JDK 动态代理基于接口实现，要求目标类至少有一个接口，通过 java.lang.reflect.Proxy 和 InvocationHandler 完成；CGLIB 基于继承实现，通过生成目标类的子类来代理，不需要接口，但 final 类和 final 方法无法被代理。Spring Boot 默认使用 CGLIB-52。

Q4：为什么 @Transactional 注解有时会失效？

标准答案：最常见的原因是同一个类中的内部调用——当方法 A 直接调用同类中的方法 B 时，调用没有经过代理对象，AOP 切面不会生效-52。其他原因包括：方法不是 public 的、方法是 final 的、目标类没有被 Spring 容器管理。

Q5：@Around 和 @Before / @After 有什么区别？

标准答案：@Before / @After 只在方法执行前后包裹逻辑，不控制方法的执行；@Around 通过 ProceedingJoinPoint 可完全控制方法执行流程，包括决定是否执行目标方法、获取修改返回值、处理异常等，是最强大的通知类型-52。

Q6：Spring AOP 和 AspectJ 的主要区别？

标准答案：Spring AOP 基于运行时动态代理，仅支持方法级别的拦截，配置简单、与 Spring 生态集成度高；AspectJ 基于编译时/类加载时织入，支持字段、构造器等更细粒度的连接点，功能更强大但配置复杂-52。两者可互补使用：Spring AOP 处理业务切面，AspectJ 处理基础设施切面。

八、结尾总结

回顾全文，我们建立了 AOP 的完整知识链路：

🔥 面试黄金三连：是什么 → 怎么实现 → 有什么限制。回答 AOP 问题时按这个逻辑组织，既体现理解深度，又展现思维条理。

易错点提醒：

• ⚠️ 同一个类内部的方法调用不会触发 AOP（没有经过代理对象）

• ⚠️ private 和 final 方法无法被 AOP 代理

• ⚠️ Spring AOP 默认只拦截 Spring 容器管理的 Bean 的方法调用

进阶预告：下一篇将深入 @EnableAspectJAutoProxy 的源码，拆解 Spring 如何自动识别 @Aspect 切面并创建代理对象，敬请期待！