Java反射机制实战：如何读取字段、调用方法和创建对象

平时写 Java 代码，我们通常在编译时就知道要调用哪个类、哪个方法。例如，直接执行 user.getName()。反射则允许程序在运行时检查类的结构，并根据类对象、成员名称和参数类型读取字段、调用方法或创建实例。

这种能力适合框架、通用工具和需要运行时扩展的程序，但并不意味着可以绕过所有 Java 访问规则，更不适合用来替代普通的静态调用。本文从一份可运行的示例出发，说明反射的基本操作、容易踩到的边界，以及如何安全地使用它。

一、反射是什么，适合用在什么地方

反射主要围绕 Class、Field、Method 和 Constructor 等类型展开。一个 Class 对象描述某个类在运行时的结构；通过它可以查询类的字段、方法、构造器，再用相应对象执行操作。

常见应用包括：

• 依赖注入和对象装配：容器读取构造器或注解信息，按规则创建对象并连接依赖。
• 序列化与数据映射：框架根据字段、方法或注解，把对象转换为 JSON、数据库记录等格式，或执行反向映射。
• 插件与扩展机制：程序根据受控配置加载实现类，再创建实例调用约定好的接口。
• 测试、诊断和开发工具：测试框架发现测试方法，调试工具检查对象结构。

如果类和方法在编写代码时已确定，直接调用通常更简单，也更容易被编译器检查。反射需要运行时查找，错误往往到执行时才暴露，还可能受到访问控制和模块边界限制。只有当“目标要在运行时确定”确实是需求时，才值得引入它。

二、完整可运行示例

下面的程序演示如何读取公有和私有字段、调用实例方法和静态方法，以及通过构造器创建对象。将代码保存为 ReflectionDemo.java，使用 JDK 17 或较新的 JDK 编译运行：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectionDemo {
    public static class User {
        private String name;
        public int age;

        public User() {
            this("未命名", 0);
        }

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String greet(String prefix) {
            return prefix + "，我是" + name;
        }

        private void rename(String newName) {
            this.name = newName;
        }

        public static String category() {
            return "普通用户";
        }
    }

    public static void main(String[] args)
            throws ReflectiveOperationException {
        User user = new User("林", 28);
        Class<User> type = User.class;

        // 1. 读取公有字段
        Field ageField = type.getField("age");
        Object age = ageField.get(user);
        System.out.println("age = " + age);

        // 2. 读取私有字段
        Field nameField = type.getDeclaredField("name");
        if (!nameField.trySetAccessible()) {
            throw new IllegalStateException("当前环境不允许访问 name");
        }
        Object name = nameField.get(user);
        System.out.println("name = " + name);

        // 3. 调用公有实例方法
        Method greet = type.getMethod("greet", String.class);
        Object greeting = greet.invoke(user, "你好");
        System.out.println(greeting);

        // 4. 调用私有实例方法
        Method rename = type.getDeclaredMethod("rename", String.class);
        if (!rename.trySetAccessible()) {
            throw new IllegalStateException("当前环境不允许访问 rename");
        }
        rename.invoke(user, "小林");
        System.out.println(greet.invoke(user, "你好"));

        // 5. 调用静态方法：接收者参数传 null
        Method category = type.getMethod("category");
        System.out.println(category.invoke(null));

        // 6. 调用指定构造器创建对象
        Constructor<User> constructor =
                type.getConstructor(String.class, int.class);
        User created = constructor.newInstance("周", 31);
        System.out.println(greet.invoke(created, "欢迎"));
    }
}

运行结果会包含年龄、姓名、两次问候、用户类别，以及新建对象的问候信息。下面逐项解释这段程序使用的 API 和其中的限制。

三、取得 Class 对象

反射操作通常从 Class 对象开始。常用的三种方式是：

Class<String> a = String.class;
Class<?> b = "hello".getClass();
Class<?> c = Class.forName("java.lang.String");

类型.class 适合类型在编译时已知的情况；对象.getClass() 返回对象的实际运行时类型；Class.forName 根据类的完整名称查找类，常用于配置驱动的场景。它会抛出 ClassNotFoundException，类名拼错或运行时类路径缺少对应类时都可能发生。

如果使用 Class.forName 加载外部配置提供的类名，不要因此就直接执行任意类的构造器或方法。类加载和初始化也可能触发静态初始化逻辑。应先校验类是否属于预期范围，再按明确的接口或父类约束使用它。

四、读取和修改字段

1. getField 与 getDeclaredField 的区别

getField("age") 查找当前类及其继承层次中的公有字段；getDeclaredField("name") 只查找当前类直接声明的字段，字段可以是 private、protected、包级或 public。如果字段不存在，两者都会抛出 NoSuchFieldException。

同样，getFields() 返回可见的公有字段，可能包括继承而来的字段；getDeclaredFields() 返回当前类声明的所有字段，但不包含继承字段。需要遍历父类时，应沿着 getSuperclass() 自行查询，并注意到达接口、数组、基本类型等情形时的差异。

字段的 get 方法返回 Object，基本类型字段会被装箱。例如，读取 int 得到的是 Integer。需要写入时可调用 set，但字段类型必须兼容：

Field ageField = User.class.getField("age");
ageField.set(user, 29);
int age = ageField.getInt(user);

getInt 是针对 int 字段的类型化读取方法；字段类型不匹配会导致异常。使用通用 get 再显式转换也可以，但转换必须符合实际字段类型。

2. 访问私有字段的边界

对于私有字段，常见做法是先用 getDeclaredField 获取字段，再尝试调用 trySetAccessible()。返回 true 表示当前运行环境允许抑制 Java 语言访问检查；返回 false 表示不允许。旧代码中常见的 setAccessible(true) 会尝试设置访问标记，并可能抛出 InaccessibleObjectException。

这不是无条件的“越权开关”。从 Java 9 开始，模块系统对跨模块反射访问施加了边界。访问其他模块中的非公有成员，通常要求目标包对调用方开放；否则，即使拿到了 Field 或 Method，也可能无法抑制访问检查。应查看模块声明，必要时由应用维护者通过合理的模块配置开放指定包，而不是假设所有私有成员都能反射访问。

此外，不要把反射修改私有状态当作常规业务 API。对象可能依赖封装维护不变量，直接改字段会绕过校验、事件通知或缓存更新。优先调用对象公开的方法。

3. static 和 final 字段

读取实例字段时，Field.get 的接收者应是目标对象；读取静态字段时可以传 null，也可以传对应类型的实例。静态字段属于类，而非某个对象。

final 字段不应通过反射修改来实现业务功能。现代 Java 对这类写入有严格限制；即使某些环境或特定字段允许修改，也可能影响程序正确性、可见性或编译器优化。尤其是常量、记录类的组件和不可变对象，应通过设计好的构造过程设置，而不是事后反射改值。

五、查找并调用方法

调用方法的核心步骤是：查找 Method，准备接收者和参数，再调用 invoke。实例方法需要传入目标对象，静态方法传入 null 即可。

Method method = User.class.getMethod("greet", String.class);
Object result = method.invoke(user, "你好");
System.out.println(result);

getMethod 只查找公有方法，包括继承而来的公有方法；getDeclaredMethod 查找当前类声明的方法，包含非公有方法，但不沿父类查找。方法重载时，查找依据是方法名和参数的精确类型列表，并不是根据实际参数值自动完成与 Java 源码调用完全相同的重载决议。

例如，目标方法声明为 greet(String)，查找时就应传入 String.class。若参数是基本类型，应使用对应的基本类型令牌，例如 int.class，而不是 Integer.class：

Method setAge = SomeType.class.getMethod("setAge", int.class);

int.class 和 Integer.class 是不同的类型。调用时反射通常会处理基本类型与对应包装类型之间的装箱、拆箱，但方法查找阶段仍要提供正确的声明参数类型。也不能指望查找 API 自动把 long 变成 int，或把任意对象转换为目标类型。

调用参数、数组和可变参数

Method.invoke 的参数个数和类型必须与目标方法兼容。对于普通方法，参数数量不匹配或类型不兼容时会抛出 IllegalArgumentException。调用者传入的值还必须满足方法声明的类型约束，反射不是通用类型转换器。

可变参数方法在 JVM 中以数组参数表示。例如，方法声明为 log(String... messages)，反射查找时要传 String[].class，调用时也要传一个 String[]。为了避免 Java 的可变参数语法把数组展开成多项，可显式把数组作为一个参数传递：

Method log = SomeType.class.getMethod("log", String[].class);
log.invoke(target, (Object) new String[] {"开始", "完成"});

这里的 (Object) 用于明确告诉编译器：数组整体是 invoke 的一个参数。实际代码中，SomeType 和 log 必须替换为真实类和方法；如果目标方法是静态方法，接收者可以传 null。

六、创建对象：构造器与 newInstance

反射创建对象时，先取得构造器，再调用 newInstance。示例中使用的 getConstructor 查找公有构造器，参数类型列表必须和构造器声明一致：

Constructor<User> constructor =
        User.class.getConstructor(String.class, int.class);
User user = constructor.newInstance("周", 31);

如果目标构造器不是公有的，应使用 getDeclaredConstructor 查找当前类声明的构造器；是否能实际访问，仍取决于访问控制和模块开放情况。若没有无参构造器，调用无参查找会得到 NoSuchMethodException。Java 不会因为找不到无参构造器就自动选择一个其他构造器。

对于常见业务代码，new User(...) 通常比反射构造更安全、直观。反射创建对象适用于构造参数或具体实现要由运行时配置决定的场景，并应把可选实现限制在可信的接口或父类范围内。

七、常见异常与排查方法

• ClassNotFoundException：Class.forName 指定的类找不到。检查完整类名、拼写、类路径或模块配置。
• NoSuchFieldException、NoSuchMethodException、NoSuchMethodException：字段、方法或构造器没有按提供的名称和参数类型找到。检查成员是否由父类声明、是否为公有，以及基本类型和包装类型是否混淆。构造器查找失败同样使用 NoSuchMethodException。
• IllegalAccessException：当前调用不能访问目标成员。先确认成员的可见性，再检查是否有必要使用 trySetAccessible，以及模块是否开放目标包。
• IllegalArgumentException：调用参数数量或类型不匹配，或者字段赋值类型不兼容。逐项对照目标方法的声明参数类型。
• InvocationTargetException：目标方法或构造器本身抛出了异常。实际业务异常可通过 getCause() 查看；不要把它误判为反射查找失败。
• ExceptionInInitializerError：类初始化期间的静态初始化逻辑发生错误。排查目标类的静态字段初始化块和相关依赖。

在本文完整示例中，main 声明抛出 ReflectiveOperationException，是为了让演示代码保持简洁。生产代码通常应在合适的层级捕获异常，记录目标类、成员名称和必要的上下文，然后决定重试、回退或向调用方报告。不要简单吞掉异常，也不要只打印“反射失败”而不保留根因。

如果要区分目标方法抛出的业务异常与反射调用问题，可以这样处理：

try {
    method.invoke(target, args);
} catch (InvocationTargetException e) {
    Throwable cause = e.getCause();
    // 按业务需要记录或处理 cause
    throw new RuntimeException("目标方法执行失败", cause);
}

八、反射的安全用法

反射本身不是安全机制，也不会自动构成漏洞；风险通常来自程序把不可信输入当成类名、成员名或方法参数，再以高权限直接执行。反射可以调用当前进程有权调用的代码，但它不能替代操作系统权限隔离、进程隔离或可靠的沙箱。

使用反射处理外部配置或插件时，可以遵循以下原则：

• 限制可选实现：使用明确的类白名单，或要求实现指定接口、继承指定基类，并在创建前校验。
• 固定可调用面：优先调用接口中约定的方法，不要让请求方任意指定类中的任意方法名。对方法参数做和普通 API 相同的校验。
• 谨慎访问非公有成员：只在确有必要时尝试抑制访问检查，不要因为“能访问”就忽略对象封装与模块边界。
• 控制配置来源与权限：外部配置决定加载哪些实现，本身就可能影响程序行为。限制配置的修改权限，并审查插件代码的来源。
• 避免把反射当作沙箱：如果运行不可信插件，应采用独立进程等真正的隔离方式，并按操作系统和运行环境配置权限。

九、性能与设计上的注意事项

反射调用通常比直接调用多出查找、访问检查和运行时分派等成本，但实际开销取决于 JDK 版本、调用方式和运行场景。现代 JDK 对反射实现进行过优化，不能简单套用过时结论说反射必然慢到不可使用；同样，也不应假设它和直接调用成本完全相同。高频路径应先用基准测试验证，再决定是否缓存方法或构造器、改用接口调用，或调整设计。

如果每次处理请求都重复查找同一个方法，可以在初始化阶段缓存 Method 或 Constructor，但缓存也要考虑类加载器生命周期和应用重载。尤其在插件容器、应用服务器等环境中，静态缓存对插件类的强引用可能阻止类加载器释放，造成内存无法回收。

还要注意 Java 编译器不会替反射字符串检查成员是否存在。重命名字段或方法时，普通调用往往会在编译期报错，而写在字符串里的成员名可能直到运行时才失败。可以通过集中管理名称、编写测试、启动时校验配置，降低这类问题的排查成本。

十、选择反射前的检查清单

• 目标类型是否必须在运行时才能确定？如果不是，优先使用普通调用或接口。
• 是否清楚成员来自当前类还是父类？据此选择 getDeclared... 或 get... 方法。
• 是否按声明类型查找了重载方法和构造器？基本类型与包装类型不能混为一谈。
• 是否确认调用参数数量、类型，以及可变参数所需的数组形式？
• 是否处理了访问失败和目标方法自身抛出的异常？
• 类名、方法名和参数是否可能来自不可信输入？如果是，是否使用白名单和接口约束？

掌握这些规则后，反射并不难使用：从 Class 开始查找目标成员，根据需要处理访问权限，随后读取字段、调用方法或执行构造器。真正需要仔细权衡的，是使用反射是否必要、运行环境是否允许，以及如何控制运行时输入和失败处理。把它用于边界明确的框架功能和通用工具，通常能发挥价值；把它塞进本可直接编写的业务调用中，则往往只会增加脆弱性。