Java 反射机制详解

Java 反射（Reflection）是 Java 语言的一种强大特性，允许程序在运行时动态地获取类的信息并操作类或对象的属性、方法和构造器。反射机制打破了 Java 的封装性，但也提供了极大的灵活性，常用于框架开发、动态代理、注解处理等场景。

---

目录

1. 反射的基本概念
2. 反射的核心类
3. 获取 Class 对象
4. 获取类的信息
5. 操作类的属性
6. 调用类的方法
7. 操作构造器
8. 反射的应用场景
9. 反射的优缺点
10. 代码示例

---

反射的基本概念

反射是指在程序运行时，能够动态地获取类的信息（如类名、方法、属性等），并能够操作这些信息。通过反射，可以在运行时创建对象、调用方法、访问属性，而不需要在编译时知道类的具体信息。

---

反射的核心类

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

• Class：表示类的类型信息。
• Field：表示类的属性。
• Method：表示类的方法。
• Constructor：表示类的构造器。

---

获取 Class 对象

要使用反射，首先需要获取类的 Class 对象。以下是获取 Class 对象的三种方式：

1. 通过 Class.forName()

Class<?> clazz = Class.forName("java.lang.String");

2. 通过 .class 语法

Class<?> clazz = String.class;

3. 通过对象的 getClass() 方法

String str = "Hello";
Class<?> clazz = str.getClass();

---

获取类的信息

通过 Class 对象，可以获取类的名称、修饰符、父类、接口等信息。

示例代码

Class<?> clazz = String.class;

// 获取类名
System.out.println("类名: " + clazz.getName());

// 获取简单类名
System.out.println("简单类名: " + clazz.getSimpleName());

// 获取修饰符
int modifiers = clazz.getModifiers();
System.out.println("修饰符: " + Modifier.toString(modifiers));

// 获取父类
Class<?> superClass = clazz.getSuperclass();
System.out.println("父类: " + superClass.getName());

// 获取实现的接口
Class<?>[] interfaces = clazz.getInterfaces();
for (Class<?> iface : interfaces) {
    System.out.println("接口: " + iface.getName());
}

---

操作类的属性

通过反射可以获取和修改类的属性（包括私有属性）。

示例代码

class Person {
    private String name;
    public int age;

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

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        Person person = new Person("Alice", 25);
        Class<?> clazz = person.getClass();

        // 获取公有属性
        Field ageField = clazz.getField("age");
        System.out.println("age: " + ageField.get(person));

        // 获取私有属性
        Field nameField = clazz.getDeclaredField("name");
        nameField.setAccessible(true); // 设置可访问
        System.out.println("name: " + nameField.get(person));

        // 修改属性值
        nameField.set(person, "Bob");
        System.out.println("修改后的 name: " + nameField.get(person));
    }
}

---

调用类的方法

通过反射可以调用类的方法（包括私有方法）。

示例代码

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    private int multiply(int a, int b) {
        return a * b;
    }
}

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        Calculator calculator = new Calculator();
        Class<?> clazz = calculator.getClass();

        // 调用公有方法
        Method addMethod = clazz.getMethod("add", int.class, int.class);
        int result = (int) addMethod.invoke(calculator, 2, 3);
        System.out.println("add 结果: " + result);

        // 调用私有方法
        Method multiplyMethod = clazz.getDeclaredMethod("multiply", int.class, int.class);
        multiplyMethod.setAccessible(true); // 设置可访问
        int product = (int) multiplyMethod.invoke(calculator, 2, 3);
        System.out.println("multiply 结果: " + product);
    }
}

---

操作构造器

通过反射可以创建类的实例。

示例代码

class Person {
    private String name;
    private int age;

    public Person() {}

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

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

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Person.class;

        // 获取无参构造器
        Constructor<?> constructor1 = clazz.getConstructor();
        Person person1 = (Person) constructor1.newInstance();
        System.out.println("无参构造器创建的对象: " + person1);

        // 获取带参构造器
        Constructor<?> constructor2 = clazz.getConstructor(String.class, int.class);
        Person person2 = (Person) constructor2.newInstance("Alice", 25);
        System.out.println("带参构造器创建的对象: " + person2);
    }
}

---

反射的应用场景

1. 框架开发：如 Spring 框架通过反射实现依赖注入。
2. 动态代理：如 JDK 动态代理通过反射调用目标方法。
3. 注解处理：通过反射读取注解信息。
4. 工具类：如 Apache Commons BeanUtils 使用反射操作 JavaBean。

---

反射的优缺点

优点

• 灵活性：可以在运行时动态操作类和对象。
• 通用性：适用于编写通用框架和工具。

缺点

• 性能开销：反射操作比直接调用慢。
• 安全性问题：可以访问私有成员，破坏封装性。
• 代码可读性差：反射代码通常难以理解和维护。

---

代码示例

以下是一个完整的反射示例，展示了如何获取类信息、操作属性和方法、调用构造器：

import java.lang.reflect.*;

class Student {
    private String name;
    public int age;

    public Student() {}

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

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    private void secretMethod() {
        System.out.println("这是一个私有方法");
    }
}

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        // 获取 Class 对象
        Class<?> clazz = Class.forName("Student");

        // 创建对象
        Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
        Object student = constructor.newInstance("Alice", 20);

        // 获取并修改属性
        Field nameField = clazz.getDeclaredField("name");
        nameField.setAccessible(true);
        nameField.set(student, "Bob");

        Field ageField = clazz.getField("age");
        ageField.set(student, 22);

        // 调用方法
        Method displayMethod = clazz.getMethod("display");
        displayMethod.invoke(student);

        Method secretMethod = clazz.getDeclaredMethod("secretMethod");
        secretMethod.setAccessible(true);
        secretMethod.invoke(student);
    }
}

---

通过本文，你应该对 Java 反射有了全面的了解。反射是一个强大的工具，但需要谨慎使用，避免滥用导致性能问题和代码可读性下降。