Java 反射（Reflection）（建议收藏）

Java 反射（Reflection）：揭开类的“神秘面纱”

你有没有想过，一个 Java 程序在运行时，如何知道自己“身上”有哪些方法、字段、构造器？又或者，如何在不知道具体类名的情况下，动态地创建对象、调用方法？这背后，正是 Java 反射（Reflection）在默默工作。

Java 反射不是什么高深莫测的黑科技，而是一个强大的工具，它让程序在运行时能够“观察”和“操作”自身的结构。就像一位外科医生，不仅能看穿身体的表层，还能在不切开皮肤的情况下，精准地调整内部器官。Java 反射就是程序的“内窥镜”——它让我们在运行时能访问类的元数据，动态地创建对象、调用方法、修改字段。

对于初学者来说，反射可能显得有些抽象。但只要掌握核心概念，你会发现它其实非常实用，尤其是在框架开发、注解处理、序列化、ORM 框架（如 MyBatis）中广泛应用。

接下来，我们就一步步揭开 Java 反射的神秘面纱。

什么是 Java 反射（Reflection）

Java 反射是 Java 提供的一种机制，允许程序在运行时检查、获取类的信息，并动态地调用类的方法、访问字段、创建对象。

举个例子：
你有一个 User 类，定义了 name 字段和 sayHello() 方法。在编译时，Java 编译器会生成 .class 文件，其中包含类的完整结构信息。反射的作用，就是让你在程序运行时，不依赖编译时的硬编码，而是通过类名字符串，动态地获取这个类的所有信息。

这就像你有一本“类说明书”，你可以用它来了解一个类的“身体构造”，甚至在不知道具体类名的情况下，也能“凭空”创建一个对象。

Java 反射的核心类位于 java.lang.reflect 包中，主要包括：

• Class：代表一个类的元数据，是所有反射操作的入口。
• Field：代表类的字段（属性）。
• Method：代表类的方法。
• Constructor：代表类的构造器。

获取 Class 对象的三种方式

要使用反射，第一步就是获取 Class 对象。Java 提供了三种常用方式：

通过类名直接获取

Class<User> clazz = User.class;

这是最简洁、最安全的方式，适用于你知道类名的情况。编译时就能检查类是否存在，不会抛出异常。

通过实例的 getClass() 方法

User user = new User();
Class<?> clazz = user.getClass();

通过对象调用 getClass()，可以获取该对象所属类的 Class 实例。注意这里使用 ? 通配符，因为类型未知。

通过 Class.forName() 动态加载

try {
    Class<?> clazz = Class.forName("com.example.User");
    System.out.println("类加载成功：" + clazz.getName());
} catch (ClassNotFoundException e) {
    System.err.println("类未找到：" + e.getMessage());
}

这种方式是动态加载类的关键。它允许你在运行时根据字符串类名加载类，特别适合框架开发中根据配置文件决定使用哪个类。

⚠️ 注意：Class.forName() 会触发类的初始化（静态代码块执行），而前两种方式不会。

动态创建对象：使用 Constructor

有了 Class 对象，我们就能动态创建实例。这在工厂模式、依赖注入中非常有用。

假设我们有一个 User 类：

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

    // 无参构造器
    public User() {
        System.out.println("User 无参构造器被调用");
    }

    // 带参构造器
    public User(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("User 带参构造器被调用：name=" + name + ", age=" + age);
    }

    public void sayHello() {
        System.out.println("Hello, 我是 " + name);
    }

    // getter 和 setter 省略
}

现在我们用反射创建实例：

try {
    // 获取 Class 对象
    Class<?> clazz = Class.forName("com.example.User");

    // 获取无参构造器并创建对象
    Constructor<?> constructor1 = clazz.getConstructor();
    Object user1 = constructor1.newInstance();
    ((User) user1).sayHello(); // 调用方法

    // 获取带参构造器并创建对象
    Constructor<?> constructor2 = clazz.getConstructor(String.class, int.class);
    Object user2 = constructor2.newInstance("Alice", 25);
    ((User) user2).sayHello();

} catch (Exception e) {
    e.printStackTrace();
}

✅ 重点：newInstance() 是创建实例的方法，它会调用构造器。
✅ getConstructor() 传入的是参数类型的 Class 对象，如 String.class。

动态调用方法：使用 Method

反射不仅能创建对象，还能在运行时调用任意方法，甚至调用私有方法！

我们继续用 User 类：

// 假设 User 类中有一个私有方法
private void privateSay() {
    System.out.println("这是私有方法，通过反射调用");
}

要调用私有方法，需要先设置 setAccessible(true)，否则会抛出 IllegalAccessException。

try {
    Class<?> clazz = Class.forName("com.example.User");

    // 获取方法对象，参数为方法名 + 参数类型
    Method method = clazz.getDeclaredMethod("privateSay"); // 私有方法需用 getDeclaredMethod

    // 允许访问私有方法
    method.setAccessible(true);

    // 创建对象实例
    Object user = clazz.getConstructor().newInstance();

    // 调用方法，第一个参数是对象实例，后面是方法参数
    method.invoke(user);

} catch (Exception e) {
    e.printStackTrace();
}

🔍 提示：getDeclaredMethod() 只能获取当前类声明的方法（包括私有），而 getMethod() 只能获取公共方法（包括父类的）。

访问字段：使用 Field

字段（属性）的访问同样可以通过反射完成。比如我们要修改一个私有字段的值。

public class User {
    private String name = "默认名字";
    private int age = 0;

    // getter/setter 省略
}

try {
    Class<?> clazz = Class.forName("com.example.User");

    // 获取私有字段
    Field field = clazz.getDeclaredField("name");

    // 允许访问私有字段
    field.setAccessible(true);

    // 创建对象
    Object user = clazz.getConstructor().newInstance();

    // 设置字段值
    field.set(user, "Bob");

    // 获取字段值
    String value = (String) field.get(user);
    System.out.println("name 字段值为：" + value);

} catch (Exception e) {
    e.printStackTrace();
}

📌 注意：field.set(obj, value) 是设置值，field.get(obj) 是获取值。
⚠️ 静态字段需传 null 作为对象参数。

实际应用场景：注解 + 反射的威力

Java 反射最强大的应用场景之一，就是处理注解（Annotation）。

比如我们定义一个注解：

@Retention(RetentionPolicy.RUNTIME)
public @interface MyField {
    String value() default "";
}

然后在类中使用它：

public class User {
    @MyField("用户名")
    private String name;

    @MyField("年龄")
    private int age;
}

现在我们用反射来遍历所有字段，并读取注解：

try {
    Class<?> clazz = Class.forName("com.example.User");

    // 获取所有字段
    Field[] fields = clazz.getDeclaredFields();

    for (Field field : fields) {
        // 检查是否有 MyField 注解
        if (field.isAnnotationPresent(MyField.class)) {
            MyField annotation = field.getAnnotation(MyField.class);
            System.out.println("字段：" + field.getName() + "，注解值：" + annotation.value());
        }
    }

} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

输出结果：

字段：name，注解值：用户名
字段：age，注解值：年龄

这正是 MyBatis、Spring 等框架底层实现的原理——通过反射读取注解，自动生成 SQL、绑定参数。

反射的优缺点与最佳实践

优点

• 动态性：可在运行时决定类的行为。
• 灵活性：适合框架开发，实现通用工具。
• 无需硬编码：可读配置文件动态加载类。

缺点

• 性能开销：反射比直接调用慢，因为需要查表、权限检查。
• 安全风险：可以绕过访问控制，修改私有字段。
• 代码可读性差：反射代码较难理解和调试。

最佳实践建议

• 仅在必要时使用反射，如框架、配置驱动。
• 尽量避免频繁调用反射方法。
• 使用 setAccessible(true) 时需谨慎，确保安全。
• 在生产环境使用反射时，建议加日志或异常处理。

总结

Java 反射（Reflection）是 Java 语言的“元编程”能力，它赋予程序在运行时“自省”的能力。从获取类信息、创建对象，到调用方法、访问字段，甚至处理注解，反射都扮演着不可或缺的角色。

虽然它有性能代价和安全风险，但只要合理使用，它就是构建灵活、可扩展系统的利器。对于初学者，理解反射的核心概念是迈向高级开发的重要一步；对于中级开发者，掌握反射能让你更深入理解框架原理，提升问题排查与设计能力。

记住：反射不是为了炫技，而是为了在不确定中创造确定。当你在框架中看到 @Autowired、@Entity、@RequestMapping 这些注解时，背后都有反射在默默工作。

掌握 Java 反射，你离“真正理解 Java”又近了一步。