1. 前言：在AI时代重新拾起源码的温暖
"在AI可以自动生成代码的今天，为什么还要读源码？因为理解原理才能让我们从代码的'使用者'变成'创造者'！"
最近AI的崛起确实让技术圈发生了翻天覆地的变化，博主之前的源码解析栏目也因此沉寂了一段时间。不过，在经历了更多生产问题复盘和真实架构设计的实战后，我愈发觉得：理解底层原理才是应对技术变革的不变法宝。
今天，让我们重新点燃源码解析的热情！随着这两年工作的积累，我对这些基础框架有了更深刻的理解，可以为大家带来更多实际应用中的"避坑指南"。好消息是，今天的代码量很少，相信你喝杯咖啡的时间就能轻松掌握！
代码分支：https://github.com/yihuiaa/little-spring/tree/jdk-dynamic-proxy
2. 总体设计：AOP动态代理的"四重奏"
在开始代码之旅前，让我们先认识今天的"主演阵容"：
核心组件总览
classDiagram class AopProxy { <<interface>> +getProxy() Object } class JdkDynamicAopProxy { -AdvisedSupport advised +getProxy() Object +invoke(Object, Method, Object[]) Object } class AdvisedSupport { -TargetSource targetSource -MethodInterceptor methodInterceptor -MethodMatcher methodMatcher +getter/setter methods } class TargetSource { -Object target +getTargetClass() Class[] +getTarget() Object } class MethodInterceptor { <<interface>> +invoke(MethodInvocation) Object } class ReflectiveMethodInvocation { -Object target -Method method -Object[] arguments +proceed() Object } JdkDynamicAopProxy ..|> AopProxy JdkDynamicAopProxy ..|> InvocationHandler JdkDynamicAopProxy --> AdvisedSupport AdvisedSupport --> TargetSource AdvisedSupport --> MethodInterceptor JdkDynamicAopProxy --> ReflectiveMethodInvocation MethodInterceptor --> ReflectiveMethodInvocation
各组件职责说明：
- AopProxy：获取代理对象的抽象接口，定义了统一的代理创建标准
- JdkDynamicAopProxy：基于JDK动态代理的具体实现，我们的"男主角"
- TargetSource：被代理对象的"保镖"，负责安全地封装目标对象
- MethodInterceptor：方法拦截器，AOP Alliance的"标准公民"，可以在方法执行前后插入自定义逻辑
- AdvisedSupport：AOP配置的"大脑"，协调各个组件协同工作
3. 新增依赖：欢迎AOP Alliance大家庭
在开始编码前，我们需要引入一个重要依赖：
xml
<dependency>
<groupId>aopalliance</groupId>
<artifactId>aopalliance</artifactId>
<version>1.0</version>
</dependency>这个依赖是什么来头？
AOP Alliance是一个为AOP（面向切面编程）提供标准接口的库，你可以把它想象成AOP世界的"联合国"------它定义了各个AOP框架都能理解的"官方语言"，让不同的AOP实现能够和平共处、相互协作。
想象一下，如果没有这个标准，Spring AOP和Guice AOP就像两个说不同语言的人，根本无法交流！
4. 核心代码解析：深入AOP动态代理的内心世界
4.1 AdvisedSupport - AOP配置的"指挥中心"
java
package org.springframework.aop;
import org.aopalliance.intercept.MethodInterceptor;
/**
* Spring AOP核心配置类 - 负责协调AOP代理的各个组件
* @author yihui
*/
public class AdvisedSupport {
/**
* 目标对象源 - 封装被代理的目标对象
* 就像电影的"选角导演"，负责找到合适的演员（目标对象）
*/
private TargetSource targetSource;
/**
* 方法拦截器 - 定义具体的增强逻辑
* 相当于电影的"特效团队"，在原有剧情前后添加炫酷特效
*/
private MethodInterceptor methodInterceptor;
/**
* 方法匹配器 - 决定哪些方法需要被拦截
* 就像"剧本编辑"，决定哪些场景需要添加特效
*/
private MethodMatcher methodMatcher;
// getter和setter方法...
}设计亮点：
- 采用组合模式，将三个核心组件完美整合
- 配置与执行分离，符合单一职责原则
- 为后续扩展预留了充足空间
4.2 TargetSource - 目标对象的"贴心保镖"
java
package org.springframework.aop;
/**
* 被代理的目标对象 - 采用不可变设计确保线程安全
* @author yihui
*/
public class TargetSource {
/**
* 不可变的目标对象引用 - 一旦"签约"就不能更改
*/
private final Object target;
public TargetSource(Object target) {
this.target = target;
}
/**
* 返回目标对象实现的所有接口 - 为JDK动态代理提供"角色清单"
*/
public Class<?>[] getTargetClass() {
return this.target.getClass().getInterfaces();
}
public Object getTarget() {
return this.target;
}
}为什么需要TargetSource？
想象一下，如果没有这个封装，每次需要目标对象时都要直接操作原始对象，就像没有经纪人的明星------既不够安全，也不够专业！
4.3 JdkDynamicAopProxy - 动态代理的"魔法师"
java
package org.springframework.aop.framework;
import org.aopalliance.intercept.MethodInterceptor;
import org.springframework.aop.AdvisedSupport;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* JDK动态代理 - 巧妙融合AOP标准与JDK原生动态代理
* @author yihui
*/
public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {
private final AdvisedSupport advised;
public JdkDynamicAopProxy(AdvisedSupport advised) {
this.advised = advised;
}
/**
* 创建代理对象 - 这里是魔法开始的地方！
*/
@Override
public Object getProxy() {
return Proxy.newProxyInstance(
getClass().getClassLoader(),
advised.getTargetSource().getTargetClass(),
this
);
}
/**
* 方法调用拦截 - 每个方法调用都要经过这里的"安检"
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 检查这个方法是否需要被拦截（是否需要过安检）
if (advised.getMethodMatcher().matches(method, advised.getTargetSource().getTarget().getClass())) {
// 需要拦截：请拦截器来处理（走特殊通道）
MethodInterceptor methodInterceptor = advised.getMethodInterceptor();
return methodInterceptor.invoke(new ReflectiveMethodInvocation(
advised.getTargetSource().getTarget(), method, args));
}
// 不需要拦截：直接放行（走普通通道）
return method.invoke(advised.getTargetSource().getTarget(), args);
}
}双重身份的魅力：
- AopProxy接口：对外提供统一的代理创建接口
- InvocationHandler接口：对内处理方法调用的拦截逻辑
这种设计就像一个人既是"建筑设计师"（负责创建），又是"物业经理"（负责运营），确保了整个流程的连贯性。
JDK动态代理 vs CGLIB代理：
| 特性 | JDK动态代理 | CGLIB代理 |
|---|---|---|
| 基础 | 基于接口 | 基于类继承 |
| 依赖 | JDK内置，无需额外依赖 | 需要CGLIB库 |
| 性能 | JDK6+性能优秀 | 通常稍慢，但在持续优化 |
| 限制 | 只能代理接口方法 | 可以代理类，但final方法不行 |
实际开发中的"坑"：
- 自调用问题：代理对象内部方法互相调用时，不会经过代理
java
public class UserService {
public void updateUser() {
this.validateUser(); // 这个调用不会走代理！
}
}- equals和hashCode：需要特殊处理，避免代理对象比较时出现意外结果
4.4 ReflectiveMethodInvocation - 方法调用的"时光胶囊"
java
package org.springframework.aop.framework;
import org.aopalliance.intercept.MethodInvocation;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;
/**
* 方法调用上下文封装 - 把一次方法调用打包成"标准化包裹"
* @author yihui
*/
public class ReflectiveMethodInvocation implements MethodInvocation {
/**
* 目标对象引用 - 要调用谁
*/
private final Object target;
/**
* 方法元数据 - 要调用什么方法
*/
private final Method method;
/**
* 方法参数 - 调用时传递什么参数
*/
private final Object[] arguments;
public ReflectiveMethodInvocation(Object target, Method method, Object[] arguments) {
this.target = target;
this.method = method;
this.arguments = arguments;
}
/**
* 执行目标方法 - 打开"时光胶囊"，执行原始逻辑
*/
@Override
public Object proceed() throws Throwable {
return method.invoke(target, arguments);
}
// 其他信息获取方法...
@Override
public Method getMethod() { return method; }
@Override
public Object[] getArguments() { return arguments; }
@Override
public Object getThis() { return target; }
@Override
public AccessibleObject getStaticPart() { return method; }
}为什么需要这个"时光胶囊"？
它把一次方法调用的所有上下文信息完整保存，让拦截器可以在任何时候、任何地方重现这次调用，就像把当下的瞬间封存在胶囊中，随时可以重新开启。
5. 实战测试：让代码"活"起来
理论说再多，不如实际跑一跑！让我们看看这些组件如何协同工作：
java
public class DynamicProxyTest {
@Test
public void testJdkDynamicProxy() throws Exception {
// 1. 准备目标对象（我们的"演员"）
WorldService worldService = new WorldServiceImpl();
// 2. 配置AOP（搭建"拍摄现场"）
AdvisedSupport advisedSupport = new AdvisedSupport();
TargetSource targetSource = new TargetSource(worldService);
WorldServiceInterceptor methodInterceptor = new WorldServiceInterceptor();
MethodMatcher methodMatcher = new AspectJExpressionPointcut("execution(* service.WorldService.sayHello(..))").getMethodMatcher();
advisedSupport.setTargetSource(targetSource);
advisedSupport.setMethodInterceptor(methodInterceptor);
advisedSupport.setMethodMatcher(methodMatcher);
// 3. 创建代理（开机！）
WorldService proxy = (WorldService) new JdkDynamicAopProxy(advisedSupport).getProxy();
// 4. 使用代理（Action!）
proxy.sayHello();
}
}
// 业务接口
public interface WorldService {
void sayHello();
}
// 业务实现
public class WorldServiceImpl implements WorldService {
@Override
public void sayHello() {
System.out.println("Hello World");
}
}
// 自定义拦截器
public class WorldServiceInterceptor implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("方法处理前");
Object result = invocation.proceed();
System.out.println("方法处理后");
return result;
}
}运行结果：
方法处理前
Hello World
方法处理后看到这个输出，是不是有种"魔法生效"的成就感？我们的拦截器成功在目标方法执行前后添加了自定义逻辑！
6. 总结：从理解到掌握
通过今天的学习，我们不仅理解了JDK动态代理在Spring AOP中的应用，更重要的是，我们看到了一个优秀框架的设计思想：
- 标准化思维：通过AOP Alliance接口，确保与生态系统的兼容性
- 组合优于继承：通过AdvisedSupport组合各个组件，保持灵活性
- 职责分离：每个类都有明确的单一职责，便于理解和维护
- 扩展性设计：为后续功能升级预留了充足空间
记住这个精妙的AOP代理流程：
flowchart TD A[配置阶段] --> B[创建代理] B --> C[方法调用] subgraph A [配置阶段] A1[TargetSource] --> A2[AdvisedSupport] A3[MethodInterceptor] --> A2 A4[MethodMatcher] --> A2 end subgraph B [创建代理] B1[AdvisedSupport] --> B2[JdkDynamicAopProxy] B2 --> B3[代理对象] end subgraph C [方法调用] C1[代理对象] --> C2{MethodMatcher检查} C2 -->|匹配| C3[MethodInterceptor] C2 -->|不匹配| C4[直接调用目标方法] C3 --> C5[ReflectiveMethodInvocation] C5 --> C6[目标方法执行] end
虽然这只是Spring AOP的简化实现，但核心思想与完整版一脉相承。理解了这个基础版本，再去学习完整的Spring AOP源码，就会觉得"原来如此"！
源码阅读就像拼图游戏，一开始可能只见树木不见森林，但当所有碎片就位时，一幅精美的画卷就会呈现在眼前。希望今天的讲解能帮你找到几块关键的拼图！
在接下来的章节中，我们将继续探索AOP的更多奥秘，包括CGLIB代理、拦截器链等高级特性。敬请期待！