Java 反射（Reflection）

反射是 Java 提供的一种在运行期（runtime）审视并操作自身结构的元编程（meta-programming）能力。它使得程序可以在运行时探查类的字段、方法、构造器、注解，并能动态调用方法、构造对象、读写字段值。反射既是 Spring、Hibernate、MyBatis、JUnit 等几乎所有 Java 主流框架的基石，也是理解 Java 类型系统、字节码、JVM 行为的钥匙。

1. 学习目标（基于 Bloom 分类法）

本节以 Bloom 教育目标分类法（1956 版本，Anderson 2001 修订版）为框架，对学习目标进行显式分级，便于读者自检学习成果与认知深度。

1.1 认知层级目标

1.2 学习成果自检清单

完成本章学习后，读者应能独立完成以下任务：

1. 在不查阅文档的前提下，编写出通过反射读取类全部成员信息的小工具。
2. 用一句话向同事解释反射的”动态分派”与”性能代价”之间的关系。
3. 在 Spring 源码中定位出至少 3 处反射调用，并说明其用途。
4. 识别生产代码中滥用反射的反模式，并给出替换方案（如 MethodHandle、VarHandle、LambdaMetafactory）。
5. 在白板上画出 Class.forName → 类加载 → 方法区元数据 → Method 对象 → invoke 调用栈 的完整链路图。

1.3 前置知识地图

面向对象编程（OOP）
    │
    ├── 类与对象
    ├── 封装、继承、多态
    └── 接口与抽象类
            │
            ▼
JVM 类加载机制
    │
    ├── 加载 → 链接（验证、准备、解析）→ 初始化
    ├── 双亲委派模型
    └── 方法区与元数据
            │
            ▼
Java 反射（本章）
    │
    ├── java.lang.Class
    ├── java.lang.reflect.*
    ├── 动态代理（JDK Proxy / CGLIB）
    └── MethodHandle / VarHandle

1.4 章节阅读建议

• 零基础读者：建议按顺序阅读第 2–5 节，配合第 5 节代码示例上机实操，再回到第 3、4 节深化理论。
• 有 Java 经验的工程师：可跳过第 2、3 节基础部分，直接阅读第 4 节字节码分析、第 7 节反模式、第 9 节案例研究。
• 框架开发者：重点关注第 8 节工程实践与第 9 节案例研究，特别是 Spring、MyBatis、Hibernate 的反射使用模式。

2. 历史动机与演化

2.1 反射的起源：从静态语言到动态审视

Java 1.0（1996 年 1 月发布）最初并不包含反射 API。彼时 Java 的设计哲学是”静态、安全、显式”——所有类型信息在编译期确定，编译器对成员可见性进行严格检查。这种设计对于编写应用程序足够，但对于构建 开发工具（IDE、调试器、文档生成器） 与 组件框架（如可视化 Bean 拼装器） 则力不从心。

1997 年 5 月发布的 JDK 1.1 引入了反射 API（JEP 的前身，JSR 早期规范），其原始动机来自三个工程需求：

1. JavaBeans 规范：为了让可视化构建工具（如 Sun 的 BeanBox、IBM VisualAge）能在不知道具体 Bean 类型的情况下，自动发现属性、事件、方法，并提供拖拽式拼装能力。JavaBeans 规范（Glasgow 版本）明确要求”自省（introspection）“机制，反射正是其底层支撑。
2. Object Serialization（对象序列化）：JDK 1.1 引入的 java.io.ObjectInputStream / ObjectOutputStream 需要在运行时读取对象字段并写入字节流，或从字节流中读取字段并赋值。没有反射，这一能力几乎无法实现。
3. 远程方法调用（RMI）：RMI 需要在客户端生成 stub，在服务端根据方法签名分发调用——这正是动态代理与反射的天然场景。

2.2 关键里程碑时间线

2.3 设计哲学：为什么 Java 反射”重”且”慢”

Java 反射的”重”源于其 元对象协议（Meta-Object Protocol, MOP） 的设计取向。Gregor Kiczales 等人在 1991 年的《The Art of the Metaobject Protocol》（AMOP）一书中区分了两类 MOP：

• 内省式（Introspective）MOP：仅允许程序在运行时”读取”自身结构（查询方法、字段、注解），不改变结构。Java 反射属于此类。
• 干预式（Intercessory）MOP：允许程序在运行时”修改”自身结构（添加方法、修改继承关系）。Lisp CLOS、Python、Ruby、Smalltalk 属于此类。

Java 选择了内省式 MOP，原因有三：

1. 类型安全：Java 强调编译期类型检查，干预式 MOP 会让类型系统在运行时变形，违背”一次编写、到处运行”的可预测性。
2. JVM 优化：内省式 MOP 使得 JIT 编译器可以基于”类结构在加载后不可变”的假设进行激进优化（如内联、去虚化）。
3. 安全模型：Java 1.0 的安全模型（Applet 沙箱）要求严格的成员可见性检查，干预式 MOP 会破坏这一模型。

这一选择的代价是：反射调用必须经过”运行时可见性检查 → 方法签名匹配 → 参数装箱/拆箱 → 实际方法分派 → 返回值装箱/拆箱”的多重步骤，无法像普通方法调用那样在编译期就完成分派。这就是反射”慢”的根源——后面第 4 节会从字节码层面深入分析。

2.4 JEP 与反射相关提案

2.5 反射与 Java 生态的共生关系

Java 反射并非孤立存在，它与以下生态形成了共生关系：

• Spring Framework：IoC 容器（BeanUtils、ReflectionUtils）、AOP（cglib 代理）、注解驱动（@Autowired、@RequestMapping）全部建立在反射之上。
• Hibernate / MyBatis：ORM 框架通过反射读写实体字段，实现对象-关系映射。
• JUnit：@Test、@Before、@After 注解的发现与执行依赖反射。
• Jackson / Gson：JSON 序列化/反序列化通过反射读写 POJO 字段。
• Lombok：编译期通过注解处理器（非反射）修改 AST，但运行期反射读取其生成的字段与方法。
• JDK 工具链：javap、jconsole、VisualVM、jdb 都通过反射（或类似机制）查看运行时类信息。

历史轶事：JDK 1.1 设计反射 API 时，Sun 工程师曾在内部争论是否采用 Smalltalk 风格的”完全动态对象”。最终选择保守路线——这一定调使 Java 在企业级市场获得”可预测、可维护”的声誉，但也让动态语言特性（如 Groovy、JRuby）需要在 JVM 上构建额外的元对象层。

3. 形式化定义

3.1 反射的形式化定义

设 $J$ 为一个 Java 程序的运行时状态空间，$C$ 为所有已加载类的集合，$M_c$ 为类 $c \in C$ 的方法集合，$F_c$ 为类 $c$ 的字段集合，$K_c$ 为类 $c$ 的构造器集合，$A_c$ 为类 $c$ 上声明的注解集合。

定义 1（反射视图）：反射视图 $\mathcal{R}: C \to \mathcal{P}(\text{MetaInfo})$ 是一个从类到其元信息集合的映射，其中：

其中 $\text{sig}(m)$ 为方法签名，$\text{mods}(m)$ 为修饰符位掩码，$\text{ann}(m)$ 为方法上的注解集合。

定义 2（反射调用）：反射方法调用是一个三元组 $\text{Invoke}(\mu, o, \bar{a})$，其中 $\mu \in \mathcal{R}(c)$ 是一个 Method 对象，$o$ 是接收者对象（静态方法为 null），$\bar{a} = (a_1, a_2, \ldots, a_n)$ 是参数元组。其语义为：

3.2 类型系统与 Class 对象的关系

每个已加载的类 $c$ 在 JVM 中对应一个唯一的 Class 对象 $\kappa_c$。这一对应关系满足：

即 Class 对象是类的”运行时身份”。这一性质由 JVM 规范保证，并通过 Class.forName + 类加载器命名空间实现。

类型系统的层级关系（继承、接口实现、数组元素类型）通过 Class 的方法暴露：

• getSuperclass()：返回直接父类的 Class 对象，接口返回 null，Object 返回 null。
• getInterfaces()：返回直接实现的接口数组。
• getComponentType()：若为数组类型，返回元素类型；否则 null。
• isAssignableFrom(Class<?>)：判断类型赋值兼容性，等价于 $c_1 \sqsupseteq c_2$（$c_2$ 是 $c_1$ 的子类型）。

3.3 类型擦除与泛型反射

Java 泛型采用 擦除（erasure） 实现：编译后泛型类型参数 $\langle T \rangle$ 被擦除为其上界（默认 Object）。这导致运行时 List<String> 与 List<Integer> 共享同一个 Class 对象（java.util.List）。

但反射并非完全无法恢复泛型信息。对于 字段声明、方法返回类型、方法参数类型、类继承的父类与接口，编译器会将泛型签名写入 Signature 属性（JVMS §4.7.9.1），反射可通过 Type 体系读取：

形式化地，设 $\Gamma$ 为类型环境，$\tau$ 为源码中的泛型类型，$\text{erase}(\tau)$ 为擦除后的类型，$\text{sig}(\tau)$ 为 Signature 属性中保存的泛型签名，则：

3.4 Method.invoke 的复杂度下界

设 $n$ 为方法参数个数，反射调用 Method.invoke 的复杂度下界为：

其中 $C_{\text{access}}$ 为访问检查开销（依赖 setAccessible 状态），$C_{\text{dispatch}}$ 为分派开销（虚方法分派 vs. 静态绑定）。直接调用的复杂度为 $O(1)$（不考虑参数传递本身），因此反射调用的常数因子通常比直接调用大 10–100 倍（无 JIT 优化时）。

HotSpot JIT 在 JDK 7+ 对反射调用做了内联缓存（inline cache）优化：当 Method.invoke 的目标方法稳定不变时，JIT 会生成直接的调用点，使反射调用接近直接调用的性能。这一优化在 JDK 8 的 LambdaMetafactory 中被进一步强化。

3.5 setAccessible 的形式化语义

AccessibleObject.setAccessible(boolean flag) 改变反射对象的访问检查行为。其形式化语义为：

其中 $\text{isVisible}(\mu, \text{caller})$ 由 Java 语言规范（JLS §6.6）定义，依赖 public、protected、private、包可见性的复杂规则。

在 JDK 9+ 模块系统下，可见性检查还需考虑模块边界：

其中 $\text{isOpen}(m_1, m_2)$ 当且仅当模块 $m_1$ 通过 opens 或 open 向 $m_2$ 开放对应包。

4. 理论推导：JVM 视角下的反射机制

4.1 Class 对象在 JVM 中的存储

JVM 规范（JVMS §2.5.1）规定，每个已加载的类在方法区（HotSpot 中称为 Metaspace，JDK 8 前 PermGen）中存储一个 类元数据（Class Metadata） 结构。这一结构包含：

• 类名、父类名、实现的接口列表
• 字段表（fields），每个字段记录名称、描述符（descriptor）、修饰符、注解
• 方法表（methods），每个方法记录名称、描述符、修饰符、注解、字节码偏移
• 常量池（constant pool）
• 方法表分派槽位（vtable for virtual methods, itable for interface methods）

Class 对象是一个 指向类元数据的”门面”（facade）。在 HotSpot 内部，Class 对象的 C++ 实现包含一个 Klass* 指针，指向方法区中的 InstanceKlass（普通类）或 ArrayKlass（数组类型）。

[Java Heap]                [Metaspace]
+-----------------+        +--------------------------+
| Class<Object>   | -----> | InstanceKlass            |
+-----------------+        |   - _name: Symbol*       |
                           |   - _fields: FieldInfo[] |
                           |   - _methods: Method[]   |
                           |   - _constants: ConstantPool
                           |   - _vtable: ...          |
                           +--------------------------+

4.2 Class.forName 的字节码与调用链

Class.forName(String className) 是反射的入口。其内部调用链：

1. JVM 入口：Class.forName0 是 native 方法，调用 JVM 内部 JVM_FindClassFromCaller。
2. 类加载：根据调用者的类加载器，按双亲委派模型查找类。若类未加载，触发完整的加载-链接-初始化流程。
3. 返回 Class 对象：JVM 从 Metaspace 取出 InstanceKlass，返回对应的 Class 对象。

Class.forName("java.util.ArrayList")
    │
    ▼
JVM_FindClassFromCaller(loader, "java.util.ArrayList", ...)
    │
    ├── 询问 BootClassLoader
    ├── 询问 PlatformClassLoader (JDK 9+)
    ├── 询问 AppClassLoader
    └── 找到 ArrayList.class
            │
            ▼
        加载 → 验证 → 准备 → 解析 → 初始化
            │
            ▼
        返回 Class<ArrayList>

4.3 Method.invoke 的字节码与分派

反射方法调用的核心是 Method.invoke(Object obj, Object... args)。其字节码层调用链：

1. Java 层：Method.invoke 先做访问检查，再调用 MethodAccessor.invoke。
2. MethodAccessor：HotSpot 提供两种实现：
   • NativeMethodAccessorImpl：JVM 启动初期使用，调用 JVM_InvokeMethod，每次都进行完整分派。
   • GeneratedMethodAccessorImpl：当同一 Method 被调用次数超过阈值（默认 15 次，由 -Dsun.reflect.inflationThreshold 控制）后，JVM 通过 ASM 生成一个专门的字节码类，直接调用目标方法，跳过 native 转换。
3. 实际调用：根据方法是否为 static、是否为虚方法，执行不同的分派策略。

4.3.1 Inflation 机制推导

设 $T_{\text{native}}$ 为 native accessor 的调用时间，$T_{\text{generated}}$ 为生成 accessor 的调用时间，$T_{\text{gen}}$ 为生成字节码的一次性开销。则 $n$ 次调用的总时间为：

当 $n \to \infty$ 时，平均每次调用时间趋近于 $T_{\text{generated}}$，这是反射调用性能接近直接调用的根本原因。但 $T_{\text{gen}}$ 较大（生成字节码、类加载、JIT 编译），因此短生命周期、低频调用场景不划算。

4.3.2 vtable 与 itable 的角色

对于虚方法调用，GeneratedMethodAccessorImpl 生成的字节码包含 invokevirtual 指令，由 JVM 根据 vtable 分派到具体方法。这与普通虚方法调用相同，因此反射调用的”分派开销”在 JIT 优化后接近于零。

但对于接口方法调用（invokeinterface），JVM 需要查找 itable，开销略高于 vtable。这就是为什么”基于接口的动态代理”比”基于类的动态代理”在某些场景下略慢——但 JIT 的去虚化（devirtualization）可以消除这一差异。

4.4 安全检查的开销分析

反射的安全检查包括：

1. Caller Sensitivity：@CallerSensitive 注解的方法需要识别真实调用者，JVM 通过 Reflection.getCallerClass(int) 获取，开销远小于栈帧扫描。
2. 模块可见性检查：JDK 9+ 引入，需要比较两个 Module 对象的 opens 关系，开销 $O(1)$ 但常数较大。
3. 访问修饰符检查：基于位运算，开销极小。

setAccessible(true) 跳过 1–3 的所有检查，因此能显著提升性能。但 JDK 9+ 后，跨模块 setAccessible 受 opens 约束，违反会抛出 InaccessibleObjectException。

4.5 MethodHandle 的设计动机

MethodHandle（JDK 7）的设计目标是”反射的现代替代品”。其优势：

• 类型签名固化：MethodType 在创建时确定，调用时不再做类型检查，开销低。
• invokedynamic 兼容：可直接作为 invokedynamic 的 bootstrap 方法，与 lambda、字符串拼接等特性无缝集成。
• JIT 友好：MethodHandle.invokeExact 在 JIT 中可被内联到几乎零开销。

形式化地，MethodHandle 的调用语义为：

否则抛出 WrongMethodTypeException。这与 Method.invoke 的”运行时类型检查 + 装箱”形成对比。

5. 代码示例（可运行 Java 代码）

本节提供一组可直接编译运行的 Java 反射示例。所有代码在 JDK 17+ 验证通过。

5.1 环境准备

# 创建工作目录
mkdir -p ~/java-reflection-demo
cd ~/java-reflection-demo

# 验证 JDK 版本
java -version
# 应输出 openjdk version "17.x.x" 或更高

5.2 示例 1：获取 Class 对象的三种方式

// file: GetClassDemo.java
import java.util.ArrayList;

public class GetClassDemo {
    public static void main(String[] args) throws Exception {
        // 方式 1：类名.class 编译期常量
        Class<ArrayList> c1 = ArrayList.class;
        System.out.println("方式 1: " + c1.getName());

        // 方式 2：对象.getClass() 运行时类型
        ArrayList<String> list = new ArrayList<>();
        Class<?> c2 = list.getClass();
        System.out.println("方式 2: " + c2.getName());

        // 方式 3：Class.forName 运行时字符串
        Class<?> c3 = Class.forName("java.util.ArrayList");
        System.out.println("方式 3: " + c3.getName());

        // 同一类的 Class 对象全局唯一
        System.out.println("c1 == c2: " + (c1 == c2));
        System.out.println("c1 == c3: " + (c1 == c3));
    }
}

编译与运行：

javac GetClassDemo.java
java GetClassDemo

预期输出：

方式 1: java.util.ArrayList
方式 2: java.util.ArrayList
方式 3: java.util.ArrayList
c1 == c2: true
c1 == c3: true

5.3 示例 2：枚举类的字段、方法、构造器

// file: InspectClassDemo.java
import java.lang.reflect.*;

public class InspectClassDemo {
    public static void inspectClass(String className) throws Exception {
        Class<?> c = Class.forName(className);
        System.out.println("==== 类: " + c.getName() + " ====");

        // 修饰符
        System.out.println("修饰符: " + Modifier.toString(c.getModifiers()));

        // 父类
        Class<?> superClass = c.getSuperclass();
        System.out.println("父类: " + (superClass != null ? superClass.getName() : "无"));

        // 接口
        System.out.print("接口: ");
        for (Class<?> iface : c.getInterfaces()) {
            System.out.print(iface.getName() + " ");
        }
        System.out.println();

        // 字段（仅 public，包含继承）
        System.out.println("--- Public Fields ---");
        for (Field f : c.getFields()) {
            System.out.printf("  %s %s %s%n",
                    Modifier.toString(f.getModifiers()),
                    f.getType().getSimpleName(),
                    f.getName());
        }

        // 字段（本类声明的，含 private）
        System.out.println("--- Declared Fields ---");
        for (Field f : c.getDeclaredFields()) {
            System.out.printf("  %s %s %s%n",
                    Modifier.toString(f.getModifiers()),
                    f.getType().getSimpleName(),
                    f.getName());
        }

        // 方法（本类声明）
        System.out.println("--- Declared Methods ---");
        for (Method m : c.getDeclaredMethods()) {
            System.out.printf("  %s %s %s(%s)%n",
                    Modifier.toString(m.getModifiers()),
                    m.getReturnType().getSimpleName(),
                    m.getName(),
                    formatParams(m));
        }

        // 构造器
        System.out.println("--- Constructors ---");
        for (Constructor<?> k : c.getDeclaredConstructors()) {
            System.out.printf("  %s(%s)%n",
                    Modifier.toString(k.getModifiers()),
                    formatParams(k));
        }
    }

    private static String formatParams(Executable e) {
        Parameter[] params = e.getParameters();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < params.length; i++) {
            if (i > 0) sb.append(", ");
            sb.append(params[i].getType().getSimpleName());
            if (params[i].isNamePresent()) {
                sb.append(" ").append(params[i].getName());
            }
        }
        return sb.toString();
    }

    public static void main(String[] args) throws Exception {
        inspectClass("java.util.ArrayList");
    }
}

编译时建议加 -parameters 以获取参数名：

javac -parameters InspectClassDemo.java
java InspectClassDemo

5.4 示例 3：动态构造对象与调用方法

// file: DynamicInvokeDemo.java
import java.lang.reflect.*;
import java.util.*;

public class DynamicInvokeDemo {
    public static void main(String[] args) throws Exception {
        // 1. 通过无参构造器创建对象
        Class<?> listClass = Class.forName("java.util.ArrayList");
        Object list1 = listClass.getDeclaredConstructor().newInstance();
        System.out.println("list1 类型: " + list1.getClass().getName());
        System.out.println("list1 size: " + ((ArrayList<?>) list1).size());

        // 2. 通过有参构造器创建对象
        Constructor<?> ctor = listClass.getConstructor(int.class);
        Object list2 = ctor.newInstance(16);
        System.out.println("list2 类型: " + list2.getClass().getName());

        // 3. 动态调用方法
        Method addMethod = listClass.getMethod("add", Object.class);
        addMethod.invoke(list2, "hello");
        addMethod.invoke(list2, "world");
        System.out.println("list2: " + list2);
        System.out.println("list2 size: " + ((ArrayList<?>) list2).size());

        // 4. 调用静态方法
        Method valueOf = Integer.class.getMethod("valueOf", String.class);
        Integer num = (Integer) valueOf.invoke(null, "42");
        System.out.println("Integer.valueOf(\"42\") = " + num);

        // 5. 调用私有方法
        Method privateMethod = String.class.getDeclaredMethod("isLatin1");
        privateMethod.setAccessible(true);
        boolean isLatin1 = (boolean) privateMethod.invoke("abc");
        System.out.println("\"abc\".isLatin1() = " + isLatin1);
    }
}

5.5 示例 4：读写私有字段

// file: AccessPrivateFieldDemo.java
import java.lang.reflect.*;
import java.util.*;

public class AccessPrivateFieldDemo {
    public static void main(String[] args) throws Exception {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));

        // ArrayList 内部使用 Object[] elementData 存储数据
        Field elementDataField = ArrayList.class.getDeclaredField("elementData");
        elementDataField.setAccessible(true);
        Object[] elementData = (Object[]) elementDataField.get(list);

        System.out.println("elementData 实际容量: " + elementData.length);
        for (int i = 0; i < ((ArrayList<?>) list).size(); i++) {
            System.out.println("  [" + i + "] = " + elementData[i]);
        }

        // 修改私有字段
        elementData[0] = "X";
        System.out.println("修改后 list: " + list);

        // 读取静态字段
        Field emptyListField = Collections.class.getDeclaredField("EMPTY_LIST");
        emptyListField.setAccessible(true);
        Object emptyList = emptyListField.get(null);
        System.out.println("Collections.EMPTY_LIST: " + emptyList);
    }
}

5.6 示例 5：动态代理（JDK Proxy）

// file: DynamicProxyDemo.java
import java.lang.reflect.*;
import java.util.*;

interface UserService {
    String getUserName(Long id);
    void deleteUser(Long id);
}

class UserServiceImpl implements UserService {
    public String getUserName(Long id) {
        System.out.println("  [UserServiceImpl] getUserName(" + id + ")");
        return "用户-" + id;
    }

    public void deleteUser(Long id) {
        System.out.println("  [UserServiceImpl] deleteUser(" + id + ")");
    }
}

class LoggingHandler implements InvocationHandler {
    private final Object target;

    public LoggingHandler(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("[LOG] 调用 " + method.getName() + "(" + Arrays.toString(args) + ")");
        long start = System.nanoTime();
        try {
            Object result = method.invoke(target, args);
            long elapsed = System.nanoTime() - start;
            System.out.println("[LOG] " + method.getName() + " 返回 " + result + "（耗时 " + elapsed + " ns）");
            return result;
        } catch (InvocationTargetException e) {
            long elapsed = System.nanoTime() - start;
            System.out.println("[LOG] " + method.getName() + " 抛出 " + e.getCause() + "（耗时 " + elapsed + " ns）");
            throw e.getCause();
        }
    }
}

public class DynamicProxyDemo {
    public static void main(String[] args) {
        UserService realService = new UserServiceImpl();

        UserService proxy = (UserService) Proxy.newProxyInstance(
                UserService.class.getClassLoader(),
                new Class<?>[] { UserService.class },
                new LoggingHandler(realService));

        System.out.println("代理类: " + proxy.getClass().getName());

        String name = proxy.getUserName(42L);
        System.out.println("返回值: " + name + "\n");

        proxy.deleteUser(99L);
    }
}

编译运行：

javac DynamicProxyDemo.java
java DynamicProxyDemo

5.7 示例 6：注解的读取与处理

// file: AnnotationDemo.java
import java.lang.annotation.*;
import java.lang.reflect.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Table {
    String name();
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Column {
    String name();

    boolean nullable() default true;
}

@Table(name = "users")
class User {
    @Column(name = "id", nullable = false)
    private Long id;

    @Column(name = "username", nullable = false)
    private String username;

    @Column(name = "email")
    private String email;

    public User(Long id, String username, String email) {
        this.id = id;
        this.username = username;
        this.email = email;
    }
}

public class AnnotationDemo {
    public static String generateSelectSQL(Class<?> entityClass) {
        Table table = entityClass.getAnnotation(Table.class);
        if (table == null) {
            throw new IllegalArgumentException("类未标注 @Table");
        }

        StringBuilder sql = new StringBuilder("SELECT ");
        StringBuilder columns = new StringBuilder();

        for (Field f : entityClass.getDeclaredFields()) {
            Column col = f.getAnnotation(Column.class);
            if (col != null) {
                if (columns.length() > 0) columns.append(", ");
                columns.append(col.name());
            }
        }

        sql.append(columns).append(" FROM ").append(table.name());
        return sql.toString();
    }

    public static void main(String[] args) {
        String sql = generateSelectSQL(User.class);
        System.out.println("生成的 SQL: " + sql);

        // 输出每个字段的列信息
        System.out.println("\n字段映射:");
        for (Field f : User.class.getDeclaredFields()) {
            Column col = f.getAnnotation(Column.class);
            if (col != null) {
                System.out.printf("  %s -> 列 %s (nullable=%s)%n",
                        f.getName(), col.name(), col.nullable());
            }
        }
    }
}

5.8 示例 7：泛型类型信息恢复

// file: GenericTypeDemo.java
import java.lang.reflect.*;
import java.util.*;

class GenericBox<T extends Number> {
    private T value;

    public GenericBox(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

public class GenericTypeDemo {
    public static void main(String[] args) throws Exception {
        GenericBox<Integer> box = new GenericBox<>(42);

        // 擦除后的 Class
        Class<?> erasedClass = box.getClass();
        System.out.println("擦除后类型: " + erasedClass.getName());
        // value 字段的擦除类型
        Field valueField = erasedClass.getDeclaredField("value");
        System.out.println("value 字段擦除类型: " + valueField.getType().getName());

        // 泛型签名（Type）
        Type genericType = valueField.getGenericType();
        System.out.println("value 字段泛型类型: " + genericType.getTypeName() + " (class: " + genericType.getClass().getSimpleName() + ")");

        // 类的类型变量
        TypeVariable<?>[] typeParams = erasedClass.getTypeParameters();
        System.out.println("\n类的类型参数:");
        for (TypeVariable<?> tv : typeParams) {
            System.out.println("  " + tv.getName() + " bounds: " + Arrays.toString(tv.getBounds()));
        }

        // 演示 ParameterizedType
        Map<String, List<Integer>> map = new HashMap<>();
        Class<?> mapClass = map.getClass();
        // 演示通过子类捕获泛型签名
        Type superType = HashMap.class.getGenericSuperclass();
        System.out.println("\nHashMap 父类: " + superType);

        // 通过匿名子类捕获泛型（Type Reference 技巧）
        TypeReference<Map<String, List<Integer>>> typeRef = new TypeReference<>() {};
        Type capturedType = typeRef.getType();
        System.out.println("捕获的泛型类型: " + capturedType.getTypeName());

        if (capturedType instanceof ParameterizedType pt) {
            System.out.println("原始类型: " + pt.getRawType().getTypeName());
            System.out.println("类型参数:");
            for (Type arg : pt.getActualTypeArguments()) {
                System.out.println("  " + arg.getTypeName());
            }
        }
    }

    static abstract class TypeReference<T> {
        private final Type type;

        protected TypeReference() {
            Type superClass = getClass().getGenericSuperclass();
            if (superClass instanceof ParameterizedType pt) {
                this.type = pt.getActualTypeArguments()[0];
            } else {
                throw new IllegalArgumentException("缺少类型参数");
            }
        }

        public Type getType() {
            return type;
        }
    }
}

5.9 示例 8：MethodHandle 替代反射

// file: MethodHandleDemo.java
import java.lang.invoke.*;
import java.lang.reflect.Method;

public class MethodHandleDemo {
    public static void main(String[] args) throws Throwable {
        // 用反射获取 Method
        Method parseInt = Integer.class.getMethod("parseInt", String.class);

        // 方法 1：直接反射调用
        long start1 = System.nanoTime();
        int sum1 = 0;
        for (int i = 0; i < 1_000_000; i++) {
            sum1 += (int) parseInt.invoke(null, "42");
        }
        long elapsed1 = System.nanoTime() - start1;
        System.out.println("反射调用 100 万次: " + (elapsed1 / 1_000_000) + " ms, sum=" + sum1);

        // 方法 2：MethodHandle
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodHandle mh = lookup.findStatic(Integer.class, "parseInt",
                MethodType.methodType(int.class, String.class));

        long start2 = System.nanoTime();
        int sum2 = 0;
        for (int i = 0; i < 1_000_000; i++) {
            sum2 += (int) mh.invokeExact("42");
        }
        long elapsed2 = System.nanoTime() - start2;
        System.out.println("MethodHandle 100 万次: " + (elapsed2 / 1_000_000) + " ms, sum=" + sum2);

        // 方法 3：直接调用基准
        long start3 = System.nanoTime();
        int sum3 = 0;
        for (int i = 0; i < 1_000_000; i++) {
            sum3 += Integer.parseInt("42");
        }
        long elapsed3 = System.nanoTime() - start3;
        System.out.println("直接调用 100 万次: " + (elapsed3 / 1_000_000) + " ms, sum=" + sum3);
    }
}

5.10 示例 9：模块系统下的反射开放

在 JDK 9+ 模块系统中，跨模块反射需要显式 --add-opens：

// file: ModuleReflectionDemo.java
public class ModuleReflectionDemo {
    public static void main(String[] args) throws Exception {
        // 尝试反射 java.util.ArrayList 的私有字段
        Class<?> arrayListClass = Class.forName("java.util.ArrayList");
        var field = arrayListClass.getDeclaredField("elementData");
        try {
            field.setAccessible(true);
            System.out.println("setAccessible 成功");
        } catch (InaccessibleObjectException e) {
            System.out.println("setAccessible 失败: " + e.getMessage());
            System.out.println("请使用: --add-opens java.base/java.util=ALL-UNNAMED");
        }
    }
}

编译并尝试运行（不带开放参数）：

javac ModuleReflectionDemo.java
java ModuleReflectionDemo
# JDK 16+ 应输出 setAccessible 失败

带开放参数运行：

java --add-opens java.base/java.util=ALL-UNNAMED ModuleReflectionDemo
# 应输出 setAccessible 成功

5.11 示例 10：反射性能基准

// file: ReflectionBenchmark.java
import java.lang.invoke.*;
import java.lang.reflect.*;

public class ReflectionBenchmark {
    interface StringParser {
        int parse(String s);
    }

    public static void main(String[] args) throws Throwable {
        int warmup = 50_000;
        int iterations = 5_000_000;
        String input = "12345";

        // 1. 直接调用
        long direct = 0;
        for (int i = 0; i < warmup; i++) {
            Integer.parseInt(input);
        }
        long s1 = System.nanoTime();
        int sum1 = 0;
        for (int i = 0; i < iterations; i++) {
            sum1 += Integer.parseInt(input);
        }
        direct = System.nanoTime() - s1;

        // 2. 反射调用
        Method method = Integer.class.getMethod("parseInt", String.class);
        method.setAccessible(true); // 跳过访问检查
        for (int i = 0; i < warmup; i++) {
            method.invoke(null, input);
        }
        long s2 = System.nanoTime();
        int sum2 = 0;
        for (int i = 0; i < iterations; i++) {
            sum2 += (int) method.invoke(null, input);
        }
        long reflect = System.nanoTime() - s2;

        // 3. MethodHandle
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodHandle mh = lookup.findStatic(Integer.class, "parseInt",
                MethodType.methodType(int.class, String.class));
        for (int i = 0; i < warmup; i++) {
            mh.invokeExact(input);
        }
        long s3 = System.nanoTime();
        int sum3 = 0;
        for (int i = 0; i < iterations; i++) {
            sum3 += (int) mh.invokeExact(input);
        }
        long mhTime = System.nanoTime() - s3;

        // 4. LambdaMetafactory
        CallSite cs = LambdaMetafactory.metafactory(
                lookup,
                "parse",
                MethodType.methodType(StringParser.class),
                MethodType.methodType(int.class, String.class),
                mh,
                MethodType.methodType(int.class, String.class));
        StringParser parser = (StringParser) cs.getTarget().invokeExact();
        for (int i = 0; i < warmup; i++) {
            parser.parse(input);
        }
        long s4 = System.nanoTime();
        int sum4 = 0;
        for (int i = 0; i < iterations; i++) {
            sum4 += parser.parse(input);
        }
        long lambdaTime = System.nanoTime() - s4;

        System.out.println("iterations: " + iterations);
        System.out.printf("直接调用:   %6.2f ms (sum=%d)%n", direct / 1e6, sum1);
        System.out.printf("反射调用:   %6.2f ms (sum=%d)  倍数: %.2fx%n", reflect / 1e6, sum2, (double) reflect / direct);
        System.out.printf("MethodHandle: %6.2f ms (sum=%d)  倍数: %.2fx%n", mhTime / 1e6, sum3, (double) mhTime / direct);
        System.out.printf("Lambda:      %6.2f ms (sum=%d)  倍数: %.2fx%n", lambdaTime / 1e6, sum4, (double) lambdaTime / direct);
    }
}

预期结果（JDK 17， warmed up）：

iterations: 5000000
直接调用:      ~15 ms (sum=6172500000)
反射调用:      ~150 ms (sum=6172500000)  倍数: ~10x
MethodHandle:  ~20 ms (sum=6172500000)  倍数: ~1.3x
Lambda:        ~15 ms (sum=6172500000)  倍数: ~1.0x

6. 对比分析：Java 反射 vs 其他语言元编程

6.1 总体对比表

6.2 Java vs C# 反射

C# 反射（System.Reflection）与 Java 反射在设计上有显著相似性，但有几个关键差异：

6.2.1 Reified Generics（具体化泛型）

C# 的泛型在运行时是 具体化（reified） 的——List<int> 与 List<string> 是不同的类型，运行时可获取泛型参数。Java 的泛型是擦除的，反射只能通过 Signature 属性间接获取泛型签名。

// C# 代码
Type t = typeof(List<int>);
Console.WriteLine(t.GetGenericArguments()[0].Name); // 输出 "Int32"

// Java 代码
Class<?> c = List.class; // List<Integer>.class 不存在
System.out.println(c.getTypeParameters()[0].getName()); // 输出 "E"

6.2.2 Reflection.Emit 动态生成类型

C# 提供了 System.Reflection.Emit 命名空间，允许在运行时生成新的类型、方法、IL 指令。Java 没有等价的官方 API，需借助 ASM、ByteBuddy 等第三方库。

6.2.3 性能

C# 反射在 .NET Core 3.0+ 后引入了”动态方法委托缓存”，性能与 Java 反射的 Inflation 机制类似。但 C# 的 MethodInfo.CreateDelegate 比反射调用快 5–10 倍，类似于 Java 的 MethodHandle。

6.3 Java vs Kotlin 反射

Kotlin 提供了独立的反射库 kotlin-reflect，对 Java 反射做了若干改进：

• KClass：Kotlin 类的元对象，比 Java Class 多了 isData、isSealed、isCompanion 等属性。
• KProperty：Kotlin 属性（带 backing field 的 getter/setter），比 Java 反射分别处理 Field/Method 更内聚。
• 可空类型信息：Kotlin 反射能区分 String 与 String?，Java 反射无法区分（编译后都是 String）。

// Kotlin 代码
data class Person(val name: String, val age: Int)

val kClass = Person::class
println(kClass.isData) // true
println(kClass.primaryConstructor?.parameters?.map { it.type }) // [String, Int]

代价是 kotlin-reflect 库体积较大（约 3MB），且首次调用有初始化开销。

6.4 Java vs Scala 反射

Scala 反射分为两层：

• 运行时反射（scala.reflect.runtime.universe）：基于 Java 反射，提供 Scala 特有的类型信息（如 Case Class、Trait、Higher-Kinded Type）。
• 编译期反射（macros、TASTY）：在编译时操作 AST，零运行时开销。

Scala 的反射 API 比 Java 复杂得多，但能处理 Java 反射无法表达的高阶类型。性能上，Scala 反射比 Java 反射慢 2–5 倍（由于类型系统的额外抽象层）。

6.5 Java vs Go 反射

Go 反射（reflect 包）设计哲学与 Java 完全不同：

• 无注解：Go 无原生注解概念，使用 struct tag 模拟，反射通过 Field.Tag.Get("json") 读取。
• 无类继承：Go 无类继承，反射只需处理 struct、interface、指针、channel 等类型。
• 性能：Go 反射比 Java 慢得多——每次 reflect.Value.MethodByName 都需要遍历方法表，没有 Java 的 Inflation 优化。
• 类型断言优于反射：Go 推荐优先使用类型断言（v, ok := x.(T)）而非反射，类型断言零开销。

// Go 代码
type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

t := reflect.TypeOf(User{})
f, _ := t.FieldByName("Name")
fmt.Println(f.Tag.Get("json")) // 输出 "name"

6.6 Java vs Python 内省

Python 反射（getattr、setattr、inspect 模块）是 干预式 MOP 的典型代表：

• 运行时修改类：Python 允许运行时给类添加方法、字段，甚至改变继承关系（class.__bases__）。
• 无类型检查：Python 反射调用任意方法无需类型检查，鸭子类型即可。
• 元类（metaclass）：Python 元类能在类创建时介入，是反射的极致形态。
• 性能：Python 反射与直接调用性能接近（差异 < 20%），因为 Python 本身就是动态语言。

# Python 代码
class User:
    def __init__(self, name):
        self.name = name

u = User("Alice")
# 动态添加方法
def greet(self):
    return f"Hello, {self.name}"

User.greet = greet
print(u.greet())  # Hello, Alice

6.7 选型建议

7. 常见陷阱与反模式

7.1 反模式 1：在热点路径中使用反射

问题描述：在请求处理循环中反复使用 Class.forName + getMethod，导致性能瓶颈。

反模式代码：

// 反模式
public class BadRouter {
    public void handle(String path, Object[] args) throws Exception {
        String className = "com.example.handlers." + pathToClassName(path);
        Class<?> clazz = Class.forName(className);
        Method handler = clazz.getMethod("handle", Object[].class);
        Object instance = clazz.getDeclaredConstructor().newInstance();
        handler.invoke(instance, args);
    }
}

问题分析：

• Class.forName 每次都触发类加载查找（即使已加载，也要经过类加载器命名空间检查）。
• getMethod 每次都遍历方法表。
• newInstance 每次都调用构造器。

正确做法：

// 正确做法：缓存 Class、Method、实例
public class GoodRouter {
    private static final Map<String, Method> METHOD_CACHE = new ConcurrentHashMap<>();
    private static final Map<String, Object> INSTANCE_CACHE = new ConcurrentHashMap<>();

    public void handle(String path, Object[] args) throws Exception {
        Method handler = METHOD_CACHE.computeIfAbsent(path, k -> {
            try {
                String className = "com.example.handlers." + pathToClassName(k);
                Class<?> clazz = Class.forName(className);
                Object instance = clazz.getDeclaredConstructor().newInstance();
                INSTANCE_CACHE.put(k, instance);
                return clazz.getMethod("handle", Object[].class);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
        handler.invoke(INSTANCE_CACHE.get(path), args);
    }
}

7.2 反模式 2：滥用 setAccessible(true) 绕过封装

问题描述：在生产代码中频繁调用 setAccessible(true) 读写第三方库的私有字段，导致升级时出现兼容性问题。

反模式代码：

// 反模式：直接读 ArrayList 的私有字段
public int getArrayListCapacity(ArrayList<?> list) {
    try {
        Field f = ArrayList.class.getDeclaredField("elementData");
        f.setAccessible(true);
        return ((Object[]) f.get(list)).length;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

问题分析：

• 第三方库升级后字段名、类型可能变化，导致代码失效。
• JDK 9+ 模块系统下，setAccessible 可能被拒绝（InaccessibleObjectException）。
• 反射读写私有字段绕过了 JDK 的安全模型。

正确做法：

// 正确做法：使用 public API
public int getArrayListCapacity(ArrayList<?> list) {
    return list.size(); // 或者用反射但封装在工具类，且做版本探测
}

// 如果确实需要，封装在工具类并明确版本兼容性
public class ArrayListReflectionUtils {
    private static final Field ELEMENT_DATA_FIELD;
    static {
        try {
            ELEMENT_DATA_FIELD = ArrayList.class.getDeclaredField("elementData");
            ELEMENT_DATA_FIELD.setAccessible(true);
        } catch (NoSuchFieldException e) {
            throw new RuntimeException("ArrayList 结构变化，请检查 JDK 版本", e);
        }
    }
    public static int getCapacity(ArrayList<?> list) {
        try {
            return ((Object[]) ELEMENT_DATA_FIELD.get(list)).length;
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

7.3 反模式 3：忽略 InvocationTargetException

问题描述：反射调用抛出的 InvocationTargetException 包装了目标方法的真实异常，但开发者直接 catch 并忽略，导致异常信息丢失。

反模式代码：

// 反模式
try {
    method.invoke(target, args);
} catch (Exception e) {
    e.printStackTrace(); // 看不到真实异常
}

正确做法：

try {
    method.invoke(target, args);
} catch (InvocationTargetException e) {
    Throwable cause = e.getCause(); // 真实异常
    throw cause; // 重新抛出真实异常
} catch (ReflectiveOperationException e) {
    throw new RuntimeException("反射调用失败", e);
}

7.4 反模式 4：反射构造对象时忽略异常

问题描述：clazz.newInstance()（已弃用）会吞掉构造器抛出的受检异常，导致问题难追踪。JDK 9+ 已弃用 newInstance()，推荐 getDeclaredConstructor().newInstance()。

反模式代码：

// 反模式（已弃用）
Object obj = clazz.newInstance();

正确做法：

// 正确做法
Object obj = clazz.getDeclaredConstructor().newInstance();
// 这会抛出 InvocationTargetException，能正确传播构造器异常

7.5 反模式 5：在静态初始化器中使用反射

问题描述：在 static {} 块中调用 Class.forName 或反射初始化字段，会导致类初始化变慢，且异常会触发 ExceptionInInitializerError，难以处理。

反模式代码：

// 反模式
public class BadConfig {
    private static final Handler HANDLER;
    static {
        try {
            Class<?> clazz = Class.forName(System.getProperty("handler.class"));
            HANDLER = (Handler) clazz.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
    }
}

正确做法：使用懒加载（懒汉单例）或工厂方法，避免静态初始化器中的反射。

7.6 反模式 6：泛型类型推断误用

问题描述：误以为 List<String>.class 存在，或误以为 Method.getReturnType() 能返回泛型参数。

反模式代码：

// 反模式：编译错误
Class<List<String>> c = List<String>.class; // 编译错误

// 反模式：误解泛型
Method m = ArrayList.class.getMethod("get", int.class);
Class<?> returnType = m.getReturnType();
// returnType 是 Object，不是 String

正确做法：

// 正确：使用 Class<List> 或 TypeReference
Class<List> rawClass = List.class;
// 或者通过子类捕获泛型

7.7 反模式 7：忽略模块系统的 opens 约束

问题描述：JDK 9+ 后，跨模块反射需要 --add-opens 或模块描述符中声明 opens。生产环境部署时未配置，导致运行时 InaccessibleObjectException。

正确做法：

1. 在 module-info.java 中声明 opens：

   module com.example.app {
       opens com.example.app.domain to spring.core;
   }

2. 或在启动参数中添加 --add-opens：

   java --add-opens java.base/java.util=ALL-UNNAMED --add-opens java.base/java.lang=ALL-UNNAMED -jar app.jar

3. 使用 Module API 编程式开放（仅限同模块）。

7.8 反模式 8：动态代理泄漏

问题描述：Proxy.newProxyInstance 生成的代理类会一直存活在 ProxyCache 中，类加载器无法回收，导致内存泄漏（特别是在频繁创建临时类加载器的场景）。

正确做法：

• 重用代理实例而非每次新建。
• 使用 WeakReference 持有代理。
• 考虑 CGLIB 或 ByteBuddy，它们的类缓存机制更可控。

7.9 反模式 9：误用 Class.isInstance 与 instanceof

// instanceof 在编译期检查类型
if (obj instanceof String) { ... }

// isInstance 在运行期检查，等价于 instanceof 但更灵活
if (String.class.isInstance(obj)) { ... }

// 反模式：误以为 isInstance 等价于 isAssignableFrom
Class<?> c = String.class;
Object o = new Object();
if (c.isInstance(o)) { ... } // false
if (c.isAssignableFrom(o.getClass())) { ... } // false，Object 不是 String
if (o.getClass().isAssignableFrom(c)) { ... } // true，Object 是 String 的父类

7.10 反模式 10：忽视反射的线程安全

Class、Method、Field 等反射对象本身是线程安全的（不可变），但 Method.invoke 调用的目标方法可能不是线程安全的。常见误解：

// 误以为反射调用是线程安全的
Method m = SomeClass.class.getMethod("increment");
Field counterField = SomeClass.class.getDeclaredField("counter");
counterField.setAccessible(true);

// 多线程并发调用，即使有反射，目标方法仍需同步
m.invoke(target); // 内部可能读写非线程安全字段

8. 工程实践与最佳实践

8.1 反射性能优化策略

8.1.1 缓存反射对象

public class ReflectionCache {
    private static final ConcurrentHashMap<String, Method> METHOD_CACHE = new ConcurrentHashMap<>();

    public static Method getMethod(Class<?> clazz, String name, Class<?>... paramTypes) {
        String key = clazz.getName() + "#" + name + Arrays.toString(paramTypes);
        return METHOD_CACHE.computeIfAbsent(key, k -> {
            try {
                Method m = clazz.getDeclaredMethod(name, paramTypes);
                m.setAccessible(true);
                return m;
            } catch (NoSuchMethodException e) {
                throw new RuntimeException(e);
            }
        });
    }
}

8.1.2 使用 MethodHandle 替代高频反射调用

public class MethodHandleCache {
    private static final ConcurrentHashMap<String, MethodHandle> MH_CACHE = new ConcurrentHashMap<>();

    public static MethodHandle get(Class<?> clazz, String name, MethodType type) {
        String key = clazz.getName() + "#" + name + type.toMethodDescriptorString();
        return MH_CACHE.computeIfAbsent(key, k -> {
            try {
                MethodHandles.Lookup lookup = MethodHandles.lookup();
                return lookup.findVirtual(clazz, name, type);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
    }
}

8.1.3 使用 LambdaMetafactory 实现近乎零开销的反射

public class LambdaFactory {
    public static <T> T createFactory(Method method, Class<T> functionalInterface) throws Throwable {
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodHandle mh = lookup.unreflect(method);
        MethodType instantiatedMethodType = mh.type();
        MethodType samMethodType = instantiatedMethodType.dropParameterTypes(0, 1);

        CallSite cs = LambdaMetafactory.metafactory(
                lookup,
                getSamMethodName(functionalInterface),
                MethodType.methodType(functionalInterface),
                samMethodType,
                mh,
                samMethodType);
        return functionalInterface.cast(cs.getTarget().invoke());
    }

    private static String getSamMethodName(Class<?> fi) {
        for (Method m : fi.getMethods()) {
            if (m.isDefault()) continue;
            if (!Modifier.isStatic(m.getModifiers())) {
                return m.getName();
            }
        }
        throw new IllegalArgumentException("未找到 SAM 方法");
    }
}

8.2 反射与 AOP 切面

// 简化的 AOP 切面实现
public class SimpleAOP {
    public static <T> T wrap(T target, MethodInterceptor interceptor) {
        return (T) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    return interceptor.intercept(target, method, args, () -> method.invoke(target, args));
                });
    }

    @FunctionalInterface
    public interface MethodInterceptor {
        Object intercept(Object target, Method method, Object[] args, Callable<?> superCall) throws Throwable;
    }

    @FunctionalInterface
    public interface Callable<T> {
        T call() throws Throwable;
    }
}

8.3 反射在配置系统中的应用

// 基于注解的配置绑定
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface ConfigKey {
    String value();
    String defaultValue() default "";
}

class AppConfig {
    @ConfigKey(value = "app.port", defaultValue = "8080")
    private int port;

    @ConfigKey(value = "app.host", defaultValue = "localhost")
    private String host;

    @ConfigKey(value = "app.debug", defaultValue = "false")
    private boolean debug;
}

public class ConfigBinder {
    public static void bind(Object config, Map<String, String> properties) throws Exception {
        for (Field f : config.getClass().getDeclaredFields()) {
            ConfigKey key = f.getAnnotation(ConfigKey.class);
            if (key == null) continue;

            String value = properties.getOrDefault(key.value(), key.defaultValue());
            Object converted = convert(value, f.getType());
            f.setAccessible(true);
            f.set(config, converted);
        }
    }

    private static Object convert(String value, Class<?> type) {
        if (type == int.class || type == Integer.class) return Integer.parseInt(value);
        if (type == long.class || type == Long.class) return Long.parseLong(value);
        if (type == boolean.class || type == Boolean.class) return Boolean.parseBoolean(value);
        if (type == String.class) return value;
        throw new IllegalArgumentException("不支持的类型: " + type);
    }
}

8.4 反射工具类设计原则

设计企业级反射工具类时，应遵循以下原则：

1. 统一异常处理：将反射 API 的受检异常包装为运行时异常，简化调用方代码。
2. 缓存策略：所有反射对象（Class、Method、Field）必须缓存，避免重复查找。
3. 类型安全：通过泛型约束减少调用方的强制类型转换。
4. 可观测性：提供统计接口，输出缓存命中率、反射调用次数等指标。
5. 可关闭性：在低权限环境（如安全管理器启用）下能优雅降级。

public final class ReflectionUtils {
    private static final ConcurrentHashMap<String, Method> METHODS = new ConcurrentHashMap<>();
    private static final ConcurrentHashMap<String, Field> FIELDS = new ConcurrentHashMap<>();
    private static final ConcurrentHashMap<String, Constructor<?>> CTORS = new ConcurrentHashMap<>();

    private ReflectionUtils() {}

    public static Method findMethod(Class<?> clazz, String name, Class<?>... paramTypes) {
        String key = clazz.getName() + "#" + name + Arrays.toString(paramTypes);
        return METHODS.computeIfAbsent(key, k -> {
            try {
                Method m = clazz.getDeclaredMethod(name, paramTypes);
                m.setAccessible(true);
                return m;
            } catch (NoSuchMethodException e) {
                throw new IllegalArgumentException("方法不存在: " + k, e);
            }
        });
    }

    public static Object invokeMethod(Object target, String methodName, Object... args) {
        Class<?>[] paramTypes = Arrays.stream(args).map(Object::getClass).toArray(Class<?>[]::new);
        Method m = findMethod(target.getClass(), methodName, paramTypes);
        try {
            return m.invoke(target, args);
        } catch (InvocationTargetException e) {
            throw new RuntimeException("方法调用失败: " + methodName, e.getCause());
        } catch (IllegalAccessException e) {
            throw new RuntimeException("方法访问失败: " + methodName, e);
        }
    }
}

8.5 模块系统下的反射兼容策略

JDK 9+ 模块系统引入后，框架需要显式声明对目标模块的开放。三种策略：

策略 1：在 module-info.java 中显式 opens

module com.example.app {
    requires spring.core;
    opens com.example.app.domain to spring.core;
    opens com.example.app.service;
}

策略 2：使用启动参数 --add-opens

java --add-opens java.base/java.lang=ALL-UNNAMED \
     --add-opens java.base/java.util=ALL-UNNAMED \
     -jar app.jar

策略 3：编程式开放（仅限同模块）

Module targetModule = AppConfig.class.getModule();
if (!targetModule.isOpen("com.example.app.domain")) {
    // 无 API 直接开放，只能通过 --add-opens 启动参数
}

8.6 反射与序列化框架的协作

JSON 序列化框架（如 Jackson）使用反射的常见模式：

public class SimpleJsonSerializer {
    public String serialize(Object obj) throws Exception {
        StringBuilder sb = new StringBuilder("{");
        Field[] fields = obj.getClass().getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            if (i > 0) sb.append(", ");
            Field f = fields[i];
            f.setAccessible(true);
            sb.append("\"").append(f.getName()).append("\": ");
            Object value = f.get(obj);
            if (value instanceof String) {
                sb.append("\"").append(value).append("\"");
            } else {
                sb.append(value);
            }
        }
        sb.append("}");
        return sb.toString();
    }
}

工程级实现需考虑：

• 缓存 Field 数组
• 处理循环引用
• 自定义序列化注解（@JsonSerialize）
• 处理 null、日期、嵌套对象

9. 案例研究

9.1 案例研究 1：Spring Framework 的反射使用

Spring Framework 是反射的重度使用者。以下分析其核心反射使用点。

9.1.1 IoC 容器的 Bean 创建

org.springframework.beans.factory.support.SimpleInstantiationStrategy 使用反射创建 Bean 实例：

// Spring 源码简化版
public class SimpleInstantiationStrategy {
    public Object instantiate(RootBeanDefinition bd, Constructor<?> ctor, Object[] args) {
        if (ctor == null) {
            // 无参构造
            return BeanUtils.instantiateClass(bd.getBeanClass());
        } else {
            // 有参构造
            return BeanUtils.instantiateClass(ctor, args);
        }
    }
}

public abstract class BeanUtils {
    public static <T> T instantiateClass(Constructor<T> ctor, Object... args) {
        ReflectionUtils.makeAccessible(ctor);
        return ctor.newInstance(args); // Kotlin 友好版本会调用 Kotlin 反射
    }
}

9.1.2 @Autowired 注入

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor 通过反射注入依赖：

// Spring 源码简化版
public class AutowiredAnnotationBeanPostProcessor {
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass());
        metadata.inject(bean, beanName, pvs);
        return pvs;
    }
}

class InjectionMetadata {
    void inject(Object target, String beanName, PropertyValues pvs) {
        for (InjectedElement element : this.injectedElements) {
            element.inject(target, beanName, pvs);
        }
    }
}

class AutowiredFieldElement extends InjectedElement {
    protected void inject(Object target, String requestingBeanName, PropertyValues pvs) {
        Field field = (Field) this.member;
        Object value = beanFactory.resolveDependency(field, requestingBeanName);
        ReflectionUtils.makeAccessible(field);
        field.set(target, value);
    }
}

9.1.3 AOP 动态代理

Spring AOP 使用 JDK Proxy（接口代理）或 CGLIB（类代理）：

// Spring 源码简化版
public class DefaultAopProxyFactory {
    public AopProxy createAopProxy(AdvisedSupport config) {
        if (config.isOptimize() || config.isProxyTargetClass()
                || hasNoUserSuppliedProxyInterfaces(config)) {
            return new CglibAopProxy(config); // 类代理
        } else {
            return new JdkDynamicAopProxy(config); // 接口代理
        }
    }
}

class JdkDynamicAopProxy implements InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
        return invocation.proceed(); // 执行切面链
    }
}

9.2 案例研究 2：MyBatis 的反射映射

MyBatis 通过反射将数据库结果集映射到 Java 对象：

// MyBatis 源码简化版
public class DefaultResultSetHandler {
    private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
        Object resultObject = createResultObject(rsw, resultMap);
        applyAutomaticMappings(rsw, resultMap, resultObject);
        applyPropertyMappings(rsw, resultMap, resultObject);
        return resultObject;
    }

    private void applyPropertyMappings(ResultSetWrapper rsw, ResultMap resultMap, Object resultObject) {
        for (ResultMapping propertyMapping : resultMap.getPropertyResultMappings()) {
            String property = propertyMapping.getProperty();
            Class<?> propertyType = objectFactory.getClass(propertyMapping.getJavaType());
            Object value = getResultSetValue(rsw, propertyMapping);
            // 通过反射设置属性
            MetaObject metaObject = configuration.newObjectWrapper(resultObject);
            metaObject.setValue(property, value);
        }
    }
}

MetaObject 内部使用 Reflector 类缓存类的 getter/setter 方法：

public class Reflector {
    private final Class<?> type;
    private final Map<String, Method> getMethods = new HashMap<>();
    private final Map<String, Method> setMethods = new HashMap<>();
    private final Map<String, Class<?>> getTypes = new HashMap<>();
    private final Map<String, Class<?>> setTypes = new HashMap<>();

    public Reflector(Class<?> clazz) {
        this.type = clazz;
        addGetMethods(clazz); // 反射获取所有 getter
        addSetMethods(clazz); // 反射获取所有 setter
        addFields(clazz); // 反射获取所有字段
    }
}

9.3 案例研究 3：Hibernate 的实体管理

Hibernate 使用反射读写实体字段，实现脏检查（dirty checking）：

// Hibernate 源码简化版
public class PojoEntityTuplizer implements EntityTuplizer {
    private final EntityMetamodel entityMetamodel;
    private final Getter[] getters;
    private final Setter[] setters;

    public Object[] getPropertyValues(Object entity) {
        Object[] values = new Object[getters.length];
        for (int i = 0; i < getters.length; i++) {
            values[i] = getters[i].get(entity); // 反射调用 getter
        }
        return values;
    }

    public void setPropertyValues(Object entity, Object[] values) {
        for (int i = 0; i < setters.length; i++) {
            setters[i].set(entity, values[i], null); // 反射调用 setter
        }
    }
}

Hibernate 还使用字节码增强（Bytecode Enhancement）替代反射，以提升性能——通过 ASM 在编译期或加载期生成直接的 getter/setter 调用代码。

9.4 案例研究 4：JUnit 的测试方法发现

// JUnit 5 源码简化版
public class JUnit5TestDiscovery {
    public List<Method> findTestMethods(Class<?> testClass) {
        List<Method> methods = new ArrayList<>();
        for (Method m : testClass.getDeclaredMethods()) {
            if (m.isAnnotationPresent(Test.class)) {
                methods.add(m);
            }
            if (m.isAnnotationPresent(ParameterizedTest.class)) {
                methods.add(m);
            }
        }
        return methods;
    }
}

9.5 案例研究 5：Hadoop 的反射序列化

Hadoop 使用反射实现 Writable 接口的序列化：

public class WritableSerializer {
    public byte[] serialize(Writable writable) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream dataOut = new DataOutputStream(out);
        writable.write(dataOut); // 反射调用具体类型的 write 方法
        return out.toByteArray();
    }

    public <T extends Writable> T deserialize(Class<T> clazz, byte[] bytes) throws IOException {
        try {
            T instance = clazz.getDeclaredConstructor().newInstance(); // 反射构造
            instance.readFields(new DataInputStream(new ByteArrayInputStream(bytes)));
            return instance;
        } catch (Exception e) {
            throw new IOException("反序列化失败", e);
        }
    }
}

9.6 案例研究 6：Elasticsearch 的字段映射

public class ElasticsearchMapper {
    public Map<String, Object> toMap(Object document) throws Exception {
        Map<String, Object> result = new HashMap<>();
        for (Field f : document.getClass().getDeclaredFields()) {
            f.setAccessible(true);
            Object value = f.get(document);
            if (value != null) {
                result.put(f.getName(), convertToEsType(value));
            }
        }
        return result;
    }

    private Object convertToEsType(Object value) {
        if (value instanceof Date) {
            return ((Date) value).getTime();
        }
        if (value.getClass().isEnum()) {
            return ((Enum<?>) value).name();
        }
        return value;
    }
}

9.7 案例研究 7：Jackson 的 JSON 序列化

public class JacksonSerializer {
    private final ConcurrentHashMap<Class<?>, List<PropertyAccessor>> accessors = new ConcurrentHashMap<>();

    public String serialize(Object obj) throws Exception {
        List<PropertyAccessor> props = accessors.computeIfAbsent(obj.getClass(), this::buildAccessors);
        StringBuilder sb = new StringBuilder("{");
        for (int i = 0; i < props.size(); i++) {
            if (i > 0) sb.append(",");
            PropertyAccessor p = props.get(i);
            Object value = p.getter.invoke(obj);
            sb.append("\"").append(p.name).append("\":");
            sb.append(toJsonValue(value));
        }
        sb.append("}");
        return sb.toString();
    }

    private List<PropertyAccessor> buildAccessors(Class<?> clazz) {
        List<PropertyAccessor> list = new ArrayList<>();
        for (Field f : clazz.getDeclaredFields()) {
            if (Modifier.isStatic(f.getModifiers())) continue;
            if (f.isAnnotationPresent(JsonIgnore.class)) continue;
            f.setAccessible(true);
            list.add(new PropertyAccessor(f.getName(), f));
        }
        return list;
    }

    static class PropertyAccessor {
        final String name;
        final Field getter;
        PropertyAccessor(String name, Field getter) {
            this.name = name;
            this.getter = getter;
        }
    }
}

9.8 案例研究 8：字节码增强替代反射（ByteBuddy）

// ByteBuddy 创建运行时类
public class ByteBuddyDemo {
    public static void main(String[] args) throws Exception {
        Class<?> dynamicType = new ByteBuddy()
                .subclass(Object.class)
                .name("com.example.DynamicHello")
                .defineMethod("sayHello", String.class, Modifier.PUBLIC)
                .intercept(FixedValue.value("Hello from ByteBuddy!"))
                .make()
                .load(ByteBuddyDemo.class.getClassLoader())
                .getLoaded();

        Object instance = dynamicType.getDeclaredConstructor().newInstance();
        Method m = dynamicType.getMethod("sayHello");
        System.out.println(m.invoke(instance));
    }
}

字节码增强的优势：

• 生成的类与普通类无差别，JIT 可正常优化。
• 不需要每次调用都做反射检查。
• 适合在启动期生成代理类，运行期零开销。

9.9 案例研究 9：Lombok 与编译期注解处理器

Lombok 不使用反射，而是在编译期通过注解处理器修改 AST：

// Lombok 内部使用 javac API 修改 AST
public class GetterAnnotationProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
        for (Element e : env.getElementsAnnotatedWith(Getter.class)) {
            if (e.getKind() == ElementKind.FIELD) {
                addGetterMethod((TypeElement) e.getEnclosingElement(), (VariableElement) e);
            }
        }
        return true;
    }

    private void addGetterMethod(TypeElement clazz, VariableElement field) {
        // 修改 AST，添加 getter 方法
        // ...
    }
}

这种做法规避了反射的所有性能与安全问题，但牺牲了灵活性（编译期不能访问运行时数据）。

10. 习题与思考题

10.1 基础题（记忆与理解）

习题 1：写出获取 java.util.HashMap 的 Class 对象的三种方式。

参考答案：

Class<?> c1 = HashMap.class;
Class<?> c2 = new HashMap<>().getClass();
Class<?> c3 = Class.forName("java.util.HashMap");

习题 2：getFields() 与 getDeclaredFields() 的区别是什么？

参考答案：

• getFields()：返回所有 public 字段，包括继承自父类的。
• getDeclaredFields()：返回本类声明的所有字段（含 private、protected、包可见），不包括继承的。

习题 3：解释以下代码的输出：

List<Integer> list = new ArrayList<>();
Class<?> c1 = list.getClass();
Class<?> c2 = ArrayList.class;
Class<?> c3 = Class.forName("java.util.ArrayList");
System.out.println(c1 == c2);
System.out.println(c1 == c3);

参考答案：输出 true 和 true。Class 对象在 JVM 中全局唯一，泛型擦除使 List<Integer> 与 List<String> 共享同一个 Class。

10.2 应用题

习题 4：编写一个工具方法 copyProperties(Object source, Object target)，使用反射将 source 对象的同名字段值复制到 target 对象。