Flyinsky's Codes
1331 字
7 分钟
反射
2024-10-18
JavaSE

Java 反射详解与实践#

反射是Java中的一种动态机制，允许程序在运行时检查或修改类、方法、字段等的行为。通过反射，程序可以在不知道某个类的情况下动态加载、访问和操作它的成员。这种灵活性为开发提供了强大的能力，但同时也增加了复杂性和潜在的性能开销。

在这篇博客笔记中，我们将详细探讨反射的核心概念，并为每个概念提供实际的代码示例。

1. 获取Class对象#

每个Java类在运行时都有一个Class对象与之关联。可以通过以下三种方式获取：

  1. 使用Class.forName(String className)
  2. 调用对象的getClass()方法
  3. 使用类的.class属性
示例：#
public class ReflectExample {
    public static void main(String[] args) throws ClassNotFoundException {
        // 1. 使用 Class.forName() 获取
        Class<?> class1 = Class.forName("java.util.ArrayList");

        // 2. 通过对象调用 getClass() 获取
        ArrayList<String> list = new ArrayList<>();
        Class<?> class2 = list.getClass();

        // 3. 使用 .class 语法获取
        Class<?> class3 = ArrayList.class;

        System.out.println(class1.getName());
        System.out.println(class2.getName());
        System.out.println(class3.getName());
    }
}

2. 通过反射创建对象#

反射可以在运行时创建类的实例，通常使用Class类的newInstance()方法。不过，自从Java 9以来，newInstance()已被弃用，建议使用Constructor对象的newInstance()。

示例：#
import java.lang.reflect.Constructor;

public class ReflectExample {
    public static void main(String[] args) throws Exception {
        // 通过反射创建 StringBuffer 的实例
        Class<?> clazz = Class.forName("java.lang.StringBuffer");

        // 获取构造方法
        Constructor<?> constructor = clazz.getConstructor(String.class);

        // 通过构造方法创建实例
        StringBuffer buffer = (StringBuffer) constructor.newInstance("Hello, Reflection!");

        System.out.println(buffer.toString());  // 输出: Hello, Reflection!
    }
}

3. 访问和修改字段#

反射允许我们在运行时获取类的字段，甚至可以访问私有字段。通过Field类的get()和set()方法，我们可以读取和修改字段的值。

示例：#
import java.lang.reflect.Field;

class Person {
    private String name = "John";
}

public class ReflectExample {
    public static void main(String[] args) throws Exception {
        Person person = new Person();

        // 获取 Person 类的 Class 对象
        Class<?> clazz = person.getClass();

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

        // 由于字段是 private 的，先要设置为可访问
        nameField.setAccessible(true);

        // 获取字段值
        String nameValue = (String) nameField.get(person);
        System.out.println("Before modification: " + nameValue);  // 输出: John

        // 修改字段值
        nameField.set(person, "Jane");
        System.out.println("After modification: " + nameField.get(person));  // 输出: Jane
    }
}

4. 调用方法#

反射也可以让我们在运行时调用类的方法。我们可以通过Method类获取指定方法，并使用invoke()方法进行调用。

示例：#
import java.lang.reflect.Method;

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

public class ReflectExample {
    public static void main(String[] args) throws Exception {
        Calculator calculator = new Calculator();

        // 获取 Calculator 类的 Class 对象
        Class<?> clazz = calculator.getClass();

        // 获取指定的方法 add(int, int)
        Method method = clazz.getMethod("add", int.class, int.class);

        // 调用方法并传递参数
        int result = (int) method.invoke(calculator, 5, 3);
        System.out.println("Result: " + result);  // 输出: 8
    }
}

5. 访问构造方法#

除了无参构造方法，反射也允许我们访问带参构造方法，并通过它们创建对象实例。

示例：#
import java.lang.reflect.Constructor;

class Car {
    private String model;

    // 带参数的构造方法
    public Car(String model) {
        this.model = model;
    }

    public String getModel() {
        return model;
    }
}

public class ReflectExample {
    public static void main(String[] args) throws Exception {
        // 获取 Car 类的 Class 对象
        Class<?> clazz = Car.class;

        // 获取带一个参数的构造方法
        Constructor<?> constructor = clazz.getConstructor(String.class);

        // 通过构造方法创建实例
        Car car = (Car) constructor.newInstance("Tesla Model S");

        System.out.println("Car model: " + car.getModel());  // 输出: Tesla Model S
    }
}

6. 获取类的所有成员#

通过反射，我们可以列出一个类的所有构造方法、字段和方法。

示例：#
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

class Sample {
    private String field1;
    public int field2;

    public Sample() {}

    public void method1() {}
    private void method2(String param) {}
}

public class ReflectExample {
    public static void main(String[] args) {
        Class<?> clazz = Sample.class;

        // 获取所有构造方法
        Constructor<?>[] constructors = clazz.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("Constructor: " + constructor);
        }

        // 获取所有字段
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            System.out.println("Field: " + field);
        }

        // 获取所有方法
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println("Method: " + method);
        }
    }
}

7. 反射与注解#

反射可以帮助我们处理注解。我们可以在运行时检查类、方法、字段上是否存在某个注解，并获取其值。

示例：#
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;

// 定义一个注解
@Retention(RetentionPolicy.RUNTIME)
@interface TestAnnotation {
    String value();
}

class TestClass {
    @TestAnnotation("This is a test method.")
    public void annotatedMethod() {}
}

public class ReflectExample {
    public static void main(String[] args) throws Exception {
        TestClass testClass = new TestClass();

        // 获取类的Class对象
        Class<?> clazz = testClass.getClass();

        // 获取指定的方法
        Method method = clazz.getMethod("annotatedMethod");

        // 检查方法上是否有TestAnnotation注解
        if (method.isAnnotationPresent(TestAnnotation.class)) {
            // 获取注解
            TestAnnotation annotation = method.getAnnotation(TestAnnotation.class);
            System.out.println("Annotation value: " + annotation.value());  // 输出: This is a test method.
        }
    }
}

反射的优缺点#

优点：

  1. 提供了运行时动态操作类和对象的能力。
  2. 使得框架、工具可以不依赖编译时信息进行动态绑定和操作。

缺点：

  1. 性能开销较大，因为反射绕过了编译期的优化。
  2. 安全性较低，容易破坏封装性，暴露私有成员。
  3. 代码的可读性和维护性较差。

总结#

Java反射是一个非常强大的工具，特别是在框架开发中（如Spring、Hibernate等），通过它可以动态操作对象，甚至不依赖于编译时信息。但是，反射的使用也要适量，尤其在性能敏感的场景中，反射的性能开销不可忽视。

JDBC
多线程编程