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

在 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);

---

四、反射的优缺点

优点：

1. 动态性：运行时灵活操作类和对象。
2. 扩展性：支持插件化开发和框架设计。
3. 通用性：可编写通用工具（如序列化、测试框架）。

缺点：

1. 性能开销：反射操作比直接调用慢（JVM 无法优化）。
2. 安全问题：可绕过访问权限（如访问私有字段）。
3. 代码复杂度：反射代码可读性差，调试困难。

---

五、反射的最佳实践

1. 缓存反射对象 ：将频繁使用的 Method、Field 缓存起来，避免重复查找。
2. 避免滥用反射：优先使用接口和设计模式（如工厂模式）。
3. 处理安全检查 ：通过 setAccessible(true) 提升性能，但需谨慎使用。
4. 结合注解 ：通过注解标记需要反射处理的元素（如 Spring 的 @Autowired）。

---

六、总结

反射是 Java 中强大的动态编程工具，广泛应用于框架、动态代理、序列化等场景。合理使用反射可以大幅提升代码的灵活性和扩展性，但需权衡性能和安全问题。核心原则是：

• 需要动态性时用反射（如框架开发）。
• 追求性能时避免反射（如高频调用的核心逻辑）。