技术 Java

Java 反射（Reflection）详解

penjc2024-12-292025-03-10

Java 反射（Reflection）概念

反射是 Java 提供的一种机制，允许我们在运行时获取有关类、字段、方法等信息，并动态地操作它们。通过反射，Java 程序能够在运行时访问和修改类的结构（如字段、方法、构造方法），而不是在编译时就固定下来。

反射的基本作用

动态加载类：在程序运行时，根据类名动态加载类。
获取类信息：可以获取类的构造方法、字段、方法等详细信息。
动态创建对象：可以通过反射机制，动态创建类的对象，甚至是无法提前知道的类。
访问/修改字段和方法：可以访问类的私有字段和方法，并对其进行修改。
动态代理：反射与动态代理结合可以实现面向切面编程（AOP）等技术。

Java 反射的核心类和包

Class 类：
- Class 类是反射的核心类，它表示一个类或接口的对象。
- 通过 Class 对象可以获取类的各种信息（如字段、方法、构造方法等）。
- 获取 Class 对象的常见方法：
  - Class.forName("com.example.MyClass")：通过类名获取 Class 对象。
  - MyClass.class：通过类字面量获取 Class 对象。
  - object.getClass()：通过对象实例获取 Class 对象。
Field 类：
- 用于表示类的字段（成员变量），可以通过反射来访问或修改字段值。
Method 类：
- 用于表示类的方法，可以用来调用类的方法，甚至是私有方法。
Constructor 类：
- 用于表示类的构造方法，可以用来通过反射创建对象。
java.lang.reflect 包：
- 提供了所有与反射相关的类（如 Class, Field, Method, Constructor 等）。

获取 `Class` 对象的方式

在反射中，获取 Class 对象是第一步，只有通过 Class 对象，我们才能进一步操作类的字段、方法等信息。

通过类名直接获取 Class 对象：
1
Class<?> clazz = MyClass.class;

通过 getClass() 获取 Class 对象：

1 2	MyClass obj = new MyClass(); Class<?> clazz = obj.getClass();

通过 Class.forName() 获取 Class 对象：

1	Class<?> clazz = Class.forName("com.example.MyClass");

反射的常见操作

获取类的字段（Field）

通过反射可以获取类的字段（包括私有字段）。

Field field = clazz.getDeclaredField("fieldName");
field.setAccessible(true);  // 如果字段是私有的，可以通过这个方法绕过访问限制
Object value = field.get(obj);  // 获取字段值
field.set(obj, value);  // 设置字段值

获取类的方法（Method）

通过反射可以获取类的所有方法，并动态调用。

1
2
3

Method method = clazz.getDeclaredMethod("methodName", ParameterType.class);
method.setAccessible(true);  // 如果方法是私有的，可以通过这个方法绕过访问限制
method.invoke(obj, params);  // 调用方法

获取类的构造方法（Constructor）

通过反射可以获取类的构造方法，并通过它创建对象。

1
2
3

Constructor<?> constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true);
Object obj = constructor.newInstance();  // 创建对象

访问静态字段和方法

静态字段和方法属于类，而不是对象，因此可以直接通过类来访问。

1
2
3

Field staticField = clazz.getDeclaredField("staticField");
staticField.setAccessible(true);
Object value = staticField.get(null);  // 对于静态字段，第一个参数为 null

动态代理：
- Java 动态代理通过反射创建一个代理对象，并在方法调用时拦截它们。可以实现 AOP（面向切面编程）等技术。

反射在具体业务场景中的应用

我们先理解了反射的基本概念和使用方法，现在来看看在具体业务场景中，反射如何发挥作用。

1. Spring 框架中的反射应用

Spring 框架是一个使用广泛的 Java 企业级框架，它依赖反射来实现核心功能，尤其是在依赖注入（DI）和面向切面编程（AOP）中。

1.1 依赖注入（DI）

在 Spring 中，依赖注入允许开发人员在类之间注入依赖关系，而不需要手动创建对象。Spring 使用反射来动态地识别类中的字段、构造函数、方法等，并将适当的对象注入。

例如，Spring 会自动扫描类中标注了 @Autowired 的字段，并使用反射将需要的实例注入到这些字段中。你无需手动创建和注入对象，Spring 会自动完成。

@Component
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public void getUserById(int id) {
        userRepository.findById(id);
    }
}

Spring 在启动时，通过反射检查 UserService 类，发现 userRepository 字段上有 @Autowired 注解，并根据类型自动注入 UserRepository 实例。

1.2 面向切面编程（AOP）

Spring AOP 使用反射来创建代理对象，并为目标对象的方法添加横切逻辑（例如日志记录、事务管理等）。Spring 使用反射实现了方法的拦截，并在方法执行前后插入额外的操作。

public class LoggingAspect {
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("方法 " + joinPoint.getSignature().getName() + " 被调用");
    }

    public void logAfter(JoinPoint joinPoint) {
        System.out.println("方法 " + joinPoint.getSignature().getName() + " 执行完毕");
    }
}

在 Spring AOP 中，反射用于在运行时创建代理对象，并动态绑定切面（如日志、事务）到目标方法。

2. 插件架构中的反射应用

在需要灵活扩展功能的应用程序中，反射是实现插件架构的一个重要工具。插件类在运行时动态加载，避免了编译时对插件的依赖。

假设你要构建一个简单的插件系统，用户可以在运行时上传插件，并由系统加载并执行这些插件。通过反射，系统可以动态地加载插件类并调用其方法。

public interface Plugin {
    void execute();
}

public class PluginA implements Plugin {
    public void execute() {
        System.out.println("执行插件 A");
    }
}

public class PluginLoader {
    public static void loadPlugin(String pluginClassName) throws Exception {
        // 动态加载插件类
        Class<?> pluginClass = Class.forName(pluginClassName);
        
        // 创建插件对象
        Plugin plugin = (Plugin) pluginClass.getDeclaredConstructor().newInstance();
        
        // 调用插件的方法
        Method method = pluginClass.getMethod("execute");
        method.invoke(plugin);
    }

    public static void main(String[] args) throws Exception {
        loadPlugin("PluginA");  // 动态加载并执行 PluginA
    }
}

在这个场景中，反射使得系统能够根据用户提供的插件类名动态加载插件并执行方法。

3. 数据库 ORM 框架中的反射应用

在 ORM（对象关系映射）框架中，反射通常用于将数据库表的记录映射到 Java 对象，或者将 Java 对象的内容存储到数据库表中。反射允许我们动态地读取类的字段和方法，并将它们与数据库中的数据进行映射。

例如，假设我们有一个 User 类和一个 users 表，通过反射可以动态地将表中的数据映射到 User 对象。

public class User {
    private int id;
    private String name;

    // getter 和 setter
}

public class UserDAO {
    public User getUserById(int id) throws Exception {
        // 查询数据库并返回结果
        ResultSet rs = // 执行 SQL 查询
        
        // 使用反射创建 User 对象
        User user = User.class.getDeclaredConstructor().newInstance();
        
        // 使用反射将数据库字段映射到对象字段
        Field idField = User.class.getDeclaredField("id");
        idField.setAccessible(true);
        idField.set(user, rs.getInt("id"));


        
        Field nameField = User.class.getDeclaredField("name");
        nameField.setAccessible(true);
        nameField.set(user, rs.getString("name"));
        
        return user;
    }
}