当前位置：首页 > news >正文

介绍一下什么是反射（面试题详细讲解）

news 来源：原创 2025/5/25 11:47:40

在 Java 中，反射（Reflection） 是一种允许程序在运行时动态访问、检测和修改类、方法、属性等元信息的机制。通过反射，可以绕过编译时的静态类型检查，直接操作类的内部结构。以下是反射的核心原理、使用方法和典型应用场景的详细讲解：

一、反射的核心原理

反射基于 Java 的 Class 类，每个加载到 JVM 中的类（包括基本类型和数组）都会生成一个唯一的 Class 对象，该对象包含了类的完整元信息（如方法、字段、构造器等）。反射通过 Class 对象实现以下功能：

动态加载类：根据类名加载 .class 文件到内存。
动态创建对象：通过类的无参或有参构造器实例化对象。
动态调用方法：绕过编译时检查，直接调用方法。
动态访问字段：读取或修改对象的字段值（包括私有字段）。

二、反射的核心 API

1. 获取 `Class` 对象

通过类名：Class.forName("全限定类名")
通过对象：对象.getClass()
通过 .class 语法：类名.class

// 示例：获取 String 类的 Class 对象
Class<?> stringClass = Class.forName("java.lang.String");
Class<?> stringClass2 = "Hello".getClass();
Class<?> stringClass3 = String.class;

2. 动态创建对象

无参构造：clazz.newInstance()（已过时，推荐 clazz.getDeclaredConstructor().newInstance()）
有参构造：通过 Constructor 对象调用构造器。

// 创建 String 对象（无参构造）
Class<?> clazz = Class.forName("java.lang.String");
String str = (String) clazz.getDeclaredConstructor().newInstance();// 创建有参构造的对象（如 Integer）
Constructor<?> constructor = Integer.class.getConstructor(int.class);
Integer num = (Integer) constructor.newInstance(100);

3. 动态调用方法

获取方法：clazz.getMethod("方法名", 参数类型...) 或 clazz.getDeclaredMethod(...)（包括私有方法）。
调用方法：method.invoke(对象, 参数...)

// 调用 String 的 substring 方法
String str = "Hello World";
Method substringMethod = String.class.getMethod("substring", int.class, int.class);
String result = (String) substringMethod.invoke(str, 0, 5);
System.out.println(result); // 输出：Hello

4. 动态访问字段

获取字段：clazz.getField("字段名") 或 clazz.getDeclaredField(...)（包括私有字段）。
读取/修改字段值：field.get(对象) 和 field.set(对象, 值)。

// 访问私有字段（需设置 accessible=true）
class Person {private String name = "Alice";
}Person person = new Person();
Field nameField = Person.class.getDeclaredField("name");
nameField.setAccessible(true); // 绕过访问权限检查
String name = (String) nameField.get(person);
System.out.println(name); // 输出：Alice

三、反射的典型应用场景

1. 框架和库的设计

依赖注入（如 Spring）：通过反射动态创建对象并注入依赖。
ORM 框架（如 Hibernate）：将数据库记录映射到 Java 对象时，通过反射设置字段值。
注解处理器：解析和处理自定义注解。

示例：简易依赖注入

// 定义一个 Service 注解
@Retention(RetentionPolicy.RUNTIME)
@interface Service {}// 使用注解标记类
@Service
class UserService {public void saveUser() {System.out.println("用户保存成功！");}
}// 通过反射扫描并创建实例
public class Container {public static void main(String[] args) throws Exception {Class<?> clazz = Class.forName("com.example.UserService");if (clazz.isAnnotationPresent(Service.class)) {Object instance = clazz.getDeclaredConstructor().newInstance();((UserService) instance).saveUser(); // 输出：用户保存成功！}}
}

2. 动态代理和 AOP

JDK 动态代理：基于接口生成代理类，拦截方法调用。
AOP 切面编程：通过反射动态增强方法逻辑（如日志、事务）。

示例：动态代理

interface UserDao {void save();
}class UserDaoImpl implements UserDao {@Overridepublic void save() {System.out.println("保存用户数据");}
}// 代理类
class ProxyHandler implements InvocationHandler {private Object target;public ProxyHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("方法调用前记录日志");Object result = method.invoke(target, args);System.out.println("方法调用后记录日志");return result;}
}// 使用动态代理
UserDao userDao = (UserDao) Proxy.newProxyInstance(UserDao.class.getClassLoader(),new Class[]{UserDao.class},new ProxyHandler(new UserDaoImpl())
);
userDao.save(); // 输出日志 + 保存用户数据

3. 序列化与反序列化

JSON/XML 解析（如 Jackson、Gson）：通过反射读取对象的字段并生成 JSON/XML。
对象深拷贝：通过反射递归复制对象的所有字段。

示例：JSON 序列化

class User {private String name;private int age;// 省略 getter/setter
}// 使用反射实现简易 JSON 序列化
public String toJson(Object obj) throws Exception {StringBuilder json = new StringBuilder("{");Class<?> clazz = obj.getClass();Field[] fields = clazz.getDeclaredFields();for (Field field : fields) {field.setAccessible(true);json.append("\"").append(field.getName()).append("\": ");Object value = field.get(obj);if (value instanceof String) {json.append("\"").append(value).append("\"");} else {json.append(value);}json.append(", ");}json.delete(json.length()-2, json.length()).append("}");return json.toString();
}// 使用
User user = new User();
user.setName("Alice");
user.setAge(25);
System.out.println(toJson(user)); // 输出：{"name": "Alice", "age": 25}

4. 插件化开发和动态加载

热部署：通过 ClassLoader 动态加载外部 .class 文件或 JAR。
模块化系统：根据配置动态加载功能模块。

示例：动态加载类

// 自定义 ClassLoader 加载外部类
class DynamicClassLoader extends ClassLoader {public Class<?> loadClassFromFile(String path) throws Exception {byte[] classBytes = Files.readAllBytes(Paths.get(path));return defineClass(null, classBytes, 0, classBytes.length);}
}// 使用
DynamicClassLoader loader = new DynamicClassLoader();
Class<?> clazz = loader.loadClassFromFile("ExternalPlugin.class");
Object plugin = clazz.getDeclaredConstructor().newInstance();
Method runMethod = clazz.getMethod("run");
runMethod.invoke(plugin);