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

最新推荐文章于 2025-05-25 18:59:20 发布

FAQEW

最新推荐文章于 2025-05-25 18:59:20 发布

阅读量701

点赞数 15

分类专栏： java面试篇文章标签：开发语言 java 反射

本文链接：https://blog.csdn.net/FAQEW/article/details/148193642

版权

java面试篇专栏收录该内容

6 篇文章

订阅专栏

在 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 {
    @Override
    public void save() {
        System.out.println("保存用户数据");
    }
}

// 代理类
class ProxyHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public 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);