Java 反射机制详解：从原理到实践

注意：对于基本类型（如 int），不能使用 forName。Java 22 引入了 Class.forPrimitiveName() 来解决此问题。

对象.getClass() 实例获取
通过 Object 类中的 getClass() 方法获取，适用于已有对象实例的场景。

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

类名.class 静态获取
这种方式不会触发类的静态初始化块，是最安全、最直接的方式。

Class<String> stringClazz = String.class;
Class<int[]> arrayClazz = int[].class; // 数组也有 Class 对象
Class<Void> voidClazz = void.class; // void 也有

2.3 类加载的幕后故事

当 JVM 遇到 new、Class.forName() 等指令时，类加载器会将 .class 字节码文件加载到内存，经过加载（Loading）、链接（Linking）、初始化（Initializing） 三步，最终在方法区形成 Class 对象。反射正是通过操作这个 Class 对象来影响程序行为的。

第三章 解剖类：反射的核心 API

java.lang.reflect 包提供了核心的反射类，它们被统称为反射镜像类，分别对应类的不同组成部分。

3.1 操作构造方法（Constructor）：创建对象

通过反射创建对象主要有两种方式：

• Class.newInstance()：已过时。它只能调用无参构造方法，且会将任何异常包装为 InvocationTargetException。
• Constructor.newInstance()：推荐使用。可以选择调用任意参数（包括私有）的构造方法。

public class User {
    private String name;

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

    public void sayHi() {
        System.out.println("Hi, " + name);
    }
}

// 反射调用带参构造
try {
    Class<?> userClass = Class.forName("com.example.User");
    // 获取指定参数类型的构造方法
    Constructor<?> constructor = userClass.getConstructor(String.class);
    // 通过构造器创建实例
    User user = (User) constructor.newInstance("Alice");
    user.sayHi();
} catch (Exception e) {
    e.printStackTrace();
}

3.2 操作字段（Field）：访问与修改属性

Field 类提供了对类属性的访问能力。getField(s) 只能获取 public 字段（包括从父类继承的），而 getDeclaredField(s) 可以获取当前类所有访问级别的字段（不包括父类）。

要访问私有字段，必须调用 field.setAccessible(true) 来关闭 Java 的访问安全检查。

import java.lang.reflect.Field;

class Person {
    private int age; // 私有字段
}

public class FieldExample {
    public static void main(String[] args) throws Exception {
        Person person = new Person();
        Class<?> clazz = person.getClass();
        Field ageField = clazz.getDeclaredField("age");
        ageField.setAccessible(true); // 暴力破解封装

        // 获取值
        int age = (int) ageField.get(person);
        System.out.println("原始年龄：" + age);

        // 设置值
        ageField.set(person, 25);
        System.out.println("新年龄：" + ageField.get(person));
    }
}

这个例子展示了反射如何绕过 private 限制，这正是许多框架（如 ORM）填充数据的基础，但也带来了安全隐患。

3.3 操作方法（Method）：动态调用

Method 类代表类中的方法，通过 invoke 方法执行。

import java.lang.reflect.Method;

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

    private void secret() {
        System.out.println("秘密方法被调用！");
    }
}

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

        // 调用公有方法
        Method addMethod = clazz.getMethod("add", int.class, int.class);
        Object result = addMethod.invoke(calc, 10, 20); // invoke 返回 Object
        System.out.println("10 + 20 = " + result);

        // 调用私有方法
        Method secretMethod = clazz.getDeclaredMethod("secret");
        secretMethod.setAccessible(true);
        secretMethod.invoke(calc);
    }
}

invoke 方法的第一个参数是目标对象，静态方法则传入 null。

第四章 深入进阶：反射的高级特性

4.1 动态代理：AOP 的基石

动态代理允许在运行时动态创建一组接口的代理实例。Java 通过 java.lang.reflect.Proxy 类和 InvocationHandler 接口实现。

其核心思想是：当调用代理对象的方法时，代码并不会直接执行目标方法，而是被重定向到 InvocationHandler 的 invoke 方法中。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface Hello {
    void sayHello(String name);
}

class HelloImpl implements Hello {
    public void sayHello(String name) {
        System.out.println("Hello, " + name);
    }
}

// 日志处理器
class LogHandler implements InvocationHandler {
    private Object target;

    public LogHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("[LOG] 方法 " + method.getName() + " 开始执行");
        Object result = method.invoke(target, args); // 调用真实对象的方法
        System.out.println("[LOG] 方法 " + method.getName() + " 执行结束");
        return result;
    }
}

public class DynamicProxyDemo {
    public static void main(String[] args) {
        Hello hello = new HelloImpl();
        InvocationHandler handler = new LogHandler(hello);

        // 创建代理对象
        Hello proxyHello = (Hello) Proxy.newProxyInstance(
            hello.getClass().getClassLoader(),
            hello.getClass().getInterfaces(),
            handler
        );
        proxyHello.sayHello("World");
    }
}

Spring 的声明式事务、拦截器等都是基于这种机制实现的。

4.2 操作数组与泛型

• 获取泛型信息：由于 Java 的泛型存在类型擦除，运行时通常无法获得泛型的具体类型。但通过反射获取 Field 或 Method 的 getGenericType()，可以获取泛型参数信息（用于解析类似 List<String> 的情况）。

动态创建数组：java.lang.reflect.Array 类提供了动态创建和访问数组元素的静态方法。

int[] intArray = (int[]) Array.newInstance(int.class, 5);
Array.set(intArray, 0, 100);
System.out.println(Array.get(intArray, 0));

4.3 注解的处理

注解（Annotation）本身只是元数据，其解析工作完全依赖反射。框架通过反射获取类、方法或字段上的注解，然后根据注解的值采取相应的行为。

@Retention(RetentionPolicy.RUNTIME) // 必须声明为运行时可见
@interface MyBean {
    String value() default "";
}

@MyBean("userService")
class UserService {}

// 解析注解
Class<?> clazz = UserService.class;
if (clazz.isAnnotationPresent(MyBean.class)) {
    MyBean annotation = clazz.getAnnotation(MyBean.class);
    System.out.println("Bean Name: " + annotation.value()); // 输出 userService
}

第五章 性能考量与优化策略

5.1 反射为何慢？

反射的性能开销主要来自以下几个方面：

1. 动态查找：方法名、字段名在运行时需要解析，编译器无法进行优化（如方法内联）。
2. 类型检查：反射调用涉及大量的动态类型检查。
3. 自动装箱：反射 API 处理基本类型时频繁进行装箱和拆箱操作。
4. 安全检查：每次调用 getMethod 或 invoke 时，JVM 都会检查方法或字段的访问权限。
5. 堆内存消耗：Method、Field 等对象的生成和缓存也会占用资源。

5.2 性能优化技巧

1. 适当使用 setAccessible(true)：对于需要频繁访问的私有字段或方法，提前调用 setAccessible(true) 可以跳过后续的访问安全检查，显著提升速度。
2. 优先使用 MethodHandle：Java 7 引入的 java.lang.invoke.MethodHandle（以及 Java 9 的 VarHandle）提供了比反射更高效、更简洁的底层方法调用方式，被称为'更快的反射'。

缓存元数据：避免在循环中反复调用 getMethod()，应将其缓存为静态变量。

// 不推荐
for (int i = 0; i < 1000; i++) {
    Method m = clazz.getMethod("doWork");
    m.invoke(obj);
}

// 推荐
Method m = clazz.getMethod("doWork");
m.setAccessible(true); // 关闭安全检查
for (int i = 0; i < 1000; i++) {
    m.invoke(obj);
}

5.3 性能对比

在大量循环调用下，直接调用 > MethodHandle > 缓存后的反射 > 未缓存的反射。因此，性能敏感的核心代码中应避免使用反射。

第六章 安全风险与现代 Java 的演进

6.1 反射的安全隐患

反射的'暴力访问'能力是一把双刃剑：

• 绕过私有 API：恶意代码可以利用反射调用本应不可访问的内部 API，破坏数据完整性。
• 特权提升：通过反射修改 final 字段的值（虽然有一定限制，但仍可能做到）。
• 内存马注入：在 Java Web 应用中，攻击者常利用反射修改请求处理链，动态注入恶意组件（即'内存马'），实现持久化控制且难以查杀。

6.2 Java 模块系统（Module）的限制

为了解决反射带来的安全问题，Java 9 引入的模块化系统（JPMS） 加强了对反射的控制。

• 如果一个类被封装在模块中，并且没有显式导出（exports）或开放（opens）给其他模块，那么即使使用 setAccessible(true)，也无法通过反射访问其私有成员。
• 这为 JDK 内部代码提供了强力的封装，例如无法再通过反射操作 java.lang.String 内部的 value 数组。

第七章 实战应用：手写迷你 IoC 容器

为了加深理解，我们通过反射模拟一个最简单的 IoC（控制反转）容器。

需求：根据配置文件（简单模拟为类名字符串），自动创建对象并注入属性。

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class MiniIoCContainer {
    private Map<String, Object> beanMap = new HashMap<>();

    // 注册 Bean：根据类名创建实例并存储
    public void registerBean(String beanName, String className) throws Exception {
        Class<?> clazz = Class.forName(className);
        Object instance = clazz.getDeclaredConstructor().newInstance(); // 调用无参构造
        beanMap.put(beanName, instance);
    }

    // 执行依赖注入：查找所有 Field，如果 field 的类型在 beanMap 中有实例，则注入
    public void doAutowired() throws Exception {
        for (Object bean : beanMap.values()) {
            Class<?> clazz = bean.getClass();
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                // 模拟 @Autowired 注解
                if (field.isAnnotationPresent(Autowired.class)) {
                    field.setAccessible(true);
                    Class<?> fieldType = field.getType();
                    // 根据类型查找 bean (简化逻辑)
                    for (Object dependency : beanMap.values()) {
                        if (fieldType.isInstance(dependency)) {
                            field.set(bean, dependency); // 注入
                            break;
                        }
                    }
                }
            }
        }
    }

    public <T> T getBean(String beanName, Class<T> type) {
        return type.cast(beanMap.get(beanName)); // 使用 Class.cast 进行安全转换
    }

    // 自定义注解
    @Retention(RetentionPolicy.RUNTIME)
    @interface Autoworld {}
}

这段代码虽然简陋，但体现了 Spring IoC 的核心思想：通过反射解析类、实例化对象并注入依赖。