发布时间：北京时间2026年4月10日

如果你正在学习Java开发，或者正面临Spring相关的技术面试，那么Spring AOP绝对是一个绕不开的高频核心知识点。ai爱家助手在日常技术调研中发现，很多开发者对AOP的认识停留在“用注解实现日志”的层面，一遇到AOP失效、代理选择不当、内部方法调用不生效等问题，就不知如何下手。本文将从痛点切入，由浅入深地带你彻底搞懂Spring AOP。

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

先来看一段传统代码。假设我们需要在每个业务方法执行前后打印日志：

public class UserServiceImpl implements UserService {
    @Override
    public void saveUser(User user) {
        System.out.println("【日志】开始保存用户...");
        // 核心业务：保存用户
        System.out.println("【日志】保存用户结束");
    }
    
    @Override
    public void deleteUser(Long id) {
        System.out.println("【日志】开始删除用户...");
        // 核心业务：删除用户
        System.out.println("【日志】删除用户结束");
    }
}

这种实现的三大痛点：

1. 代码冗余严重：每个方法都要重复编写日志代码，复用率为零

2. 耦合度极高：日志逻辑与业务逻辑强耦合，日志需求变更需要改遍所有方法

3. 扩展性极差：如果新增事务管理、权限校验等需求，代码将进一步膨胀

统计数据显示，传统OOP在日志/事务等场景下的代码重复率高达60%以上-2。

而AOP（Aspect-Oriented Programming，面向切面编程） 的核心理念，正是将这些“横切关注点”从业务逻辑中抽离出来，实现统一管理。

二、核心概念讲解：AOP的7大核心术语

AOP由AspectJ团队提出，Spring AOP借鉴了其中的核心思想。以下是必须掌握的7个核心术语：

-1

一句话理解：切面 ≈ 一个类，切点 ≈ 哪些方法要增强，通知 ≈ 增强什么动作。

Spring AOP提供了5种通知类型：

• @Before：目标方法执行前执行

• @AfterReturning：目标方法正常返回后执行

• @AfterThrowing：目标方法抛出异常后执行

• @After：目标方法执行后无论结果如何都执行（类似finally）

• @Around：最强大，可完全控制方法执行

-1

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

AspectJ是一个独立的、功能强大的AOP框架，属于编译时增强，通过专门的编译器ajc在编译阶段将切面代码织入目标类-53。

Spring AOP是Spring框架自带的AOP实现，属于运行时增强，基于动态代理机制实现-53。

二者的核心区别：

-53

一句话记住：Spring AOP ≈ 轻量级运行时AOP（够用且简单），AspectJ ≈ 重量级编译时AOP（功能全但复杂）。官方推荐：如果你只需要拦截Spring Bean的方法调用，Spring AOP就是正确选择-51。

Spring AOP已经集成了AspectJ的切点表达式语法，两者可以配合使用。

四、概念关系总结

AOP是一种编程思想（规范），解决“如何分离横切关注点”的问题。Spring AOP是一种具体实现（落地），通过动态代理在运行时实现AOP思想。

两者关系可以用一句话概括：思想指导实现，实现验证思想。

在实际开发中，Spring AOP就是我们日常使用最广泛的AOP落地方案。

五、代码示例：从传统到AOP的演进

下面通过一个完整的日志记录切面示例，直观展示AOP的改进效果。

5.1 启用AOP

@Configuration
@EnableAspectJAutoProxy  // 开启AOP支持
public class AopConfig {
}

5.2 定义切面类

@Aspect
@Component
public class LogAspect {
    
    // 定义切点：匹配com.example.service包下所有类的所有方法
    @Pointcut("execution( com.example.service..(..))")
    public void serviceMethod() {}
    
    // 前置通知
    @Before("serviceMethod()")
    public void logStart(JoinPoint joinPoint) {
        System.out.println("【@Before】方法开始执行：" + joinPoint.getSignature().getName());
    }
    
    // 环绕通知（最强大）
    @Around("serviceMethod()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("【@Around前置】开始执行：" + pjp.getSignature().getName());
        
        Object result = pjp.proceed();  // 关键：必须显式调用目标方法
        
        long end = System.currentTimeMillis();
        System.out.println("【@Around后置】执行完成，耗时：" + (end - start) + "ms");
        return result;
    }
    
    // 最终通知（类似finally）
    @After("serviceMethod()")
    public void logEnd(JoinPoint joinPoint) {
        System.out.println("【@After】方法执行结束：" + joinPoint.getSignature().getName());
    }
}

5.3 业务类

@Service
public class UserService {
    public void saveUser(String name) {
        System.out.println("=== 核心业务：保存用户【" + name + "】===");
    }
}

5.4 执行效果

调用 userService.saveUser("张三") 后控制台输出：

【@Around前置】开始执行：saveUser
【@Before】方法开始执行：saveUser
=== 核心业务：保存用户【张三】===
【@Around后置】执行完成，耗时：15ms
【@After】方法执行结束：saveUser

代码关键点说明：

• @Pointcut定义切点，通过execution表达式精确匹配目标方法

• @Around通知必须接收ProceedingJoinPoint参数，并调用proceed()方法，否则目标方法不会执行-21

• 通知执行顺序：@Around前置 → @Before → 目标方法 → @Around后置 → @After

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

Spring AOP的底层实现本质上依赖于代理模式。代理模式通过引入代理对象作为目标对象的中间层，实现对目标对象访问的控制与增强-11。

6.1 两种动态代理方式

-1-17

6.2 Spring的代理选择策略

• Spring Framework（传统） ：默认使用JDK动态代理，目标类未实现接口时才使用CGLIB

• Spring Boot：默认使用CGLIB代理（spring.aop.proxy-target-class=true）

注意：以下情况会导致AOP失效：

1. 目标对象未被Spring容器管理（自己new出来的）

2. JDK动态代理时目标类未实现接口

3. 方法为private、final或static修饰

4. 内部方法自调用（this.method()）——这是最常见的坑

-45

七、高频面试题

面试题1：什么是AOP？Spring AOP的实现原理是什么？

参考答案：
AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，通过将横切关注点（如日志、事务、安全）从业务逻辑中分离，提高代码的模块化程度和可维护性。

Spring AOP基于动态代理实现：若目标类实现了接口，使用JDK动态代理生成代理对象；否则使用CGLIB生成子类代理。运行时，调用代理对象的方法时，会先执行切面通知逻辑，再调用目标方法。

【踩分点】 ：说出AOP全称+定义 → 动态代理 → JDK vs CGLIB区别

面试题2：JDK动态代理和CGLIB的区别是什么？Spring如何选择？

参考答案：

• JDK动态代理：基于接口，要求目标类实现接口，通过Proxy和InvocationHandler实现，性能较好，但仅代理接口方法

• CGLIB：基于继承，通过字节码技术生成目标类的子类，可代理无接口的类，但无法代理final方法和类

选择策略：Spring Framework默认优先JDK动态代理；Spring Boot默认使用CGLIB。可通过@EnableAspectJAutoProxy(proxyTargetClass=true)强制使用CGLIB。

【踩分点】 ：两者适用场景 → 底层实现 → 限制条件 → 配置方式

面试题3：Spring AOP有哪些通知类型？执行顺序是怎样的？

参考答案：
五种通知类型：@Before（前置）、@AfterReturning（返回后）、@AfterThrowing（抛异常后）、@After（最终，类似finally）、@Around（环绕，最强大）。

正常执行顺序：@Around前置 → @Before → 目标方法 → @Around后置 → @After → @AfterReturning

异常执行顺序：@Around前置 → @Before → 目标方法抛异常 → @After → @AfterThrowing

【踩分点】 ：说出五种通知 → 执行顺序 → Around的特殊性

面试题4：AOP失效的常见原因有哪些？如何解决？

参考答案：

1. 目标对象未被Spring管理：确保使用@Component等注解或XML配置

2. 代理类型不匹配：JDK动态代理要求目标类实现接口，否则需改用CGLIB

3. 方法为private/final/static：这些方法无法被代理

4. 内部方法自调用（最常见）：this.method()绕过了代理对象。解决方案：

   • 注入自身代理：@Autowired private UserService self; 然后调用self.method()

   • 使用AopContext.currentProxy()：需开启@EnableAspectJAutoProxy(exposeProxy=true)

【踩分点】 ：至少说出3种失效场景 → 重点强调自调用 → 给出解决方案

八、总结

💡 易错点提醒：环绕通知中必须显式调用proceed()，否则目标方法不会执行。内部方法自调用会绕过AOP代理，这是最容易被忽视的坑。

Spring AOP是Spring框架中极为高频的面试考点，也是日常开发中优化代码结构、提升可维护性的利器。建议读者亲自动手编写切面示例，在实践中加深理解，为后续深入Spring事务原理、安全框架等内容打好基础。

📌 下一篇预告：Spring事务管理与传播行为详解，敬请期待。