2026年4月10日 Java面试必考：Spring AOP原理，一篇讲透

北京时间 2026年4月10日

在Spring框架的技术体系中，AOP（Aspect Oriented Programming，面向切面编程）与IoC并称为两大核心支柱。对于Java开发者而言，掌握Spring AOP不仅是日常开发的必备技能，更是面试中的高频考点。很多学习者长期停留在“会用注解”的阶段——写个@Around、配个切点表达式就以为学会了，一旦被问到“动态代理是怎么创建的”“JDK和CGLIB有什么区别”“同类方法调用为什么切面不生效”，就答不出来了。这正是Spring AOP面试的“失分重灾区”。本文将从痛点出发，由浅入深讲透Spring AOP的核心概念、底层原理与高频面试考点，并提供完整的代码示例，帮助读者建立从概念到实战的完整知识链路。

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

先来看一段“痛点代码”。假设你有一个订单服务，里面包含下单、支付、查询等多个业务方法。现在，你需要为每个方法添加日志打印和性能监控功能。

// 没有使用AOP的代码——每个方法都要重复写日志和计时逻辑
public class OrderService {
    public void placeOrder(Order order) {
        long start = System.currentTimeMillis();
        System.out.println("[日志] 开始下单: " + order);
        try {
            // 核心下单逻辑...
            System.out.println("执行下单核心逻辑");
        } finally {
            System.out.println("[日志] 下单完成");
            System.out.println("[性能] 下单耗时: " + (System.currentTimeMillis() - start) + "ms");
        }
    }

    public void payOrder(Long orderId) {
        long start = System.currentTimeMillis();
        System.out.println("[日志] 开始支付: " + orderId);
        try {
            // 核心支付逻辑...
            System.out.println("执行支付核心逻辑");
        } finally {
            System.out.println("[日志] 支付完成");
            System.out.println("[性能] 支付耗时: " + (System.currentTimeMillis() - start) + "ms");
        }
    }
    // 其他方法也要重复同样的代码...
}

这种实现方式存在四个明显的问题：

1. 代码重复严重：每个业务方法中，日志、计时的样板代码大量重复，增加了代码量。

2. 耦合度高：业务逻辑与横切关注点（日志、性能监控）耦合在一起，一旦日志格式需要修改，就要改动所有方法。

3. 维护困难：随着方法数量的增加，维护成本呈线性增长。

4. 关注点混杂：一个方法中混杂了核心业务逻辑和非业务逻辑，降低了代码的可读性。

AOP正是为了解决这个问题而生——它将这些散落在各处的“横切关注点”抽取出来，集中定义为“切面”，然后由Spring在运行时自动织入到目标方法的前后或异常时刻，从而实现对原有业务代码的零侵入增强-1。

二、核心概念讲解：AOP的术语体系

什么是AOP？

AOP，全称 Aspect Oriented Programming（面向切面编程），是一种编程范式，旨在通过将横切关注点（cross-cutting concerns）从业务逻辑中分离出来，提高代码的模块化程度。简单来说，就是在不修改原有业务代码的前提下，对方法进行增强，统一处理日志、事务、权限、监控等横切逻辑-。

💡 一句话理解：AOP就像电影里的“特效后期”——你不用让演员边演戏边飞天遁地，拍完之后统一做后期特效，就能在所有需要的场景加上炫酷效果。AOP也是这个道理：业务代码只管“演好戏”，日志、事务等“特效”由切面在运行时统一添加。

AOP核心术语详解

理解AOP，先要搞懂以下六个核心术语-40-1：

五类通知详解

通知（Advice）定义了增强逻辑的执行时机，Spring AOP支持五种通知类型-40：

💡 重点理解：@Around环绕通知是功能最强的通知类型，它可以完全控制目标方法的执行——包括是否执行、何时执行、是否修改返回值。使用@Around时，必须手动调用ProceedingJoinPoint.proceed()来执行原始方法-1。

三、Spring AOP与AspectJ：是什么关系？

Spring AOP vs AspectJ

很多初学者会混淆Spring AOP和AspectJ的关系，其实两者完全不同--：

一句话理清关系

Spring AOP借用了AspectJ的注解和切入点表达式语法（@Aspect、@Pointcut等），但底层实现完全不同——Spring AOP用自己的动态代理，AspectJ用自己的编译器-。

💡 记忆口诀：Spring AOP≈“借壳上市”——借AspectJ的壳（注解和语法），跑自己动态代理的核。

四、代码示例：从零实现一个日志切面

4.1 环境配置

在Spring Boot项目中，AOP依赖需要手动引入。在pom.xml中添加以下依赖：

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

Spring Boot默认已经通过@EnableAspectJAutoProxy自动启用了AOP支持，通常无需额外配置-。

4.2 定义切面类

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.;
import org.springframework.stereotype.Component;

@Component           // 将切面类交给Spring容器管理
@Aspect              // 标记这是一个切面类
public class LoggingAspect {

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

    // 2. 前置通知：方法执行前打印日志
    @Before("serviceMethods()")
    public void logBefore() {
        System.out.println("[前置] 方法即将执行");
    }

    // 3. 环绕通知：统计方法执行耗时
    @Around("serviceMethods()")
    public Object measureTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("[环绕前] 开始执行: " + joinPoint.getSignature().getName());
        
        Object result = joinPoint.proceed();  // ⚠️ 必须调用，否则原方法不会执行
        
        long elapsed = System.currentTimeMillis() - start;
        System.out.println("[环绕后] 执行耗时: " + elapsed + "ms");
        return result;
    }

    // 4. 异常通知：方法抛出异常时执行
    @AfterThrowing(pointcut = "serviceMethods()", throwing = "ex")
    public void logException(Exception ex) {
        System.out.println("[异常] 方法执行出错: " + ex.getMessage());
    }
}

4.3 执行流程图解

调用方 → 代理对象 → @Around环绕前 → @Before前置通知 → 目标方法执行 → @After后置通知 
       → @AfterReturning返回通知 → @Around环绕后 → 返回结果
                          ↘ 抛出异常 → @AfterThrowing异常通知 → 抛出异常

关键点：@Around环绕通知必须主动调用proceed()才会触发目标方法的执行，而其他通知类型无需关注此细节-1。

五、底层原理：Spring AOP是如何实现的？

5.1 核心原理：动态代理

Spring AOP的底层本质是 代理模式 + 动态代理技术——在运行时为目标对象创建一个代理对象，将对目标方法的调用转发给代理，由代理在调用前后织入增强逻辑-31。

Spring AOP提供了两种动态代理实现方式--11：

5.2 Spring的选择策略

Spring AOP默认的代理选择策略是--11：

• 如果目标类实现了接口 → 使用 JDK动态代理

• 如果目标类没有实现接口 → 使用 CGLIB动态代理

在Spring Boot中，可通过配置强制使用CGLIB代理-23：

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AopConfig {}

5.3 JDK vs CGLIB：一张表彻底分清

⚠️ 面试考点：两种代理都无法代理private方法和final方法。因为JDK代理通过接口暴露方法，private不在接口中；CGLIB通过继承生成子类，final方法无法被覆写-。

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

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

标准答案：

AOP（Aspect Oriented Programming，面向切面编程）是一种编程范式，通过将横切关注点（如日志、事务）从业务逻辑中分离出来，实现对方法的无侵入增强。Spring AOP的核心实现原理是动态代理——在运行时为目标对象创建代理对象，在代理中织入增强逻辑-41。

踩分点：①给出AOP全称和定义；②提到“不修改源码”“无侵入增强”；③点明“动态代理”是核心实现机制。

面试题2：JDK动态代理和CGLIB有什么区别？

标准答案：

两者的核心区别有三点：

1. 实现机制不同：JDK基于反射生成实现接口的代理类；CGLIB基于ASM字节码生成目标类的子类。

2. 使用条件不同：JDK要求目标类必须实现接口；CGLIB无需接口，但无法代理final类和方法。

3. 性能特点不同：JDK代理类生成成本低、调用成本适中；CGLIB代理类生成成本高、调用速度快-11。

Spring AOP默认优先使用JDK动态代理，目标类无接口时自动切换为CGLIB。

踩分点：①从“接口代理 vs 子类代理”角度切入；②分别说明两种方式的原理；③提到Spring的默认选择策略。

面试题3：同类方法内部调用，为什么AOP切面不生效？

标准答案：

这是因为Spring AOP基于代理实现。当调用this.method()时，this指向的是原始目标对象而非代理对象，绕过了代理，因此切面不会执行。解决方式有三种：①将方法拆分到不同类中；②通过AopContext.currentProxy()获取代理对象来调用；③使用AspectJ的编译时织入-。

踩分点：①指出“this指向原始对象而非代理”；②给出至少两种解决方案。

面试题4：Spring AOP的通知类型有哪些？@Around和其他通知有什么区别？

标准答案：

Spring AOP支持五种通知：@Before（前置）、@After（后置）、@AfterReturning（返回）、@AfterThrowing（异常）、@Around（环绕）。区别在于：前四种通知仅规定了增强逻辑在目标方法执行前后执行的时机，而@Around环绕通知可以完全控制目标方法的执行——包括是否执行、何时执行、是否修改返回值。@Around必须手动调用proceed()才能让目标方法执行-40-1。

踩分点：①列出五种通知；②重点说明@Around的“完全控制”特性；③提到proceed()方法。

面试题5：Spring AOP和AspectJ有什么关系？

标准答案：

两者是不同层面的关系。AspectJ是一个功能更完整的独立AOP框架，支持编译时和类加载时织入，连接点更丰富；Spring AOP是Spring框架自带的AOP实现，底层基于动态代理，仅支持运行时织入和方法级别的连接点。Spring AOP借用了AspectJ的注解和切入点表达式语法（如@Aspect、@Pointcut），但底层实现机制完全不同——Spring AOP用的是自己的动态代理，不是AspectJ的编译器--。

踩分点：①明确两者是不同的实现；②对比增强时机（运行时 vs 编译时）；③指出语法借用关系。

七、结尾总结

本文围绕Spring AOP的核心知识体系，从痛点场景切入，梳理了以下重点内容：

⚠️ 易错点提醒：

1. @Around环绕通知中必须调用proceed()，否则目标方法不会执行。

2. 同类内部方法调用切面不生效——因为调用的是原始对象而非代理对象。

3. Spring AOP默认只对public方法生效，非public方法无法被代理拦截。

4. 区分Spring AOP（运行时动态代理）和AspectJ（编译时字节码织入）的本质差异。

掌握Spring AOP，核心在于理解 “动态代理” 这个底层基石。后续文章将继续深入AOP的源码剖析与实战优化，敬请期待。

📌 版权声明：本文遵循CC BY-SA 4.0协议，转载需附原文出处链接及本声明。

📅 发布时间：2026年4月10日 09:30（北京时间）