【Java】反射

最新推荐文章于 2025-06-13 15:06:56 发布

茉菇

最新推荐文章于 2025-06-13 15:06:56 发布

阅读量645

点赞数 12

分类专栏： Java 文章标签： java python 开发语言

本文链接：https://blog.youkuaiyun.com/weixin_42364929/article/details/145987504

版权

Java 专栏收录该内容

7 篇文章

订阅专栏

一、概述

Java 反射（Reflection）机制是 Java 语言的一项核心特性，允许程序在运行时动态地获取类的信息、操作类的属性和方法，甚至修改类的行为。这种能力突破了传统静态编程的限制，是框架开发（如 Spring、Hibernate）和动态代理的核心基础。

1、反射的核心概念

动态性：在编译期无需知道类的具体信息，运行时动态加载和操作类。
元数据（Metadata）：反射通过访问类的元数据（如类名、方法、字段、注解等）实现动态操作。
核心类：反射 API 集中在 java.lang.reflect 包中，关键类包括：
- Class：表示类的元数据。
- Field：表示类的字段（成员变量）。
- Method：表示类的方法。
- Constructor：表示类的构造方法。

2、反射的核心步骤

(1) 获取类的 Class 对象

反射操作的起点是获取类的 Class 对象。三种方式：

// 方式1：通过类名.class
Class<?> clazz1 = String.class;

// 方式2：通过对象.getClass()
String str = "Hello";
Class<?> clazz2 = str.getClass();

// 方式3：通过Class.forName()（最常用）
Class<?> clazz3 = Class.forName("java.lang.String");

(2) 动态创建对象

通过 Class 对象创建实例：

Class<?> clazz = Class.forName("java.lang.String");
// 使用默认无参构造器
String str1 = (String) clazz.newInstance(); // 已过时，推荐用 getDeclaredConstructor().newInstance()
// 使用带参构造器
Constructor<?> constructor = clazz.getConstructor(String.class);
String str2 = (String) constructor.newInstance("Hello");

(3) 操作字段（Field）

获取并修改字段的值（包括私有字段）：

class Person {
    private String name;
    public int age;
}

// 获取字段
Class<?> clazz = Person.class;
Field nameField = clazz.getDeclaredField("name");
Field ageField = clazz.getField("age");

// 暴力访问私有字段
nameField.setAccessible(true); // 突破私有权限限制

// 设置字段值
Person person = new Person();
nameField.set(person, "Alice");
ageField.setInt(person, 25);

// 获取字段值
System.out.println(nameField.get(person)); // 输出 Alice

(4) 调用方法（Method）

动态调用方法（包括私有方法）：

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

// 获取方法
Class<?> clazz = Calculator.class;
Method addMethod = clazz.getDeclaredMethod("add", int.class, int.class);
Method multiplyMethod = clazz.getMethod("multiply", int.class, int.class);

// 调用方法
Calculator calculator = new Calculator();
addMethod.setAccessible(true); // 访问私有方法
int sum = (int) addMethod.invoke(calculator, 2, 3); // sum = 5
int product = (int) multiplyMethod.invoke(calculator, 2, 3); // product = 6

(5) 操作泛型

反射可以绕过泛型检查（泛型擦除的补偿）：

List<Integer> list = new ArrayList<>();
list.add(1);

// 通过反射添加String类型的元素
Method addMethod = list.getClass().getMethod("add", Object.class);
addMethod.invoke(list, "Hello"); // 绕过泛型检查

System.out.println(list); // 输出 [1, Hello]

3、反射的应用场景

(1) 框架开发

Spring IoC 容器：通过反射动态创建 Bean 并注入依赖。
Hibernate/MyBatis：将数据库结果集映射到 Java 对象。
动态代理（如 JDK Proxy）：生成代理类并拦截方法调用。

(2) 动态加载类

插件化开发：根据配置文件或用户输入加载不同的类。
类浏览器：动态分析类的结构（如 IDE 的代码提示）。

(3) 测试工具

单元测试框架（如 JUnit）：通过反射调用测试方法。
Mock 框架（如 Mockito）：动态生成模拟对象。

(4) 序列化与反序列化

JSON/XML 解析库（如 Jackson、Gson）：通过反射将数据绑定到对象。

4、反射的优缺点

优点：

灵活性：动态操作类、方法和字段。
扩展性：支持插件化架构和框架开发。
突破封装：可以访问私有成员（需谨慎使用）。

缺点：

性能开销：反射操作比直接调用慢（JVM 无法优化反射代码）。
安全问题：可能绕过权限检查，破坏封装性。
代码可读性差：反射代码通常难以理解和维护。

5、反射的性能优化

缓存 Class 对象：避免重复调用 Class.forName()。
使用 setAccessible(true)：减少安全检查次数。
优先使用原生代码：在性能敏感场景避免反射。

6、示例：简单依赖注入（模拟 Spring IoC）

class Container {
    private Map<String, Object> beans = new HashMap<>();

    public void registerBean(String name, Class<?> clazz) throws Exception {
        // 创建实例（假设类有无参构造器）
        Object instance = clazz.getDeclaredConstructor().newInstance();
        beans.put(name, instance);
    }

    public Object getBean(String name) {
        return beans.get(name);
    }
}

// 使用示例
Container container = new Container();
container.registerBean("userService", UserService.class);
UserService userService = (UserService) container.getBean("userService");