Java 反射深度解析：从原理到源码的全面剖析

一、引言：Java 的"照妖镜"

在 Java 的世界里，有一个特性让它区别于 C++ 等静态语言------反射（Reflection） 。它允许一个运行中的 Java 程序检查、修改自己内部的属性，这种能力也被称为"自省"（introspection）。

反射就像一面"照妖镜"------无论一个类多么封装严密，反射都能在运行时"看透"它的一切：方法、字段、构造器，甚至是私有的、受保护的成员。

核心定位：反射是 Java 语言动态性的基石，是 Spring、Hibernate、MyBatis 等所有主流框架的底层支撑。它让程序可以在运行时动态地获取类型信息、创建对象、调用方法、访问和修改属性。

本文将从反射的核心概念 → API 用法 → 底层 源码 → 性能优化 → 现代演进，层层递进，带你彻底搞懂 Java 反射。

二、什么是反射？

2.1 官方定义

Reflection is a feature in the Java programming language. It allows an executing Java program to examine or "introspect" upon itself, and manipulate internal properties of the program.

翻译过来：反射是 Java 语言的一个特性，它允许一个运行中的 Java 程序检查（自省）并操作自身的内部属性。

2.2 一句话概括原理

JVM 会动态加载 Class，一个 Class 实例包含了该类的所有完整信息：包名、类名、各个字段、各个方法、 父类 、实现的接口等 。因此，只要获取了某个类或对象的 Class 实例，就可以通过它获取到对应类的所有信息。

动态加载 ：JVM 在第一次读取到一种 Class 类型时 才将其加载进内存，而不是一启动就加载所有类。每加载一种类，JVM 就为其创建一个 Class 类型的实例。一个类的不同对象实例，背后对应的是同一个 Class 实例。

三、反射的核心 API

反射相关的代码主要在 JDK 的 rt.jar 下的 java.lang.reflect 包中。核心类和接口包括：

3.1 五大核心类

|------------------------|-----------------------------------------------|
| 类 | 作用 |
| Class | 代表一个类或接口的运行时类型信息 |
| Field | 代表类的成员变量（字段） |
| Method | 代表类的方法 |
| Constructor | 代表类的构造方法 |
| AccessibleObject | Field/Method/Constructor 的父类，提供访问权限控制能力 |

3.2 获取 Class 对象的三种方式

// 方式1：类名.class（编译时已知）
Class<User> clazz1 = User.class;

// 方式2：对象.getClass()（运行时已知实例）
User user = new User();
Class<?> clazz2 = user.getClass();

// 方式3：Class.forName("全限定类名")（动态加载，最灵活）
Class<?> clazz3 = Class.forName("com.example.User");

3.3 获取字段（Field）

Class<?> clazz = User.class;

// 获取 public 字段（包括父类）
Field field1 = clazz.getField("name");

// 获取该类声明的字段（不包括父类，常用）
Field field2 = clazz.getDeclaredField("name");

// 获取所有 public 字段（包括父类）
Field[] fields1 = clazz.getFields();

// 获取该类声明的所有字段（不包括父类，常用）
Field[] fields2 = clazz.getDeclaredFields();

3.4 获取方法（Method）

// 获取 public 方法（包括父类）
Method method1 = clazz.getMethod("sayHello", String.class);

// 获取该类声明的方法（不包括父类）
Method method2 = clazz.getDeclaredMethod("sayHello", String.class);

// 获取所有 public 方法（包括父类）
Method[] methods1 = clazz.getMethods();

// 获取当前类的所有方法（不包括父类）
Method[] methods2 = clazz.getDeclaredMethods();

3.5 综合示例

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        // 1. 获取 Class 对象
        Class<?> clazz = Class.forName("com.example.User");
        
        // 2. 创建实例（通过无参构造器）
        Object user = clazz.getDeclaredConstructor().newInstance();
        
        // 3. 获取私有方法并调用
        Method privateMethod = clazz.getDeclaredMethod("privateMethod");
        privateMethod.setAccessible(true);  // 突破 private 限制！
        privateMethod.invoke(user);
        
        // 4. 获取私有字段并修改
        Field field = clazz.getDeclaredField("name");
        field.setAccessible(true);
        field.set(user, "张三");
        
        // 5. 获取静态方法并调用
        Method staticMethod = clazz.getDeclaredMethod("staticMethod");
        staticMethod.invoke(clazz);  // 静态方法传入 Class 对象
    }
}

四、底层源码深度剖析

反射最核心的方法就是 Method.invoke() 。搞懂了它，就搞懂了反射的底层实现原理。

4.1 Method.invoke() 源码

// java.lang.reflect.Method（源码简化）
@CallerSensitive
public Object invoke(Object obj, Object... args) 
    throws IllegalAccessException, IllegalArgumentException, 
           InvocationTargetException {
    
    // 1. 权限检查（如果未设置 override）
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    
    // 2. 获取 MethodAccessor（核心！）
    MethodAccessor ma = methodAccessor;
    if (ma == null) {
        ma = acquireMethodAccessor();
    }
    
    // 3. 真正执行方法调用
    return ma.invoke(obj, args);
}

@CallerSensitive 注解 ：防止使用者通过"双重反射"提升权限。原理是当时反射只检查深度的调用者 的类是否有权限，通过多重反射可以提高调用权限。使用该注解后，getCallerClass 方法会直接跳过有 @CallerSensitive 修饰的接口方法，直接查找真实的调用者。

4.2 MethodAccessor：反射执行的"三驾马车"

MethodAccessor 接口有三个实现类：

|------------------------------------|-------------------------|
| 实现类 | 作用 |
| NativeMethodAccessorImpl | 通过 JNI 调用 native 方法执行反射 |
| DelegatingMethodAccessorImpl | 委派模式，根据调用次数动态切换委派对象 |
| MethodAccessorImpl | 抽象基类 |

4.3 Inflation 机制：性能优化的"黑魔法"

这是一个非常关键的性能优化机制。

背景 ：Java 17 及更早版本的反射实现依赖于委派模式------委托对象一开始是一个依赖 native 代码的类，一旦调用次数超过阈值，委托对象就被替换为一个动态生成的字节码实现 。这个实现有时被称为 "inflating implementation" （膨胀实现）。

核心参数：

// sun.reflect.ReflectionFactory
private static boolean noInflation = false;
private static int inflationThreshold = 15;  // 默认阈值！

为什么是 15？ 考虑到许多反射调用仅会执行一次，JVM 设置了一个阈值 15。当调用次数在 15 以下时，采用 native 实现（快速启动）；当达到 15 时，开始动态生成字节码，并将委派对象的委派对象切换到动态实现。

Native 实现的劣势：native 方法调用需要跨越 JNI 边界，每次调用都有额外开销。

动态字节码实现的优势：一旦"膨胀"完成，后续调用变成纯 Java 字节码调用，可以被 JIT 编译器内联优化，性能大幅提升。

五、反射的性能代价

5.1 为什么反射慢？

|--------------|-------------------------------------------------------------------|
| 原因 | 说明 |
| 动态解析 | 反射需要在运行时动态解析类和成员信息，比直接代码调用慢得多 |
| 访问检查 | 每次反射调用都需要进行访问权限检查 |
| 参数装箱/拆箱 | invoke(Object obj, Object... args) 的参数和返回值都是 Object，基本类型需要装箱/拆箱 |
| JIT 优化受限 | 反射调用是多态调用，JIT 编译器很难进行有效的内联优化 |
| 安全检查 | 反射可能触发额外的安全性检查 |

5.2 性能数据

在一次 JMH 基准测试中，直接调用耗时约 0.5 ns/op ，而简单反射调用耗时约 6.5 ns/op ------反射比直接调用慢了 超过 10 倍。

另有测试表明，调用一个无参数、返回 int 类型的方法时，反射执行要比直接调用慢 11 倍。

5.3 反射优化建议

1. 缓存 Method/Field 对象 ：将反射得到的 Method/Field 对象缓存起来复用，避免重复查找

2. setAccessible(true)：关闭访问检查，减少每次调用的开销

3. 减少反射调用次数：能一次性获取的信息不要循环获取

4. 考虑替代方案 ：在性能敏感的代码中，考虑使用 MethodHandle 或 代码生成（如 APT、注解处理器）

六、Java 18+ 的演进：JEP 416------用 MethodHandle 重写反射

从 Java 18 开始，核心反射被基于 MethodHandle 重新实现。

6.1 为什么要重写？

旧的反射实现存在三条独立的代码路径：

1. VM native 方法（快速启动）

2. 动态生成的字节码存根（峰值性能）

3. Unsafe 字段访问

维护三条路径成本极高，尤其是当需要支持新语言特性时。此外，生成的字节码需要被 JVM 特殊处理（通过 MagicAccessorImpl 类），增加了系统的复杂性。

6.2 新实现的架构

核心变化：

• Method::invoke → 使用 MethodHandle

• Constructor::newInstance → 使用 MethodHandle

• Field::get/set → 使用 MethodHandle

只有在 JVM 启动早期，MethodHandle 机制尚未初始化时，才会使用 VM 的 native 反射机制。

6.3 MethodHandle 为什么更快？

MethodHandle 是 JVM 字节码级的直接调用句柄，更接近原生方法指针：

|----------|---------------------|------------------------|
| 对比维度 | 反射 (Method.invoke) | MethodHandle |
| 权限检查 | 每次调用都检查 | 查找时检查一次，调用时无需重复 |
| 类型检查 | 弱类型，参数和返回值都是 Object | 强类型，通过 MethodType 精确匹配 |
| 装箱开销 | 每次调用都装箱/拆箱 | 可避免装箱 |
| 性能 | 慢，JIT 优化困难 | 快，接近普通方法调用 |
| 抽象级别 | 高级，代表整个方法定义 | 低级，代表一个可执行的"指针" |

核心洞察 ：反射是"拿着说明书反复核对再调用"，MethodHandle 是"拿到直接入口，一键执行"。在高并发动态调用场景下，MethodHandle 的吞吐量是反射的 3～10 倍，预热后接近直接调用。

七、反射的应用场景

7.1 框架的基石

反射是几乎所有 Java 框架的底层支撑：

|-----------------------|--------------------------------|
| 框架/技术 | 反射的应用 |
| Spring IoC | 通过反射创建 Bean 实例、注入依赖 |
| Spring AOP | 动态代理的底层实现 |
| Spring MVC | 通过反射调用 Controller 方法 |
| JDBC | DriverManager 通过反射加载并注册数据库驱动 |
| MyBatis/Hibernate | 通过反射将 ResultSet 映射到实体对象 |
| JSON 序列化 | Jackson/Gson 通过反射读取字段值 |

7.2 Spring IoC 的反射原理

Spring IoC 容器的核心流程：

1. 解析配置：读取 XML 或注解配置

2. 获取 Class ：通过 Class.forName() 加载类

3. 获取构造器：通过反射获取构造方法

4. 创建实例 ：constructor.newInstance()

5. 注入依赖：通过反射设置字段值或调用 setter 方法

6. 封装为 BeanDefinition：将类的各种信息（构造器、方法、属性）封装成 Bean 定义信息，放入 Map 容器

7.3 动态代理

JDK 动态代理利用反射机制在运行时动态生成代理类和代理对象 。java.lang.reflect.Proxy 利用反射获取代理类的类对象和构造方法，由此构造出实例。

7.4 注解处理

注解的底层实现涉及 JDK 动态代理和反射机制 ------通过代理对象调用注解的方法，最终会调用 AnnotationInvocationHandler 的 invoke 方法，从 memberValues 这个 Map 中查询出对应的值。

八、总结

|------------|-----------------------------------------------------------|
| 维度 | 核心要点 |
| 本质 | 在运行时动态获取和操纵类的信息，让 Java 从"静态语言"获得"动态能力" |
| 原理 | JVM 动态加载 Class，一个 Class 实例包含该类的所有完整信息 |
| 核心 API | Class、Field、Method、Constructor、AccessibleObject |
| 底层实现 | MethodAccessor 三驾马车 + Inflation 机制（阈值 15） |
| 性能代价 | 反射比直接调用慢 10 倍以上 |
| 现代演进 | Java 18+ 用 MethodHandle 重写了核心反射，性能提升 3～10 倍 |
| 典型应用 | Spring IoC/AOP、JDBC、ORM 框架、JSON 序列化、动态代理、注解处理 |

一句话总结 ：反射是 Java 动态性的基石------它让程序在运行时能够"照镜子"般审视自身，获取并操纵类的所有信息。从 JVM 的 Class 加载机制到 MethodAccessor 的 Inflation 优化，再到 Java 18+ 的 MethodHandle 重写，反射机制经历了持续的性能演进。理解反射的底层原理，是看懂 Spring 等所有主流框架源码的必经之路。