Spring AOP（Aspect Oriented Programming，面向切面编程）与IoC并称为Spring框架的两大核心支柱。根据365ai助手整理的2026年最新技术资料，Spring AOP通过动态代理机制，实现了在不修改原始业务代码的前提下，将日志、事务、权限校验等横切关注点与核心业务逻辑解耦-10。很多开发者在实际工作中能够熟练使用@Aspect注解，但对底层原理一知半解，遇到代理失效问题往往束手无策，面试时更是一问就卡壳。本文将从“问题→概念→原理→实战→面试”五个层面，带你彻底搞懂Spring AOP。

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

先来看一个典型的开发场景。假设你需要在每个Service方法执行前后添加日志记录，传统的写法是这样的：

// ❌ 传统实现：每个方法都要写重复的日志代码

@Service
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("[日志] 开始执行 addUser，参数：" + name);  // 重复代码
        System.out.println("添加用户：" + name);  // 核心业务
        System.out.println("[日志] addUser 执行完成");  // 重复代码
    }
    
    @Override
    public void deleteUser(Long id) {
        System.out.println("[日志] 开始执行 deleteUser，参数：" + id);  // 重复代码
        System.out.println("删除用户：" + id);  // 核心业务
        System.out.println("[日志] deleteUser 执行完成");  // 重复代码
    }
}

这种方式存在明显弊端：

• 代码冗余严重：日志、权限校验等非业务代码散落在每个方法中，重复编写

• 耦合度高：横切逻辑与业务逻辑混在一起，修改日志格式需要改几十个文件

• 扩展性差：新增功能（如性能监控）需要在所有方法中逐一手动添加

• 维护成本高：分散在各处的重复代码难以统一管理和修改

AOP正是为解决这些问题而生——通过横向抽取共性功能，让业务代码只关心核心逻辑，其他通用功能统一在切面中处理-10。

二、AOP vs OOP：核心概念讲解

什么是AOP？

AOP全称 Aspect Oriented Programming（面向切面编程），是一种编程范式。如果说OOP（面向对象编程）通过“纵向”的继承和封装来组织代码，那么AOP则是从“横向”角度，将影响多个类的公共行为抽取出来，封装成独立的模块（即切面）-10。

一句话概括：OOP解决的是“是什么”的问题（对象与对象之间的关系），AOP解决的是“做什么”的问题（哪些方法需要统一增强）。

AOP与OOP并非替代关系，而是互为补充。OOP适合定义业务实体的结构和行为，AOP适合处理跨多个业务模块的通用功能，二者结合才能构建出高内聚、低耦合的系统-。

什么是OOP？

OOP全称 Object Oriented Programming（面向对象编程），以“对象”为基本单位，通过封装、继承、多态三大特性组织代码。它的优势在于将数据和操作数据的逻辑绑定在一起，适合模拟现实世界的实体关系。但当遇到日志记录、事务管理这类与具体对象无关的“横向”需求时，OOP的处理方式就显得力不从心-。

概念关系总结

记忆口诀：OOP管“纵向继承”，AOP管“横向增强”，二者搭配，干活不累。

三、Spring AOP核心术语详解

Spring AOP涉及七个核心概念，以下是完整梳理-3：

通知（Advice）的五种类型

通知定义了“何时”执行增强逻辑，Spring支持五种类型-10：

⚠️ 注意：@Around通知功能最强，可以控制目标方法是否执行、修改参数和返回值，但使用时要记得调用proceed()方法，且只能调用一次-6。

四、底层原理：动态代理机制

JDK动态代理 vs CGLIB动态代理

Spring AOP的底层实现依赖于动态代理技术。它通过创建目标对象的代理对象，在方法调用前后插入增强逻辑。Spring支持两种动态代理方式-1：

Spring的选择策略：默认情况下，若目标类实现了接口→使用JDK动态代理；若目标类无接口→自动切换为CGLIB-1。如需强制使用CGLIB，可在配置类上添加@EnableAspectJAutoProxy(proxyTargetClass = true)。

代理创建的核心流程

Spring AOP的代理创建并非在容器启动时就全部完成，而是在Bean初始化之后，通过BeanPostProcessor的后置处理方法动态创建并替换原始Bean-1。

核心流程如下：

1. 目标Bean完成实例化和属性注入

2. postProcessAfterInitialization方法被触发

3. 查找匹配当前Bean的所有增强器（Advisor）

4. 若存在匹配的增强器，则创建代理对象

5. 将容器中的原始Bean替换为代理对象

这意味着：Bean在初始化阶段还是真实对象，但最终注入到容器中的是代理对象——这个细节对于理解AOP失效场景至关重要。

技术支撑

Spring AOP的底层依赖于以下核心技术：

• 代理模式：经典设计模式，通过代理对象控制对目标对象的访问

• 反射机制：JDK动态代理运行时通过反射调用目标方法

• 字节码操作：CGLIB使用ASM框架动态生成子类字节码

这些底层能力共同支撑了AOP在运行时的动态织入功能。

五、代码示例：3步实现方法耗时统计

下面通过一个完整的实战案例，快速上手Spring AOP。

第1步：引入依赖

在pom.xml中添加Spring Boot AOP Starter依赖：

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

Spring Boot会自动完成AOP的自动装配，无需额外配置。

第2步：定义目标业务类

@Service
public class OrderService {
    public void createOrder(String productName) {
        System.out.println("创建订单：" + productName);
        // 模拟业务耗时
        try { Thread.sleep(100); } catch (InterruptedException e) {}
    }
    
    public void updateOrder(Long orderId) {
        System.out.println("更新订单：" + orderId);
    }
}

第3步：编写切面类

@Aspect  // ① 标记为切面类
@Component  // ② 交给Spring容器管理
@Slf4j
public class TimeAspect {
    
    // ③ 定义切入点：匹配com.example.service包下所有类的所有方法
    @Pointcut("execution( com.example.service..(..))")
    public void serviceMethods() {}
    
    // ④ 环绕通知：统计方法执行耗时
    @Around("serviceMethods()")
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        String className = pjp.getTarget().getClass().getSimpleName();
        String methodName = pjp.getSignature().getName();
        long startTime = System.currentTimeMillis();
        
        log.info("【{}】方法【{}】开始执行", className, methodName);
        
        Object result = pjp.proceed();  // ⑤ 调用目标方法
        
        long endTime = System.currentTimeMillis();
        log.info("【{}】方法【{}】执行完成，耗时：{}ms", className, methodName, endTime - startTime);
        return result;
    }
}

执行效果：当调用orderService.createOrder("笔记本电脑")时，控制台会输出：

【OrderService】方法【createOrder】开始执行
创建订单：笔记本电脑
【OrderService】方法【createOrder】执行完成，耗时：103ms

六、AOP失效场景与避坑指南

常见失效场景

为什么内部自调用会失效？

@Service
public class OrderService {
    
    @Transactional  // 期望被AOP拦截
    public void methodA() {
        this.methodB();  // ❌ 这里走的是this引用，不是代理对象
    }
    
    @Transactional
    public void methodB() {
        // 业务逻辑
    }
}

当methodA内部调用methodB时，调用的是原始对象的methodB，而非代理对象的methodB，因此AOP逻辑不会生效。解决方案是通过代理对象调用：

@Autowired
private OrderService self;  // 注入自身的代理对象

public void methodA() {
    self.methodB();  // ✅ 通过代理对象调用，AOP生效
}

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

Q1：Spring AOP的实现原理是什么？

参考答案：Spring AOP基于动态代理技术实现。运行时为目标Bean创建代理对象，在方法调用前后插入横切逻辑。具体有两种实现方式：若目标类实现了接口，默认使用JDK动态代理（通过Proxy和InvocationHandler）；若目标类无接口，则使用CGLIB通过继承生成子类代理。代理对象的创建发生在Bean初始化之后，通过BeanPostProcessor的后置处理方法完成-1-68。

踩分点：提到动态代理、区分JDK和CGLIB、说明代理创建时机。

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

参考答案：JDK动态代理基于接口，要求目标类必须实现至少一个接口，通过反射调用目标方法，生成代理速度快但方法调用稍慢；CGLIB基于继承，通过ASM字节码技术生成目标类的子类，无需接口支持，方法调用更快但不能代理final类和方法。Spring默认策略：有接口用JDK，无接口用CGLIB-56-61。

踩分点：接口 vs 继承、反射 vs 字节码、各自的限制。

Q3：什么是AOP？AOP解决了什么问题？

参考答案：AOP（Aspect Oriented Programming，面向切面编程）是一种编程范式，通过横向抽取日志、事务、权限等通用功能形成独立的“切面”，在运行时动态织入到目标方法中。它解决了传统OOP中横切逻辑代码分散、重复、耦合度高的问题，实现了核心业务与通用功能的解耦，提高了代码复用性和可维护性-10。

踩分点：定义、解决的问题、与OOP的关系。

Q4：为什么@Transactional注解有时候不生效？

参考答案：常见原因有四种：①内部自调用：同一个类内通过this调用被@Transactional标记的方法，绕过了代理对象；②非public方法：Spring AOP默认只拦截public方法；③异常类型不匹配：默认只回滚RuntimeException，若抛出的异常不是RuntimeException类型，事务不回滚；④数据库引擎不支持事务（如MyISAM）。解决方案：避免内部自调用、确保方法为public、指定rollbackFor参数-13。

踩分点：自调用、public限制、异常类型、数据源配置。

Q5：Spring AOP和AspectJ有什么区别？

参考答案：Spring AOP是基于动态代理的运行时AOP实现，仅支持方法级别的拦截，性能开销小，与Spring IoC无缝集成；AspectJ是编译时或类加载时织入的AOP框架，功能更强大，支持字段拦截、构造器拦截等，但使用更复杂。Spring AOP借用了AspectJ的注解语法（如@Aspect、@Pointcut），底层仍然是动态代理实现，并非AspectJ本身-。

踩分点：运行时 vs 编译时/类加载时、代理 vs 字节码织入、方法级 vs 更细粒度。

八、结尾总结

本文围绕Spring AOP，从痛点分析出发，系统讲解了：

💡 重点提醒：AOP失效的最常见原因是内部方法自调用和非public方法，排查时优先检查这两点。

下一篇预告：深入Spring AOP源码，剖析AnnotationAwareAspectJAutoProxyCreator的代理创建全过程，并详细解读拦截链（MethodInterceptor）的执行模型。欢迎持续关注！