Java反射机制

本文详细介绍Java反射机制的基本概念、原理、使用方法以及实践.

1. 反射基础

反射（Reflection）是Java的一个强大特性，它允许程序在运行时检查和操作类、接口、字段和方法等程序元素，而不需要在编译时知道这些元素的名称。

1.1 反射的概念

反射提供了一种在运行时检查和修改程序行为的方式，使得程序可以：

• 获取任何类的信息
• 在运行时创建对象实例
• 调用任意方法
• 获取和设置对象字段的值

1.2 反射的优缺点

优点：

• 提高了程序的灵活性和扩展性
• 支持动态加载类和使用类
• 是很多框架实现的基础（如Spring、Hibernate等）

缺点：

• 性能开销较大
• 可能破坏封装性
• 代码可读性降低
• 安全限制问题

2. 获取Class对象

在Java中，Class对象是反射的入口点，有三种主要方式获取Class对象：

// 方式1：通过对象的getClass()方法
String str = "Hello";
Class<?> class1 = str.getClass();

// 方式2：通过类的class属性
Class<?> class2 = String.class;

// 方式3：通过Class.forName()方法
try {
    Class<?> class3 = Class.forName("java.lang.String");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

3. 反射的主要API

3.1 检查类信息

public class ReflectionDemo {
    public static void examineClass(Class<?> clazz) {
        System.out.println("类名: " + clazz.getName());
        System.out.println("简单类名: " + clazz.getSimpleName());
        System.out.println("包名: " + clazz.getPackage().getName());
        System.out.println("是否为接口: " + clazz.isInterface());
        System.out.println("是否为枚举: " + clazz.isEnum());
        System.out.println("是否为数组: " + clazz.isArray());
        System.out.println("父类: " + clazz.getSuperclass().getName());
        
        // 获取实现的接口
        Class<?>[] interfaces = clazz.getInterfaces();
        System.out.println("实现的接口:");
        for (Class<?> i : interfaces) {
            System.out.println("  " + i.getName());
        }
    }
}

3.2 构造函数操作

public class ConstructorReflection {
    public static void main(String[] args) {
        try {
            // 获取Class对象
            Class<?> personClass = Class.forName("com.example.Person");
            
            // 获取所有公共构造函数
            Constructor<?>[] constructors = personClass.getConstructors();
            System.out.println("公共构造函数数量: " + constructors.length);
            
            // 获取特定构造函数
            Constructor<?> constructor = personClass.getConstructor(String.class, int.class);
            
            // 使用构造函数创建对象
            Object personObj = constructor.newInstance("John", 30);
            System.out.println(personObj);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.3 字段操作

public class FieldReflection {
    public static void main(String[] args) {
        try {
            // 获取Class对象
            Class<?> personClass = Class.forName("com.example.Person");
            Object person = personClass.newInstance(); // 创建实例
            
            // 获取公共字段
            Field[] fields = personClass.getFields();
            
            // 获取所有字段（包括私有字段）
            Field[] allFields = personClass.getDeclaredFields();
            
            // 获取特定字段
            Field nameField = personClass.getDeclaredField("name");
            
            // 设置私有字段可访问
            nameField.setAccessible(true);
            
            // 设置字段值
            nameField.set(person, "Alice");
            
            // 获取字段值
            String name = (String) nameField.get(person);
            System.out.println("Name: " + name);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.4 方法操作

public class MethodReflection {
    public static void main(String[] args) {
        try {
            // 获取Class对象
            Class<?> personClass = Class.forName("com.example.Person");
            Object person = personClass.newInstance(); // 创建实例
            
            // 获取所有公共方法
            Method[] methods = personClass.getMethods();
            
            // 获取所有方法（包括私有方法）
            Method[] allMethods = personClass.getDeclaredMethods();
            
            // 获取特定方法
            Method setNameMethod = personClass.getDeclaredMethod("setName", String.class);
            Method getNameMethod = personClass.getDeclaredMethod("getName");
            
            // 调用方法
            setNameMethod.invoke(person, "Bob");
            String name = (String) getNameMethod.invoke(person);
            System.out.println("Name: " + name);
            
            // 获取方法的修饰符
            int modifiers = getNameMethod.getModifiers();
            System.out.println("Is public: " + Modifier.isPublic(modifiers));
            System.out.println("Is static: " + Modifier.isStatic(modifiers));
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4. 动态代理

反射的一个重要应用是动态代理，它允许在运行时创建一个实现了指定接口的代理类。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 接口
interface UserService {
    void addUser(String name);
    String getUser(int id);
}

// 实现类
class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("Adding user: " + name);
    }
    
    @Override
    public String getUser(int id) {
        return "User " + id;
    }
}

// 调用处理器
class LoggingHandler implements InvocationHandler {
    private Object target;
    
    public LoggingHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

// 使用动态代理
public class DynamicProxyDemo {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        
        // 创建代理
        UserService proxy = (UserService) Proxy.newProxyInstance(
            userService.getClass().getClassLoader(),
            userService.getClass().getInterfaces(),
            new LoggingHandler(userService)
        );
        
        // 调用代理方法
        proxy.addUser("John");
        String user = proxy.getUser(1);
        System.out.println("Result: " + user);
    }
}