在 Java 开发中，反射和动态代理常被视为 “高级特性”，它们看似抽象，却支撑着 Spring、MyBatis 等主流框架的核心功能。本文结合手写 spring 框架的实践，从 “原理” 到 “落地”，详解这两个特性如何解决实际问题，以及它们在框架设计中的不可替代性。

一、反射：打破编译期约束，实现运行时动态操作

反射（Reflection）允许程序在运行时获取类的结构（如字段、方法、注解）并动态操作，这打破了 Java “编译期确定” 的传统约束，为框架的灵活性提供了基础。在 spring 中，反射是 IoC 容器、注解解析等功能的核心实现手段。

1. 反射的核心能力与 API

反射的核心是java.lang.Class类，它代表一个类的 “元数据”，通过它可以获取类的所有信息：

核心 API	作用	框架中典型应用
`Class.forName()`	加载类并返回 Class 对象	从配置文件中加载类（如 XML 中的`class`属性）
`getDeclaredConstructor()`	获取类的构造器	动态实例化对象（如 Bean 的创建）
`getDeclaredFields()`	获取类的所有字段（包括私有）	依赖注入（如 @Autowired 字段注入）
`getDeclaredMethods()`	获取类的所有方法（包括私有）	方法调用（如 MVC 中调用控制器方法）
`setAccessible(true)`	跳过访问权限检查（如操作私有字段 / 方法）	突破封装，操作类的内部成员

2. 在 spring 中的实战应用

（1）IoC 容器：反射实现 Bean 的动态创建与依赖注入

IoC 容器的核心是 “控制反转”—— 由容器负责创建 Bean 并注入依赖，而非手动new对象。这一过程完全依赖反射：

// mini-spring中的Bean工厂实现（简化版）
public class SimpleBeanFactory {// 存储Bean定义（类名、依赖等）private Map<String, BeanDefinition> beanDefinitions = new HashMap<>();// 获取Bean：核心是反射创建对象并注入依赖public Object getBean(String beanName) throws Exception {BeanDefinition bd = beanDefinitions.get(beanName);Class<?> beanClass = Class.forName(bd.getClassName());// 1. 反射创建对象（调用无参构造器）Object bean = beanClass.getDeclaredConstructor().newInstance();// 2. 反射注入依赖（处理@Autowired字段）for (Field field : beanClass.getDeclaredFields()) {if (field.isAnnotationPresent(Autowired.class)) {// 允许操作私有字段field.setAccessible(true);// 递归获取依赖的Bean（如UserService依赖UserDao）Object dependency = getBean(field.getName());// 注入依赖field.set(bean, dependency);}}return bean;}
}

解决的核心问题：

无需硬编码new UserService(new UserDao())，容器通过反射动态创建对象并注入依赖，实现了 “配置驱动” 而非 “代码驱动”；
支持私有字段注入（通过setAccessible(true)），无需为依赖字段暴露 setter 方法，保持类的封装性。

（2）注解解析：反射实现 @Transactional 等注解的识别

Spring 的@Transactional、@RequestMapping等注解之所以能生效，本质是框架通过反射扫描类和方法上的注解，并执行对应逻辑：

// 解析@Transactional注解，判断方法是否需要事务（简化版）
public class TransactionAnnotationParser {public boolean isTransactional(Method method) {// 检查方法上是否有@Transactionalif (method.isAnnotationPresent(Transactional.class)) {return true;}// 检查类上是否有@Transactional（方法注解优先级高于类）return method.getDeclaringClass().isAnnotationPresent(Transactional.class);}// 获取注解中的传播行为配置public Propagation getPropagation(Method method) {Transactional annotation = method.getAnnotation(Transactional.class);if (annotation == null) {annotation = method.getDeclaringClass().getAnnotation(Transactional.class);}return annotation.propagation();}
}

解决的核心问题：

注解本身只是 “标记”，反射让框架能在运行时识别这些标记并触发逻辑（如为 @Transactional 方法创建事务代理）；
无需修改被注解类的代码，实现了 “无侵入” 的功能增强（如事务、日志）。

3. 反射的性能与权衡

反射因需要动态解析类结构，性能比直接调用略低（通常慢 10-100 倍），但在框架设计中，这种权衡是值得的：

框架的核心价值是 “灵活性” 和 “开发效率”，反射带来的灵活性远大于性能损耗；
可通过缓存优化：将反射获取的Method、Field对象缓存（如 Spring 的MethodCache），避免重复解析。

二、动态代理：无侵入增强方法，支撑 AOP 核心功能

动态代理允许在运行时创建目标对象的 “代理对象”，并在目标方法执行前后插入增强逻辑（如日志、事务）。它是 AOP（面向切面编程）的技术基础，在 spring 中，通过动态代理实现了 “方法拦截” 和 “横切逻辑复用”。

1. 两种动态代理：JDK vs CGLIB

Java 中动态代理有两种主流实现，spring 会根据目标对象类型自动选择：

代理类型	底层原理	适用场景	核心 API / 依赖
JDK 动态代理	基于接口实现，生成的代理类实现目标接口	目标对象实现了接口	`java.lang.reflect.Proxy`
CGLIB 代理	基于继承，生成的代理类继承目标类	目标对象无接口（如 POJO）	`cglib`库（需额外引入）

（2）JDK 动态代理实战：AOP 方法拦截

JDK 动态代理通过Proxy.newProxyInstance()创建代理对象，核心是InvocationHandler接口（定义增强逻辑）：

// 1. 目标接口与实现类
public interface UserService {void saveUser(String username);
}public class UserServiceImpl implements UserService {@Overridepublic void saveUser(String username) {System.out.println("保存用户：" + username);}
}// 2. 增强逻辑：事务拦截器（实现InvocationHandler）
public class TransactionInvocationHandler implements InvocationHandler {private final Object target; // 目标对象（被代理的对象）public TransactionInvocationHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 前置增强：开启事务System.out.println("开启事务");try {// 执行目标方法Object result = method.invoke(target, args);// 后置增强：提交事务System.out.println("提交事务");return result;} catch (Exception e) {// 异常增强：回滚事务System.out.println("回滚事务");throw e;}}
}// 3. 代理工厂：创建代理对象
public class ProxyFactory {public static Object createJdkProxy(Object target) {return Proxy.newProxyInstance(target.getClass().getClassLoader(), // 类加载器target.getClass().getInterfaces(),  // 目标对象实现的接口new TransactionInvocationHandler(target) // 增强逻辑);}
}// 使用示例
public class Main {public static void main(String[] args) {UserService target = new UserServiceImpl();// 创建代理对象（表面是UserService，实际是代理类）UserService proxy = (UserService) ProxyFactory.createJdkProxy(target);proxy.saveUser("张三"); // 执行时会触发事务增强}
}

执行结果：

开启事务
保存用户：张三
提交事务

（3）CGLIB 代理实战：代理无接口类

当目标对象没有实现接口时（如OrderService是一个纯 POJO 类），JDK 动态代理无法使用，此时需用 CGLIB：

// 1. 无接口的目标类
public class OrderService {public void createOrder() {System.out.println("创建订单");}
}// 2. 增强逻辑：CGLIB的MethodInterceptor
public class LogMethodInterceptor implements MethodInterceptor {@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {// 前置增强：打印日志System.out.println("方法开始：" + method.getName());// 执行目标方法（注意：CGLIB需用proxy.invokeSuper，而非method.invoke）Object result = proxy.invokeSuper(obj, args);// 后置增强：打印耗时System.out.println("方法结束：" + method.getName());return result;}
}// 3. 代理工厂：创建CGLIB代理
public class ProxyFactory {public static Object createCglibProxy(Class<?> targetClass) {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(targetClass); // 设置父类（目标类）enhancer.setCallback(new LogMethodInterceptor()); // 设置增强器return enhancer.create(); // 创建代理对象}
}// 使用示例
public class Main {public static void main(String[] args) {OrderService proxy = (OrderService) ProxyFactory.createCglibProxy(OrderService.class);proxy.createOrder(); // 执行时会触发日志增强}
}

执行结果：

方法开始：createOrder
创建订单
方法结束：createOrder

2. 动态代理在 AOP 中的核心价值

AOP 的核心是 “将横切逻辑（如事务、日志）与业务逻辑分离”，动态代理是实现这一目标的关键：

无侵入：业务类（如UserServiceImpl）无需修改任何代码，增强逻辑通过代理对象植入；
复用性：横切逻辑（如事务管理）只需写一次，通过代理应用到多个目标类；
灵活性：可动态选择是否增强（如开发环境加日志，生产环境不加），甚至动态切换增强逻辑。

3. 代理选择策略：spring 的自动适配

spring 的ProxyFactory会根据目标对象类型自动选择代理方式，逻辑如下：

public class ProxyFactory {public static Object createProxy(Object target) {// 如果目标类实现了接口，用JDK代理if (target.getClass().getInterfaces().length > 0) {return createJdkProxy(target);} else {// 否则用CGLIB代理return createCglibProxy(target.getClass());}}
}

为什么这么设计？

JDK 代理是 JDK 原生支持，无需额外依赖，且性能略高于 CGLIB（对接口方法调用）；
CGLIB 能代理无接口类，弥补了 JDK 代理的局限性，但需要引入第三方库，且不能代理final类 / 方法（因基于继承）。

三、反射与动态代理：框架设计的 “黄金搭档”

反射和动态代理不是孤立的，它们在框架中往往协同工作，以spring 的 AOP 为例：

反射扫描：通过反射扫描所有类，识别带有@Aspect注解的切面类，解析@Before、@After等注解的增强逻辑和切入点（如execution(* save*(..))）；
动态代理：对匹配切入点的目标类，通过 JDK 或 CGLIB 创建代理对象；
反射调用：代理对象执行时，通过反射获取目标方法的注解（如@Transactional），并根据注解配置执行增强逻辑（如事务控制）。

这种组合让框架既能 “感知” 代码结构（反射），又能 “增强” 代码行为（动态代理），最终实现了 Spring “非侵入式” 的核心设计理念。