Java 反射 (Reflection) 是 Java 语言提供的一种强大的机制，它允许运行中的 Java 程序在运行时 (Runtime) 检查自身（包括类、接口、字段和方法）的信息，并且可以在运行时动态地创建对象、调用方法、访问和修改字段。这种能力使得 Java 能够实现高度的动态性和灵活性，是许多高级框架和工具（如 Spring、JUnit、ORM 框架等）的核心基础。

核心思想：Java 反射机制允许程序在运行时动态地获取、检查和操作类、接口、字段和方法的信息，从而实现代码的动态创建、调用和修改，是 Java 动态编程能力的关键所在。

一、为什么需要反射？

在传统的 Java 编程中，当我们使用一个类时，通常需要在编译时就明确知道这个类的所有信息（如类名、方法名、字段名等）。然而，有些场景需要程序具备更强的动态性：

  1. 解耦与框架设计：框架（如 Spring IoC 容器）需要在启动时根据配置文件或注解来动态创建对象、注入依赖、调用方法，而不是在编码阶段硬编码这些逻辑。反射使得框架能够以通用、灵活的方式处理各种用户定义的类。
  2. 动态代理：在不修改源码的情况下，为现有对象增加功能（如事务、日志、性能监控）。动态代理（如 JDK 动态代理）正是基于反射机制实现方法拦截和增强的。
  3. 单元测试框架：JUnit 等测试框架需要动态地发现并运行测试类中的测试方法。
  4. 序列化与反序列化：JSON 库（如 Jackson, Gson）需要动态地将 Java 对象转换为 JSON 字符串，或将 JSON 字符串转换为 Java 对象，这涉及到运行时访问和设置对象的字段。
  5. ORM (Object-Relational Mapping)：数据库与 Java 对象的映射框架（如 Hibernate, MyBatis）需要动态地将数据库表的列映射到 Java 对象的字段，以及动态调用 Getter/Setter 方法。
  6. IDE 和调试工具：开发环境需要在运行时检查对象的结构和状态。

二、反射的核心类

Java 反射 API 主要集中在 java.lang.reflect 包中，以下是几个最核心的类：

  1. Class：Class 类的实例代表正在运行的 Java 应用程序中的类和接口。它是反射的入口点，提供了一系列方法来获取类的构造器、方法、字段等信息。
  2. Constructor：提供了关于类的单个构造器的信息以及对它的访问权限。可以用来创建类的实例。
  3. Method：提供了关于类或接口的单个方法的信息以及对它的访问权限。可以用来调用方法。
  4. Field：提供了关于类或接口的单个字段（成员变量）的信息以及对它的访问权限。可以用来获取或设置字段的值。
  5. Modifier：一个静态工具类，提供了解析类、字段、方法或构造器访问修饰符（如 public, private, static, final）的方法。

三、获取 Class 对象的三种方式

Class 对象是反射的基础，通过它才能获取到类的其他成员信息。

  1. Class.forName(String className)：

    • 通过类的全限定名（包名.类名）获取 Class 对象。
    • 通常用于外部配置中需要加载类的情况。
    • 会触发类的初始化。
    • 可能抛出 ClassNotFoundException。
    1
    2
    Class<?> clazz1 = Class.forName("java.lang.String");
    System.out.println("Class.forName: " + clazz1.getName());

  2. 类名.class：

    • 通过类字面量获取 Class 对象。
    • 当在编译时已知类时使用，性能更好，更安全。
    • 不会触发类的初始化。
    1
    2
    Class<?> clazz2 = String.class;
    System.out.println("类名.class: " + clazz2.getName());

  3. 对象实例.getClass()：

    • 通过一个对象的实例获取其 Class 对象。
    • 当已经有对象实例时使用。
    • 获取的是该对象的运行时类型。
    1
    2
    3
    String str = "hello";
    Class<?> clazz3 = str.getClass();
    System.out.println("对象实例.getClass(): " + clazz3.getName());

示意图：获取 Class 对象

四、通过反射创建对象

获取到 Class 对象后，可以通过以下两种方式创建类的实例：

  1. 通过 Class.newInstance() (已废弃，Java 9+)：

    • 调用类的无参构造器来创建实例。
    • 如果类没有无参构造器，会抛出 InstantiationException。
    • 如果构造器是私有的，会抛出 IllegalAccessException。
    • 不推荐使用，因为它不会处理检查型异常，且性能不如 Constructor.newInstance()。
    1
    2
    // 不推荐使用，但了解原理
    // String s = (String) clazz1.newInstance(); // String 没有无参构造器，会报错

  2. 通过 Constructor 对象 (推荐)：

    • 获取类的构造器，然后调用 newInstance() 方法创建实例。
    • 可以调用有参构造器，并且可以处理各种访问修饰符。

示例：通过反射创建对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

class User {
    private String name;
    private int age;

    public User() {
        System.out.println("User() constructor called.");
    }

    public User(String name) {
        this.name = name;
        System.out.println("User(String name) constructor called. Name: " + name);
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("User(String name, int age) constructor called. Name: " + name + ", Age: " + age);
    }

    public String getName() { return name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + '}';
    }
}

public class ReflectCreateObject {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {

        Class<?> userClass = Class.forName("User");

        // 1. 获取无参构造器并创建实例
        Constructor<?> noArgsConstructor = userClass.getConstructor();
        User user1 = (User) noArgsConstructor.newInstance(); // 等同于 new User()
        System.out.println("User1: " + user1);
        System.out.println("--------------------");

        // 2. 获取有参构造器 (String) 并创建实例
        Constructor<?> singleArgConstructor = userClass.getConstructor(String.class);
        User user2 = (User) singleArgConstructor.newInstance("Alice"); // 等同于 new User("Alice")
        System.out.println("User2: " + user2);
        System.out.println("--------------------");

        // 3. 获取有参构造器 (String, int) 并创建实例
        Constructor<?> multiArgConstructor = userClass.getConstructor(String.class, int.class);
        User user3 = (User) multiArgConstructor.newInstance("Bob", 25); // 等同于 new User("Bob", 25)
        System.out.println("User3: " + user3);
        System.out.println("--------------------");

        // 4. 处理私有构造器 (若有)
        // Constructor<?> privateConstructor = userClass.getDeclaredConstructor(参数类型...);
        // privateConstructor.setAccessible(true); // 暴力访问
        // User user4 = (User) privateConstructor.newInstance(参数值...);
    }
}

五、通过反射访问字段

通过 Field 对象可以获取和设置类的成员变量。

  • getField(String name)：获取 public 字段。
  • getDeclaredField(String name)：获取所有字段，包括 private, protected, default，但不包括继承的字段。
  • getFields()：获取所有 public 字段（包括继承的）。
  • getDeclaredFields()：获取当前类声明的所有字段（不包括继承的）。

对于非 public 字段，需要调用 setAccessible(true) 来“暴力访问”。

示例：通过反射访问字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.lang.reflect.Field;

public class ReflectAccessField {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchFieldException, IllegalAccessException, InstantiationException {

        Class<?> userClass = Class.forName("User");
        User user = (User) userClass.getDeclaredConstructor().newInstance(); // 创建一个 User 实例

        // 1. 访问 public 字段 (如果 User 类有 public 字段)
        // Field publicField = userClass.getField("publicFieldName");
        // System.out.println("Public Field Value: " + publicField.get(user));

        // 2. 访问 private 字段 'name'
        Field nameField = userClass.getDeclaredField("name");
        nameField.setAccessible(true); // 暴力访问私有字段
        nameField.set(user, "Charlie"); // 设置字段值
        String name = (String) nameField.get(user); // 获取字段值
        System.out.println("Modified Name: " + name); // Charlie
        System.out.println("User object after name change: " + user); // User{name='Charlie', age=0}

        // 3. 访问 private 字段 'age'
        Field ageField = userClass.getDeclaredField("age");
        ageField.setAccessible(true); // 暴力访问
        ageField.set(user, 30); // 设置 age
        int age = ageField.getInt(user); // 获取 int 类型字段值
        System.out.println("Modified Age: " + age); // 30
        System.out.println("User object after age change: " + user); // User{name='Charlie', age=30}
    }
}

六、通过反射调用方法

通过 Method 对象可以调用类的方法。

  • getMethod(String name, Class<?>... parameterTypes)：获取 public 方法。
  • getDeclaredMethod(String name, Class<?>... parameterTypes)：获取所有方法，包括 private, protected, default，但不包括继承的方法。
  • getMethods()：获取所有 public 方法（包括继承的）。
  • getDeclaredMethods()：获取当前类声明的所有方法（不包括继承的）。

对于非 public 方法，也需要调用 setAccessible(true) 来“暴力访问”。

示例：通过反射调用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.lang.reflect.Method;

public class ReflectInvokeMethod {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {

        Class<?> userClass = Class.forName("User");
        User user = (User) userClass.getDeclaredConstructor().newInstance();
        user.setAge(28); // 预设一个 age 值

        // 1. 调用 public 的 getter 方法
        Method getNameMethod = userClass.getMethod("getName");
        String name = (String) getNameMethod.invoke(user); // 调用 user 对象的 getName() 方法
        System.out.println("Get Name (initial, should be null): " + name); // null

        // 2. 调用 public 的 setter 方法
        Method setNameMethod = userClass.getMethod("setName", String.class); // 获取 setName(String) 方法
        setNameMethod.invoke(user, "David"); // 调用 user 对象的 setName("David") 方法
        System.out.println("User after setName: " + user); // User{name='David', age=28}

        // 3. 调用带参数和返回值的 public 方法 (例如获取年龄)
        Method getAgeMethod = userClass.getMethod("getAge");
        int age = (int) getAgeMethod.invoke(user);
        System.out.println("Get Age: " + age); // 28

        // 4. 调用私有方法 (假设 User 类有一个私有方法 `private void secretMethod(String msg)`)
        // Method secretMethod = userClass.getDeclaredMethod("secretMethod", String.class);
        // secretMethod.setAccessible(true); // 暴力访问
        // secretMethod.invoke(user, "This is a secret!");
    }
}

七、反射的优缺点与适用场景

7.1 优点：

  1. 动态性：允许程序在运行时探索和操作类的内部结构，极大地增强了程序的灵活性和扩展性。
  2. 解耦：在框架设计中，反射使得组件之间的依赖可以在运行时建立，降低了耦合度。
  3. 扩展性：可以方便地集成第三方库，或者实现插件化、热部署等功能。

7.2 缺点：

  1. 性能开销：反射操作通常比直接的 Java 代码执行慢，因为它们涉及运行时类型检查、方法查找和调用，以及 JIT 编译器优化受限。
  2. 安全性问题：setAccessible(true) 允许访问类的私有成员，可能会破坏封装性，带来安全隐患。
  3. 维护困难：反射代码通常比普通代码更难阅读和理解，增加了维护成本。
  4. 编译时检查缺失：反射绕过了编译时类型检查，因此类型错误只有在运行时才会发现，增加了调试难度。
  5. 异常处理复杂：反射操作会抛出多种受检异常，需要进行适当的异常处理。

7.3 适用场景：

  • 框架和库开发：Spring、Hibernate、JUnit、JSON 库等大量使用反射来实现其核心功能。
  • IDE 和调试工具：需要检查运行时对象的结构。
  • 动态代理：如 AOP (面向切面编程) 实现。
  • 序列化与反序列化：如 XML/JSON 解析器。
  • 插件化开发：动态加载和实例化插件。

八、总结

Java 反射是 Java 语言中一项强大且复杂的特性，它赋予了程序在运行时“审视”自身的能力。虽然它带来了性能开销和潜在的安全风险，但其提供的动态性和灵活性是构建复杂框架和实现高级编程范式的基石。正确理解和谨慎使用反射，能够极大地扩展 Java 应用程序的功能和适用范围，但务必权衡其优缺点，避免滥用。