当前位置：首页 > news >正文

Java反射机制深度解析：方法、实战与底层机制

news 来源：原创 2025/9/21 9:02:51

大家好，我是钢板兽！

反射作为Java的特性，它不仅是Spring三大特性Ioc、DI、AOP的基础，而且MyBatis、Jackson序列化、rpc远程调用接口都用到了反射机制。

本文将带你系统性地掌握 Java 反射的使用，通过 JSON 反序列化的应用场景了解反射机制在实战中的使用，并通过JVM 底层实现深入剖析反射的底层机制。

文章目录

- 1.反射是什么？
- 2.反射的基本使用
- - 2.1 获取Class<T>对象
  - 2.2 获取类结构信息
  - 2.3 操作结构信息
  - 2.4 特殊处理
  - 2.5 性能优化
- 3.反射的实战使用
- - 3.1 JSON → Java 对象反序列化
  - 3.2 依赖反射机制的后端技术栈
- 4.反射的底层机制

1.反射是什么？

反射（Reflection）是一种在运行时对程序“结构信息”访问与操作的机制。

Java是静态类型语言，其程序结构信息在编译器就已经确定好了，比如方法签名、字段类型、继承关系等。通过主动使用反射，编译器的结构信息可以被延伸到运行时，程序可以在运行时动态访问、读取甚至修改这些结构信息，从而实现对静态类型系统的动态扩展和运行期控制，突破编译器的静态绑定限制。

反射的底层实现依赖于**“运行时类元数据结构”**，JVM 加载每一个 .class 文件时，都会为其构造一份“类的运行时结构”，并定义在方法区的 InstanceKlass中。这个运行时类结构包括：

信息项	说明
类名、父类、接口名	支撑类的继承
字段表	字段名称、类型、修饰符、内存偏移量
方法表	方法签名、字节码入口、方法句柄
注解数据	保留注解的元数据
常量池	对类、方法、字段等的符号引用

2.反射的基本使用

JVM 只对外暴露一个 Java 层的对象 —— java.lang.Class<T>，它是所有类元信息的唯一入口。

所以我们要先拿到 Class<?> 对象，才能访问类的结构。Class<?> 内部再通过 native 方法（本地方法）访问 JVM 结构，并包装成 Field、Method 等反射对象，Field.get()、Method.invoke() 等操作都依赖于这些对象所持有的 JVM 数据指针。

这决定了 Java 的反射操作流程具有顺序性，任何试图“越级访问”的操作都将失败或被安全机制禁止，使用反射的基本操作流程如下：

第一步：获取 Class<T> 对象。
第二步：获取类结构信息（字段、方法、构造器、注解等）
第三步：操作结构信息（创建对象/调用方法/设置字段）

其它操作：

特殊处理（私有访问、泛型、注解等高级特性）
性能优化（缓存反射对象、MethodHandle）

2.1 获取Class对象

Class<T>对象的获取有三种方式：

通过类字面量（编译期已知）
```
Class<?> clazz1 = MyClass.class;
```

通过对象（运行时获取）

MyClass obj = new MyClass();
Class<?> clazz2 = obj.getClass();

通过类名字符串（支持动态加载）
```
Class<?> clazz3 = Class.forName("com.example.MyClass");
```
这种方式是获取Class<T>对象最典型的方式，常用于框架中动态加载类。

2.2 获取类结构信息

获取字段

Field[] fields = clazz.getDeclaredFields();
Field nameField = clazz.getDeclaredField("name");

获取方法

Method[] methods = clazz.getDeclaredMethods();
Method m = clazz.getDeclaredMethod("sayHello", String.class);

获取构造器

Constructor<?>[] constructors = clazz.getDeclaredConstructors();
Constructor<?> ctor = clazz.getDeclaredConstructor(String.class, int.class);

获取注解

Annotation[] annotations = clazz.getAnnotations();
boolean hasAnno = clazz.isAnnotationPresent(MyAnnotation.class);
MyAnnotation ann = clazz.getAnnotation(MyAnnotation.class);

2.3 操作结构信息

创建对象实例

Object obj = clazz.getDeclaredConstructor().newInstance();

或者通过有参构造器：

Constructor<?> ctor = clazz.getDeclaredConstructor(String.class);
Object obj = ctor.newInstance("Tom");

设置字段值 / 获取字段值

Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true); // 如果是 private
nameField.set(obj, "Jerry");
String name = (String) nameField.get(obj);

调用方法
```
Method method = clazz.getDeclaredMethod("sayHello", String.class);
method.setAccessible(true);
method.invoke(obj, "world");
```
invoke 方法是 java.lang.reflect.Method 类的一个方法，用于动态调用某个对象的方法。
```
Object invoke(Object obj, Object... args)
```
obj：要在其上调用方法的对象（即目标实例），对于静态方法可以传 null。

args：方法参数的数组，如果无参方法可以传 null 或空数组。

2.4 特殊处理

访问私有构造器、字段、方法

Java 的访问控制符（private、protected、public）在运行时依然生效，JVM 默认会检查访问权限，所以要主动绕过这一限制，这属于对反射行为的“增强”或“越权”。
```
method.setAccessible(true);
```

获取泛型信息

Java 泛型采用类型擦除机制，在运行时大多数泛型信息已被擦除。

要访问泛型参数，必须通过反射中的 ParameterizedType、TypeVariable 等复杂 API 解析。属于高级用法。

Field listField = clazz.getDeclaredField("list");
Type type = listField.getGenericType(); // 获取该字段的通用类型（带泛型信息）
if (type instanceof ParameterizedType) { // 判断该字段是否是一个参数化类型// 如果字段是参数化类型，那么取出其实际的泛型参数。Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments();
}

解析注解信息

Field field = clazz.getDeclaredField("name");
MyAnnotation annotation = field.getAnnotation(MyAnnotation.class);
System.out.println(annotation.value());

2.5 性能优化

反射本质上是一种运行时动态调度机制，开销大（方法查找、访问检查、装箱/拆箱等），在实际框架/高性能场景中，需要引入一些性能优化的手段。

缓存反射对象

使用 Java 反射时，如 clazz.getDeclaredMethod(...) 或 method.invoke(...)，每次调用都涉及 元信息查找与访问权限检查，这在高频场景下性能较差。

为了优化性能，可以将反射对象（如 Method）缓存起来，避免重复查找，典型场景如：Spring、MyBatis、低代码平台中的动态组件绑定等。

// 方法级缓存
private static final Map<String, Method> methodCache = new ConcurrentHashMap<>();// 如果缓存中没有 "sayHello"，则调用 lambda 表达式创建并存入缓存；否则直接返回已有的 Method 对象。
Method m = methodCache.computeIfAbsent("sayHello", k -> {try {Method method = clazz.getDeclaredMethod("sayHello", String.class);method.setAccessible(true);return method;} catch (Exception e) {throw new RuntimeException(e);}
});

使用 MethodHandle 替代 Method.invoke

Method.invoke() 本质上是 JVM 内部通过反射执行的一种“间接调用”，存在性能劣势。Java 7 引入了 java.lang.invoke 包，提供了更底层、更高效的方法句柄机制。MethodHandle 是对方法、构造器、字段访问的一种 可直接执行的指令句柄（类似函数指针），支持 JIT 内联优化，性能接近直接调用。

// 获取当前类上下文的查找器，用于寻找类中的方法句柄
MethodHandles.Lookup lookup = MethodHandles.lookup();
// 查找实例方法，第一个参数是目标类；第二个是方法名；第三个是方法类型（返回值 + 参数类型）。
MethodHandle handle = lookup.findVirtual(MyClass.class, "sayHello", MethodType.methodType(void.class, String.class));
handle.invoke(obj, "World");

3.反射的实战使用

3.1 JSON → Java 对象反序列化

在后端服务中，几乎所有系统都会接收客户端发来的 JSON 请求，例如：

{"id": 123,"name": "Alice","age": 26
}

我们希望将这个 JSON 转换成如下实体类：

public class User {private int id;private String name;private int age;// getter / setter
}

但问题是：这段 JSON 是在运行时到达的，程序编译时并不知道要反序列化成哪个类、字段名是什么、字段类型是什么。

解决方案就是让前端提交任意 Java Bean 的类名 + JSON 内容，后端系统使用反射动态构造对象并设置字段完成反序列化。

前端请求示例：

POST /api/parse
Content-Type: application/json{"className": "com.example.User","json": "{"id": 123,"name": "Alice","age": 26}"
}

FastJSON / Jackson 中核心逻辑（简化版）：

@PostMapping("/api/parse")
public String parseObject(@RequestBody Map<String, Object> request) throws Exception {String className = (String) request.get("className");String json = (String) request.get("json");// 这时候类名是运行时才知道的，必须用反射Class<?> clazz = Class.forName(className);//  parseObject是阿里巴巴 FastJSON 框架 提供的 API，用于将一段 JSON 字符串反序列化为 Java 对象。Object obj = JSON.parseObject(json, clazz);// 假设我们统一调用 getName() 来检查反序列化是否成功Method getName = clazz.getMethod("getName");String name = (String) getName.invoke(obj);return "Parsed object name = " + name;
}

FastJSON 内部的JSON.parseObject(json, clazz) 内部会：

读取传入的 clazz 的所有字段（通过反射）；
对应字段名从 JSON 中取值；
自动进行类型转换（字符串转 int、Date 等）；
通过反射赋值到字段上（使用 Field.set()）；
最终返回被填充好的对象实例。

最后，obj 就是一个填充完属性的 User 实例了。

3.2 依赖反射机制的后端技术栈

在我们常用的一些后端技术栈中都“隐藏”着反射机制的身影，比如Spring框架、MyBatis、Dubbo/gRPC等。

（1）Spring框架

功能模块	使用方式
IOC 容器	使用反射实例化 Bean，调用构造方法、Setter 方法注入属性
依赖注入（DI）	通过 `Field.set()` 或 `Method.invoke()` 注入依赖字段或方法
AOP（面向切面编程）	使用 JDK 动态代理 / CGLIB 生成代理对象，方法拦截点通过反射执行原始方法
注解驱动配置	反射读取 `@Component`, `@Autowired`, `@Value`, `@Transactional` 等注解
事件监听、条件配置	动态扫描标注方法和类，注册监听器和条件逻辑
Spring Expression Language（SpEL）	使用反射读取对象结构以执行表达式

（2）MyBatis

功能点	说明
Mapper 接口动态代理	使用 `Proxy.newProxyInstance` 创建接口代理对象
方法解析	拦截方法调用后，通过反射获取方法签名、注解等
参数处理器	反射分析参数对象，提取字段值写入 SQL 语句
返回值映射	SQL 查询结果 → 实体类：通过反射设置字段值（`Field.set()`）
注解解析	解析 `@Select`, `@Insert` 等构建 SQL 映射
构造对象	执行查询后反射创建结果对象，支持构造器注入或默认构造方式

（3）Dubbo / gRPC

功能点	说明
泛化调用（GenericService）	客户端仅传入接口名、方法名、参数列表，服务端通过反射调用目标方法
JDK 动态代理	消费方创建接口代理对象，通过反射将调用封装为远程调用请求
服务暴露	服务提供者注册本地实现类，通过反射暴露其方法签名给注册中心
序列化	使用反射确定参数字段结构，用于 Hessian、Kryo 等序列化协议编解码
SPI 插件机制	利用 `Class.forName()` + 反射构造插件实例（比如扩展点、Filter、LoadBalance）

（4） Jackson / Gson

功能点	说明
字段遍历与读取	利用 `Class.getDeclaredFields()` 遍历对象属性，读取其值用于 JSON 输出
构造对象	反射调用默认构造方法或使用 `Unsafe` 构建无参对象用于反序列化
字段赋值	通过 `Field.set()` 将 JSON 数据写入 Java 对象
注解处理	Jackson 解析 `@JsonProperty`, `@JsonIgnore`, `@JsonInclude` 等注解控制行为
泛型处理	利用 `ParameterizedType` 判断泛型结构（如 `List<User>`）并反射填充

4.反射的底层机制

使用反射的过程中底层机制是怎样的？本节以字段设置为例来探究反射的底层触发过程。

Class<?> clazz = MyClass.class;
Object obj = clazz.getDeclaredConstructor().newInstance(); // 创建 User 实例
Field field = clazz.getDeclaredField("id"); // 在当前 Class 对象中查找名称为 "id" 的字段
field.setAccessible(true);
field.set(obj, 100);

逐行分析每行代码实际发生了什么。

（1）Class<?> clazz = MyClass.class

这是 Java 层访问类的元模型对象。在 JVM 内部，每一个 .class 文件被加载后都会生成一个 Class<?> 实例，它是对 JVM 内部 InstanceKlass 的封装。

Class 是 Java 层对象；
InstanceKlass 是 JVM 内部 C++ 层结构，保存字段表、方法表、注解信息、常量池等；
每个 Class<?> 对象都通过 native handle 关联到对应的 InstanceKlass。

（2）Object obj = clazz.getDeclaredConstructor().newInstance()

这个操作等价于：

Constructor<?> constructor = clazz.getDeclaredConstructor(); // 找无参构造器
Object obj = constructor.newInstance();                      // 调用构造器

底层执行逻辑：

查找构造方法（构造器也是一个 Method，JVM 方法表中 <init>）；
创建实例对象：
- JVM 调用 Unsafe.allocateInstance() 或 JVM_NewInstance()；
- 在堆中分配内存空间，初始化对象头；
调用 <init> 构造方法初始化字段。

（3）Field field = clazz.getDeclaredField("id")

这是反射获取字段的核心步骤，JVM 底层执行过程：

Class.getDeclaredField(name) 是 Java 层接口；
内部通过 JNI（Java本地接口）调用 native 方法 Class.getDeclaredField0；
InstanceKlass::_fields 表中保存所有字段结构，包括字段名、类型、修饰符、slot（编号）；
查找字段名 "id" 对应的 fieldInfo；
构造一个 Java 层 Field 对象进行封装，保留：
- 字段名；
- 字段类型；
- 父类；
- 字段在对象内存中的偏移（fieldOffset）；

源码参考：

// HotSpot C++ 层结构
class InstanceKlass {Array<FieldInfo*>* fields(); // 包含字段名、偏移、类型等
}

（4）field.setAccessible(true)

该操作本质是关闭 Java 语言的访问控制检查（绕过 private/protected 限制），实际机制：

设置 Field 对象的 override 标志；
会影响后续 Field.get()、set() 时是否进行权限校验；
在 Java 9+ 中受到模块系统限制，调用需要 --add-opens 启动参数支持。

（5） field.set(obj, 100)

这是整个反射调用中最重要的一步 —— 写入字段值，底层机制：

首次调用 field.set(...) 时，JDK 会通过 Field.getFieldAccessor() 创建一个 FieldAccessor 实例。该对象用于封装字段读写逻辑，并在之后缓存复用，具体调用路径如下：

FieldAccessor 是一个接口，JDK 内部提供多个实现，包括基于字节码生成的访问器（如 GeneratedFieldAccessor) 和基于 Unsafe 的低层访问器；

为了优化性能，JDK 会尝试动态生成字节码（通过 MethodAccessorGenerator），将字段访问逻辑转化为专门的 MethodHandle 或代理类。
字段写入最终会走到底层内存操作逻辑，目前在 JDK 中有两种主流实现路径：
1. 通过 JNI native 方法调用 JVM 内部逻辑，VM 提供一系列 native 方法处理字段写入，例如：
```
JVM_SetField(env, jclass clazz, jobject obj, jfieldID fieldID, jvalue val);
```
其内部调用 C++ 实现，找到对象引用 obj，结合 fieldID（字段的唯一标识符），将值写入目标字段内存。
1. 通过 sun.misc.Unsafe 直接写入对象内存
JDK 中对性能要求较高的反射路径会绕过 JNI，直接调用 Unsafe，它是一个提供低层次、绕过 JVM 安全检查的操作能力的类，常被称为“JVM 的后门”。
```
UNSAFE.putInt(obj, offset, 100);
```
putInt 等方法会通过内存屏障和 CPU 指令直接修改堆中字段值。
JVM 中的对象实例在堆内存中的布局大致如下：

JVM 通过计算 obj 的堆内地址加上字段偏移量，即 obj + offset，精准定位该字段的物理存储地址，并完成写入操作。

field.set(obj, 100) 的执行流程代表了 Java 反射机制中典型的“元数据访问 → 方法调度 → 内存写入”三层架构：

利用 Field 封装结构信息；
通过 FieldAccessor 访问分发；
以 Unsafe 或 native 方法在对象内存中完成实际字段写入。

这个过程在代码层面虽然很简单，但它的运行路径跨越了 Java 层、JVM native 层与内存操作层，是 Java 反射机制的底层体现。

如果这篇文章对你有帮助，欢迎点赞、转发、留言！