你用过Spring AOP却讲不清动态代理？ai助手星澜带你从零吃透两大代理方案

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

ai助手星澜提示：读完本文，你将彻底搞清楚Spring AOP底层到底是如何用动态代理帮你“悄无声息”地完成方法增强的。

面向切面编程（Aspect-Oriented Programming，AOP）是Spring框架的两大核心支柱之一，与IoC容器并称为“Spring双雄”，面试必考、日常开发高频使用。但很多开发者陷入了“只会用@Aspect和@Before，一被追问底层代理机制就答不出来”的困境——概念多、细节杂、JDK动态代理和CGLIB傻傻分不清。

本文将带你从痛点出发：先看静态代理的“硬编码困局”，再深入JDK动态代理与CGLIB的实现原理，配上可运行的极简代码，最后附上高频面试题参考答案。读完就能彻底吃透Spring AOP动态代理的完整知识链路。

一、痛点切入：为什么需要动态代理？

假设你有一个UserService，需要在每个方法执行前后打印日志。没有AOP时，最直观的做法是这样的：

// 定义接口
public interface UserService {
    void saveUser(String name);
    void deleteUser(Long id);
}

// 业务实现类——此时还没有任何日志逻辑
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser(String name) {
        System.out.println("保存用户：" + name);
    }
    @Override
    public void deleteUser(Long id) {
        System.out.println("删除用户，id：" + id);
    }
}

现在需要给这两个方法都加上日志。如果直接在业务代码里写，每个方法都要重复添加日志语句；如果以后要改日志格式，得一处一处修改。有没有一种办法，在不修改UserServiceImpl源码的前提下，统一给多个方法添加增强逻辑？这就是AOP要解决的问题，而实现这个能力的技术底座，正是代理模式。

1.1 静态代理：传统方案的“硬编码困局”

静态代理是实现AOP思想的最基础方式。它的核心结构包含三个部分：抽象主题（Subject） ——定义业务方法的接口；真实主题（RealSubject） ——实现业务逻辑的目标类；代理类（Proxy） ——包装真实主题，在调用前后插入增强逻辑-1。

// 代理类——硬编码增强逻辑
public class UserServiceProxy implements UserService {
    private UserService target;
    
    public UserServiceProxy(UserService target) {
        this.target = target;
    }
    
    @Override
    public void saveUser(String name) {
        System.out.println("[日志] 开始保存用户");
        target.saveUser(name);
        System.out.println("[日志] 保存完成");
    }
    
    @Override
    public void deleteUser(Long id) {
        System.out.println("[日志] 开始删除用户");
        target.deleteUser(id);
        System.out.println("[日志] 删除完成");
    }
}

静态代理的致命缺陷有三：

1. 代码冗余：每个被代理的类都要单独写一个代理类，每个方法都要手写增强代码；

2. 扩展性差：新增一个updateUser方法，既要改接口，又要改目标类，还要改代理类；

3. 维护成本高：修改日志逻辑（比如加时间戳），需要改动所有代理类。

于是，动态代理应运而生——在运行时动态生成代理对象，一套代码解决所有类的增强问题。

二、核心概念：JDK动态代理

2.1 定义与原理

JDK动态代理是Java标准库提供的一种在运行时动态生成代理类的机制，其核心实现依赖于两个关键组件：java.lang.reflect.Proxy和java.lang.reflect.InvocationHandler-20。

工作原理可以概括为三步：

1. 运行时动态生成一个实现指定接口的代理类；

2. 代理类拦截所有接口方法的调用，将调用转发给InvocationHandler；

3. InvocationHandler在invoke方法中实现增强逻辑，并通过反射调用目标对象的真实方法-21。

2.2 代码示例：从零实现AOP核心逻辑

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 1. InvocationHandler：定义增强逻辑
public class LoggingHandler implements InvocationHandler {
    private Object target;  // 被代理的目标对象
    
    public LoggingHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // ⭐ 前置增强：方法执行前
        System.out.println("[前置日志] 方法 " + method.getName() + " 开始执行");
        
        // 通过反射调用目标对象的真实方法
        Object result = method.invoke(target, args);
        
        // ⭐ 后置增强：方法执行后
        System.out.println("[后置日志] 方法 " + method.getName() + " 执行完成");
        return result;
    }
}

// 2. 创建代理对象
public class JdkProxyDemo {
    public static void main(String[] args) {
        // 目标对象（必须实现接口）
        UserService target = new UserServiceImpl();
        
        // 创建代理对象
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),      // 类加载器
            target.getClass().getInterfaces(),       // 要实现的接口数组
            new LoggingHandler(target)               // 调用处理器
        );
        
        // 调用代理方法
        proxy.saveUser("张三");
    }
}

执行流程：客户端调用proxy.saveUser("张三") → 代理类拦截调用并转发给LoggingHandler.invoke() → 执行前置日志 → 通过反射调用target.saveUser() → 执行后置日志 → 返回结果-21。

2.3 核心要点

三、关联概念：CGLIB动态代理

3.1 定义与原理

CGLIB（Code Generation Library） 是一个基于ASM字节码操作框架的开源代码生成库，它不要求目标类实现接口，而是通过继承的方式——在运行时动态生成目标类的子类作为代理，重写所有非final方法并在其中插入增强逻辑-30-31。

3.2 代码示例

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

// 1. 目标类（无需实现任何接口）
public class OrderService {
    public void createOrder(String product) {
        System.out.println("创建订单：" + product);
    }
    public void payOrder(Long orderId) {
        System.out.println("支付订单，id：" + orderId);
    }
}

// 2. MethodInterceptor：定义拦截逻辑
public class LogInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) 
            throws Throwable {
        System.out.println("[CGLIB前置] 方法 " + method.getName() + " 执行前");
        // 调用父类（即目标类）的原始方法
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("[CGLIB后置] 方法 " + method.getName() + " 执行后");
        return result;
    }
}

// 3. 创建代理对象
public class CglibProxyDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(OrderService.class);      // 设置父类为目标类
        enhancer.setCallback(new LogInterceptor());      // 设置拦截器
        
        OrderService proxy = (OrderService) enhancer.create();  // 生成代理对象
        proxy.createOrder("笔记本电脑");
    }
}

执行流程：客户端调用proxy.createOrder() → 实际调用的是CGLIB生成的子类中的createOrder方法 → 子类方法内部调用LogInterceptor.intercept() → 执行前置增强 → 通过proxy.invokeSuper()调用父类原始方法 → 执行后置增强 → 返回结果-31。

3.3 核心要点

四、概念关系与区别总结

一句话总结：JDK动态代理是“面向接口”的代理方案，依赖反射；CGLIB是“面向类”的代理方案，通过字节码生成子类实现，不要求目标类实现接口-。

4.1 Spring如何选择？

Spring通过DefaultAopProxyFactory自动判断：若目标类无任何接口或配置了proxyTargetClass=true，则使用CGLIB；否则使用JDK动态代理-40。

不同版本的默认行为差异：

• Spring Framework（传统）：proxyTargetClass=false，默认优先JDK动态代理；

• Spring Boot 2.x及以上：spring.aop.proxy-target-class=true，默认使用CGLIB。

⚠️ 常见陷阱：@Transactional注解失效的典型原因——在同一个类内部调用this.xxxMethod()，没有经过代理对象，因此切面不生效-51。

五、底层原理支撑：反射与字节码技术

两种动态代理方案底层依赖的核心技术各不相同：

JDK动态代理在运行时通过Proxy.newProxyInstance()动态生成字节码，生成一个名为$Proxy0的代理类并加载到JVM中-20。CGLIB则通过ASM框架在内存中直接操作字节码，生成目标类的子类（如UserService$$EnhancerByCGLIB$$xxx），并生成两个FastClass文件来优化方法调用性能-31。

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

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

标准答案（简洁版） ：

Spring AOP基于动态代理模式实现。运行时为目标对象动态生成代理对象，在代理对象的方法调用前后插入切面逻辑。具体有两种实现方式：目标类实现了接口时，使用JDK动态代理（基于Proxy和InvocationHandler）；目标类没有实现接口时，使用CGLIB代理（通过生成目标类的子类实现）-3。

加分回答：

Spring AOP的核心入口是AnnotationAwareAspectJAutoProxyCreator，它是一个BeanPostProcessor，在Bean初始化完成后调用postProcessAfterInitialization，判断当前Bean是否需要代理，如果需要则通过ProxyFactory创建代理对象并替换原始Bean-3。容器中最终注入的是代理对象，而非原始对象。

Q2：JDK动态代理和CGLIB有什么区别？Spring如何选择？

标准答案 ：

Spring的默认选择逻辑：目标类有接口时优先使用JDK动态代理，无接口时使用CGLIB。可通过proxyTargetClass=true强制使用CGLIB-41。

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

标准答案 ：

常见原因有4个：

1. 方法不是public：Spring事务只对public方法生效；

2. 同类内部调用：在同一个类中通过this.method()直接调用，绕过了代理对象，切面不生效；

3. final方法或final类：CGLIB无法代理final类或重写final方法；

4. 异常被吞没：事务默认只对RuntimeException和Error回滚，如抛出检查型异常需配合rollbackFor属性-51。

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

标准答案 ：

Spring AOP是AspectJ规范的轻量级子集实现，对于大多数业务场景（日志、事务、权限）已足够-11。

七、结尾总结

本文围绕Spring AOP动态代理的核心链路，系统梳理了：

✅ 痛点驱动：静态代理带来的代码冗余、扩展性差、维护困难，倒逼动态代理方案诞生；

✅ JDK动态代理：基于接口的代理方案，核心组件Proxy和InvocationHandler，通过反射实现方法拦截；

✅ CGLIB动态代理：基于继承的代理方案，核心类Enhancer和MethodInterceptor，通过ASM字节码生成子类实现；

✅ Spring选择策略：接口优先原则 + proxyTargetClass参数控制，以及Spring Boot 2.x默认使用CGLIB；

✅ 高频面试题：梳理了4道经典考题的规范答案与得分要点。

需要特别留意的易错点：

• JDK动态代理不能代理没有接口的类，而CGLIB不能代理final类/方法；

• Spring AOP只支持方法级别的连接点，不支持字段拦截；

• 同类内部调用会导致代理失效，这是@Transactional失效的最常见原因。

动态代理的底层涉及到字节码增强、类加载器机制、反射性能优化等更深层的话题，下一篇文章将深入剖析AnnotationAwareAspectJAutoProxyCreator的源码链路，以及Spring如何利用责任链模式组织多个切面的通知执行顺序。ai助手星澜，陪你一起深入底层，拿下面试！

📌 本文推荐收藏：遇到AOP相关问题，随时回看这份“JDK vs CGLIB对比表”和面试题答案。