Java 反射机制详解：从原理到实战

2.2 获取类信息

public class ClassInfoDemo {
    public static void main(String[] args) {
        Class<String> clazz = String.class;
        
        // 类名
        System.out.println("简单名：" + clazz.getSimpleName()); // String
        System.out.println("全限定名：" + clazz.getName()); // java.lang.String
        System.out.println("规范名：" + clazz.getCanonicalName()); // java.lang.String
        
        // 包信息
        System.out.println("包名：" + clazz.getPackage().getName()); // java.lang
        
        // 父类
        System.out.println("父类：" + clazz.getSuperclass()); // class java.lang.Object
        
        // 接口
        Class<?>[] interfaces = clazz.getInterfaces();
        for (Class<?> i : interfaces) {
            System.out.println("接口：" + i.getName());
        }
        
        // 修饰符
        int modifiers = clazz.getModifiers();
        System.out.println("是否 public: " + java.lang.reflect.Modifier.isPublic(modifiers));
        System.out.println("是否 final: " + java.lang.reflect.Modifier.isFinal(modifiers));
        System.out.println("是否 abstract: " + java.lang.reflect.Modifier.isAbstract(modifiers));
        System.out.println("是否 interface: " + java.lang.reflect.Modifier.isInterface(modifiers));
    }
}

2.3 判断类型

public class TypeCheckDemo {
    public static void main(String[] args) {
        Class<String> clazz = String.class;
        
        // 判断类型
        System.out.println("是否接口：" + clazz.isInterface()); // false
        System.out.println("是否数组：" + clazz.isArray()); // false
        System.out.println("是否枚举：" + clazz.isEnum()); // false
        System.out.println("是否注解：" + clazz.isAnnotation()); // false
        System.out.println("是否基本类型：" + clazz.isPrimitive()); // false
        
        // 数组类型
        Class<?> arrayClass = int[].class;
        System.out.println("是否数组：" + arrayClass.isArray()); // true
        System.out.println("数组元素类型：" + arrayClass.getComponentType()); // int
        
        // 判断继承关系
        System.out.println("String 是否是 Object 的子类：" + Object.class.isAssignableFrom(String.class)); // true
        System.out.println("Object 是否是 String 的子类：" + String.class.isAssignableFrom(Object.class)); // false
    }
}

2.4 获取注解

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Author {
    String name();
    String date();
}

@Author(name = "张三", date = "2025-01-01")
class MyClass {}

public class AnnotationDemo {
    public static void main(String[] args) {
        Class<MyClass> clazz = MyClass.class;
        
        // 判断是否有注解
        if (clazz.isAnnotationPresent(Author.class)) {
            // 获取注解
            Author author = clazz.getAnnotation(Author.class);
            System.out.println("作者：" + author.name());
            System.out.println("日期：" + author.date());
        }
        
        // 获取所有注解
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation ann : annotations) {
            System.out.println("注解：" + ann);
        }
    }
}

三、构造方法反射

3.1 获取构造方法

import java.lang.reflect.Constructor;

public class Person {
    private String name;
    private int age;
    
    public Person() {}
    
    public Person(String name) { this.name = name; }
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    private Person(int age) { this.age = age; }
}

public class ConstructorDemo {
    public static void main(String[] args) throws Exception {
        Class<Person> clazz = Person.class;
        
        // 获取所有 public 构造方法
        Constructor<?>[] constructors = clazz.getConstructors();
        for (Constructor<?> c : constructors) {
            System.out.println(c);
        }
        
        // 获取所有构造方法（包括私有）
        Constructor<?>[] allConstructors = clazz.getDeclaredConstructors();
        
        // 获取指定参数的 public 构造方法
        Constructor<Person> constructor1 = clazz.getConstructor(); // 无参
        Constructor<Person> constructor2 = clazz.getConstructor(String.class); // 一参
        Constructor<Person> constructor3 = clazz.getConstructor(String.class, int.class); // 两参
        
        // 获取私有构造方法
        Constructor<Person> privateConstructor = clazz.getDeclaredConstructor(int.class);
    }
}

3.2 创建对象

public class CreateInstanceDemo {
    public static void main(String[] args) throws Exception {
        Class<Person> clazz = Person.class;
        
        // 方式 1：使用无参构造
        Person p1 = clazz.getDeclaredConstructor().newInstance();
        
        // 方式 2：使用有参构造
        Constructor<Person> constructor = clazz.getConstructor(String.class, int.class);
        Person p2 = constructor.newInstance("张三", 25);
        
        // 方式 3：访问私有构造方法
        Constructor<Person> privateConstructor = clazz.getDeclaredConstructor(int.class);
        privateConstructor.setAccessible(true); // 取消访问检查
        Person p3 = privateConstructor.newInstance(30);
        
        System.out.println(p2);
    }
}

四、字段反射

4.1 获取字段

import java.lang.reflect.Field;

public class Student {
    public String name;
    private int age;
    protected String school;
    static String country = "China";
}

public class FieldDemo {
    public static void main(String[] args) throws Exception {
        Class<Student> clazz = Student.class;
        
        // 获取所有 public 字段（包括继承的）
        Field[] fields = clazz.getFields();
        
        // 获取所有字段（不包括继承的）
        Field[] allFields = clazz.getDeclaredFields();
        
        // 获取指定字段
        Field nameField = clazz.getField("name"); // public 字段
        Field ageField = clazz.getDeclaredField("age"); // 私有字段
        
        // 字段信息
        System.out.println("字段名：" + nameField.getName());
        System.out.println("字段类型：" + nameField.getType());
        System.out.println("修饰符：" + nameField.getModifiers());
    }
}

4.2 访问和修改字段

public class FieldAccessDemo {
    public static void main(String[] args) throws Exception {
        Student student = new Student();
        Class<Student> clazz = Student.class;
        
        // 访问 public 字段
        Field nameField = clazz.getField("name");
        nameField.set(student, "李四");
        String name = (String) nameField.get(student);
        System.out.println("姓名：" + name);
        
        // 访问 private 字段
        Field ageField = clazz.getDeclaredField("age");
        ageField.setAccessible(true); // 取消访问检查
        ageField.set(student, 20);
        int age = (int) ageField.get(student);
        System.out.println("年龄：" + age);
        
        // 访问静态字段
        Field countryField = clazz.getDeclaredField("country");
        countryField.set(null, "USA"); // 静态字段传 null
        String country = (String) countryField.get(null);
        System.out.println("国家：" + country);
    }
}

五、方法反射

5.1 获取方法

import java.lang.reflect.Method;
import java.util.Arrays;

public class Calculator {
    public int add(int a, int b) { return a + b; }
    private int subtract(int a, int b) { return a - b; }
    public static int multiply(int a, int b) { return a * b; }
}

public class MethodDemo {
    public static void main(String[] args) throws Exception {
        Class<Calculator> clazz = Calculator.class;
        
        // 获取所有 public 方法（包括继承的）
        Method[] methods = clazz.getMethods();
        
        // 获取所有方法（不包括继承的）
        Method[] allMethods = clazz.getDeclaredMethods();
        
        // 获取指定方法
        Method addMethod = clazz.getMethod("add", int.class, int.class);
        Method subtractMethod = clazz.getDeclaredMethod("subtract", int.class, int.class);
        
        // 方法信息
        System.out.println("方法名：" + addMethod.getName());
        System.out.println("返回类型：" + addMethod.getReturnType());
        System.out.println("参数类型：" + Arrays.toString(addMethod.getParameterTypes()));
    }
}

5.2 调用方法

public class MethodInvokeDemo {
    public static void main(String[] args) throws Exception {
        Calculator calculator = new Calculator();
        Class<Calculator> clazz = Calculator.class;
        
        // 调用 public 方法
        Method addMethod = clazz.getMethod("add", int.class, int.class);
        Object result1 = addMethod.invoke(calculator, 10, 20);
        System.out.println("10 + 20 = " + result1); // 30
        
        // 调用 private 方法
        Method subtractMethod = clazz.getDeclaredMethod("subtract", int.class, int.class);
        subtractMethod.setAccessible(true);
        Object result2 = subtractMethod.invoke(calculator, 30, 10);
        System.out.println("30 - 10 = " + result2); // 20
        
        // 调用静态方法
        Method multiplyMethod = clazz.getMethod("multiply", int.class, int.class);
        Object result3 = multiplyMethod.invoke(null, 5, 6); // 静态方法传 null
        System.out.println("5 * 6 = " + result3); // 30
    }
}

六、实战案例

6.1 通用对象打印器

import java.lang.reflect.Field;

public class ObjectPrinter {
    public static void print(Object obj) throws Exception {
        Class<?> clazz = obj.getClass();
        System.out.println("=== " + clazz.getSimpleName() + " ===");
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            String name = field.getName();
            Object value = field.get(obj);
            System.out.println(name + " = " + value);
        }
    }
    
    public static void main(String[] args) throws Exception {
        Person person = new Person("张三", 25);
        print(person);
    }
}

6.2 简单依赖注入

import java.lang.annotation.*;
import java.lang.reflect.Field;

// 自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Inject {}

// 服务类
class UserService {
    public void save() { System.out.println("保存用户"); }
}

// 控制器类
class UserController {
    @Inject
    private UserService userService;
    
    public void register() { userService.save(); }
}

// 依赖注入容器
public class SimpleContainer {
    public static void inject(Object obj) throws Exception {
        Class<?> clazz = obj.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Inject.class)) {
                field.setAccessible(true);
                Class<?> fieldType = field.getType();
                Object instance = fieldType.getDeclaredConstructor().newInstance();
                field.set(obj, instance);
            }
        }
    }
    
    public static void main(String[] args) throws Exception {
        UserController controller = new UserController();
        inject(controller); // 注入依赖
        controller.register(); // 保存用户
    }
}

6.3 通用对象复制

import java.lang.reflect.Field;

public class ObjectCopier {
    public static <T> T copy(T source) throws Exception {
        Class<?> clazz = source.getClass();
        @SuppressWarnings("unchecked")
        T target = (T) clazz.getDeclaredConstructor().newInstance();
        
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            Object value = field.get(source);
            field.set(target, value);
        }
        return target;
    }
    
    public static void main(String[] args) throws Exception {
        Person original = new Person("张三", 25);
        Person copied = copy(original);
        System.out.println("原对象：" + original);
        System.out.println("复制对象：" + copied);
        System.out.println("是否同一对象：" + (original == copied)); // false
    }
}

6.4 动态代理

import java.lang.reflect.*;

// 接口
interface UserDao {
    void save();
    void delete();
}

// 实现类
class UserDaoImpl implements UserDao {
    @Override
    public void save() { System.out.println("保存用户"); }
    
    @Override
    public void delete() { System.out.println("删除用户"); }
}

// 代理处理器
class LogHandler implements InvocationHandler {
    private Object target;
    
    public LogHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(">>> 方法开始：" + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("<<< 方法结束：" + method.getName());
        return result;
    }
}

// 测试
public class ProxyDemo {
    public static void main(String[] args) {
        UserDao userDao = new UserDaoImpl();
        
        // 创建代理对象
        UserDao proxy = (UserDao) Proxy.newProxyInstance(
            userDao.getClass().getClassLoader(),
            userDao.getClass().getInterfaces(),
            new LogHandler(userDao)
        );
        
        // 调用代理方法
        proxy.save();
        System.out.println();
        proxy.delete();
    }
}

6.5 配置文件加载

import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.Properties;

// 配置类
class AppConfig {
    private String appName;
    private int port;
    private String database;
    // getters...
}

// 配置加载器
public class ConfigLoader {
    public static <T> T load(Class<T> clazz, String configFile) throws Exception {
        // 读取配置文件
        Properties props = new Properties();
        InputStream is = clazz.getClassLoader().getResourceAsStream(configFile);
        props.load(is);
        
        // 创建对象
        T instance = clazz.getDeclaredConstructor().newInstance();
        
        // 设置字段值
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            String key = field.getName();
            String value = props.getProperty(key);
            if (value != null) {
                // 类型转换
                if (field.getType() == int.class) {
                    field.set(instance, Integer.parseInt(value));
                } else if (field.getType() == String.class) {
                    field.set(instance, value);
                }
            }
        }
        return instance;
    }
}

七、高级应用

7.1 泛型信息获取

import java.lang.reflect.*;
import java.util.*;

public class GenericDemo {
    // 带泛型的字段
    private List<String> stringList;
    private Map<String, Integer> map;
    
    // 带泛型的方法
    public List<String> getList() { return null; }
    public <T> T genericMethod(T param) { return param; }
    
    public static void main(String[] args) throws Exception {
        Class<GenericDemo> clazz = GenericDemo.class;
        
        // 1. 获取字段的泛型类型
        Field field = clazz.getDeclaredField("stringList");
        Type genericType = field.getGenericType();
        if (genericType instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) genericType;
            System.out.println("原始类型：" + pt.getRawType()); // interface java.util.List
            Type[] actualTypes = pt.getActualTypeArguments();
            System.out.println("泛型参数：" + actualTypes[0]); // class java.lang.String
        }
        
        // 2. 获取 Map 的泛型类型
        Field mapField = clazz.getDeclaredField("map");
        Type mapType = mapField.getGenericType();
        if (mapType instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) mapType;
            Type[] types = pt.getActualTypeArguments();
            System.out.println("Key 类型：" + types[0]); // class java.lang.String
            System.out.println("Value 类型：" + types[1]); // class java.lang.Integer
        }
        
        // 3. 获取方法返回值的泛型类型
        Method method = clazz.getMethod("getList");
        Type returnType = method.getGenericReturnType();
        System.out.println("返回类型：" + returnType);
        
        // 4. 获取方法的泛型参数
        Method genericMethod = clazz.getMethod("genericMethod", Object.class);
        TypeVariable<?>[] typeParams = genericMethod.getTypeParameters();
        for (TypeVariable<?> tv : typeParams) {
            System.out.println("泛型参数名：" + tv.getName()); // T
        }
    }
}

7.2 数组操作

import java.lang.reflect.Array;

public class ArrayReflectionDemo {
    public static void main(String[] args) {
        // 1. 创建数组
        Object intArray = Array.newInstance(int.class, 5);
        Array.set(intArray, 0, 10);
        Array.set(intArray, 1, 20);
        System.out.println("第一个元素：" + Array.get(intArray, 0)); // 10
        System.out.println("数组长度：" + Array.getLength(intArray)); // 5
        
        // 2. 创建多维数组
        Object multiArray = Array.newInstance(int.class, 3, 4);
        System.out.println("多维数组类型：" + multiArray.getClass()); // class [[I
        
        // 3. 动态扩展数组
        int[] oldArray = {1, 2, 3};
        int[] newArray = (int[]) expandArray(oldArray, 6);
        System.out.println("新数组长度：" + newArray.length); // 6
        System.out.println("第一个元素：" + newArray[0]); // 1
    }
    
    // 通用数组扩展方法
    public static Object expandArray(Object oldArray, int newLength) {
        Class<?> componentType = oldArray.getClass().getComponentType();
        int oldLength = Array.getLength(oldArray);
        Object newArray = Array.newInstance(componentType, newLength);
        // 复制旧数组内容
        System.arraycopy(oldArray, 0, newArray, 0, Math.min(oldLength, newLength));
        return newArray;
    }
}

7.3 性能优化

import java.lang.reflect.*;
import java.util.concurrent.ConcurrentHashMap;

public class ReflectionCache {
    // 缓存 Class 对象
    private static final ConcurrentHashMap<String, Class<?>> classCache = new ConcurrentHashMap<>();
    // 缓存 Method 对象
    private static final ConcurrentHashMap<String, Method> methodCache = new ConcurrentHashMap<>();
    // 缓存 Field 对象
    private static final ConcurrentHashMap<String, Field> fieldCache = new ConcurrentHashMap<>();
    
    // 获取 Class（带缓存）
    public static Class<?> getClass(String className) throws ClassNotFoundException {
        return classCache.computeIfAbsent(className, key -> {
            try {
                return Class.forName(key);
            } catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
        });
    }
    
    // 获取 Method（带缓存）
    public static Method getMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) {
        String key = clazz.getName() + "#" + methodName;
        return methodCache.computeIfAbsent(key, k -> {
            try {
                Method method = clazz.getMethod(methodName, paramTypes);
                method.setAccessible(true); // 提前设置，避免每次调用
                return method;
            } catch (NoSuchMethodException e) {
                throw new RuntimeException(e);
            }
        });
    }
    
    // 获取 Field（带缓存）
    public static Field getField(Class<?> clazz, String fieldName) {
        String key = clazz.getName() + "#" + fieldName;
        return fieldCache.computeIfAbsent(key, k -> {
            try {
                Field field = clazz.getDeclaredField(fieldName);
                field.setAccessible(true);
                return field;
            } catch (NoSuchFieldException e) {
                throw new RuntimeException(e);
            }
        });
    }
    
    // 性能测试
    public static void main(String[] args) throws Exception {
        Class<String> clazz = String.class;
        Method method = clazz.getMethod("length");
        
        // 测试 1：不使用缓存
        long start1 = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            Method m = clazz.getMethod("length");
        }
        long end1 = System.nanoTime();
        System.out.println("不使用缓存：" + (end1 - start1) / 1000000 + "ms");
        
        // 测试 2：使用缓存
        long start2 = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            Method m = getMethod(clazz, "length");
        }
        long end2 = System.nanoTime();
        System.out.println("使用缓存：" + (end2 - start2) / 1000000 + "ms");
    }
}

7.4 方法句柄（MethodHandle）

MethodHandle 是 JDK 7 引入的，性能比反射更好。

import java.lang.invoke.*;

public class MethodHandleDemo {
    public static void main(String[] args) throws Throwable {
        // 1. 获取 MethodHandles.Lookup
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        
        // 2. 查找方法
        MethodType mt = MethodType.methodType(int.class);
        MethodHandle mh = lookup.findVirtual(String.class, "length", mt);
        
        // 3. 调用方法
        String str = "Hello";
        int length = (int) mh.invoke(str);
        System.out.println("字符串长度：" + length); // 5
        
        // 4. 性能对比
        performanceTest();
    }
    
    public static void performanceTest() throws Throwable {
        String str = "Hello World";
        int iterations = 10000000;
        
        // 直接调用
        long start1 = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            int len = str.length();
        }
        long end1 = System.nanoTime();
        System.out.println("直接调用：" + (end1 - start1) / 1000000 + "ms");
        
        // 反射调用
        Method method = String.class.getMethod("length");
        long start2 = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            int len = (int) method.invoke(str);
        }
        long end2 = System.nanoTime();
        System.out.println("反射调用：" + (end2 - start2) / 1000000 + "ms");
        
        // MethodHandle 调用
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodType mt = MethodType.methodType(int.class);
        MethodHandle mh = lookup.findVirtual(String.class, "length", mt);
        long start3 = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            int len = (int) mh.invoke(str);
        }
        long end3 = System.nanoTime();
        System.out.println("MethodHandle: " + (end3 - start3) / 1000000 + "ms");
    }
}

性能对比结果（参考）：

• 直接调用：~5ms
• MethodHandle：~50ms（比直接调用慢 10 倍）
• 反射调用：~500ms（比直接调用慢 100 倍）

7.5 简单 ORM 框架

import java.lang.annotation.*;
import java.lang.reflect.*;
import java.sql.*;
import java.util.*;

// 表名注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Table {
    String value();
}

// 列名注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Column {
    String value();
}

// 实体类
@Table("users")
class User {
    @Column("id")
    private Long id;
    
    @Column("username")
    private String username;
    
    @Column("age")
    private Integer age;
    
    // getters and setters...
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
    
    @Override
    public String toString() {
        return "User{id=" + id + ", username='" + username + "', age=" + age + "}";
    }
}

// 简单 ORM
public class SimpleORM {
    // 查询所有
    public static <T> List<T> findAll(Class<T> clazz, Connection conn) throws Exception {
        Table table = clazz.getAnnotation(Table.class);
        String tableName = table.value();
        
        String sql = "SELECT * FROM " + tableName;
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery(sql);
        
        List<T> results = new ArrayList<>();
        while (rs.next()) {
            T obj = mapResultSet(clazz, rs);
            results.add(obj);
        }
        rs.close();
        stmt.close();
        return results;
    }
    
    // 根据 ID 查询
    public static <T> T findById(Class<T> clazz, Connection conn, Object id) throws Exception {
        Table table = clazz.getAnnotation(Table.class);
        String tableName = table.value();
        String sql = "SELECT * FROM " + tableName + " WHERE id = ?";
        PreparedStatement pstmt = conn.prepareStatement(sql);
        pstmt.setObject(1, id);
        ResultSet rs = pstmt.executeQuery();
        
        T result = null;
        if (rs.next()) {
            result = mapResultSet(clazz, rs);
        }
        rs.close();
        pstmt.close();
        return result;
    }
    
    // 插入
    public static <T> void insert(T obj, Connection conn) throws Exception {
        Class<?> clazz = obj.getClass();
        Table table = clazz.getAnnotation(Table.class);
        String tableName = table.value();
        
        StringBuilder columns = new StringBuilder();
        StringBuilder values = new StringBuilder();
        List<Object> params = new ArrayList<>();
        
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Column.class)) {
                Column column = field.getAnnotation(Column.class);
                field.setAccessible(true);
                Object value = field.get(obj);
                if (value != null) {
                    if (columns.length() > 0) {
                        columns.append(", ");
                        values.append(", ");
                    }
                    columns.append(column.value());
                    values.append("?");
                    params.add(value);
                }
            }
        }
        
        String sql = "INSERT INTO " + tableName + " (" + columns + ") VALUES (" + values + ")";
        PreparedStatement pstmt = conn.prepareStatement(sql);
        for (int i = 0; i < params.size(); i++) {
            pstmt.setObject(i + 1, params.get(i));
        }
        pstmt.executeUpdate();
        pstmt.close();
    }
    
    // 映射 ResultSet 到对象
    private static <T> T mapResultSet(Class<T> clazz, ResultSet rs) throws Exception {
        T obj = clazz.getDeclaredConstructor().newInstance();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Column.class)) {
                Column column = field.getAnnotation(Column.class);
                String columnName = column.value();
                field.setAccessible(true);
                Object value = rs.getObject(columnName);
                field.set(obj, value);
            }
        }
        return obj;
    }
    
    // 测试（需要数据库连接）
    public static void main(String[] args) {
        System.out.println("简单 ORM 框架示例");
        System.out.println("使用反射实现对象关系映射");
    }
}

7.6 Bean 拷贝工具

import java.lang.reflect.Field;
import java.util.*;

public class BeanUtils {
    // 浅拷贝
    public static <T> T shallowCopy(T source) throws Exception {
        if (source == null) return null;
        @SuppressWarnings("unchecked")
        Class<T> clazz = (Class<T>) source.getClass();
        T target = clazz.getDeclaredConstructor().newInstance();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            Object value = field.get(source);
            field.set(target, value);
        }
        return target;
    }
    
    // 属性拷贝（不同类型）
    public static void copyProperties(Object source, Object target) throws Exception {
        if (source == null || target == null) return;
        Class<?> sourceClass = source.getClass();
        Class<?> targetClass = target.getClass();
        Field[] sourceFields = sourceClass.getDeclaredFields();
        Map<String, Field> targetFieldMap = new HashMap<>();
        
        for (Field field : targetClass.getDeclaredFields()) {
            targetFieldMap.put(field.getName(), field);
        }
        
        for (Field sourceField : sourceFields) {
            String fieldName = sourceField.getName();
            Field targetField = targetFieldMap.get(fieldName);
            if (targetField != null && sourceField.getType() == targetField.getType()) {
                sourceField.setAccessible(true);
                targetField.setAccessible(true);
                Object value = sourceField.get(source);
                targetField.set(target, value);
            }
        }
    }
    
    // 对象转 Map
    public static Map<String, Object> toMap(Object obj) throws Exception {
        if (obj == null) return null;
        Map<String, Object> map = new HashMap<>();
        Class<?> clazz = obj.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            String key = field.getName();
            Object value = field.get(obj);
            map.put(key, value);
        }
        return map;
    }
    
    // Map 转对象
    public static <T> T fromMap(Map<String, Object> map, Class<T> clazz) throws Exception {
        if (map == null) return null;
        T obj = clazz.getDeclaredConstructor().newInstance();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            String key = field.getName();
            Object value = map.get(key);
            if (value != null) {
                field.set(obj, value);
            }
        }
        return obj;
    }
    
    public static void main(String[] args) throws Exception {
        User user = new User();
        user.setId(1L);
        user.setUsername("张三");
        user.setAge(25);
        
        Map<String, Object> map = toMap(user);
        System.out.println("对象转 Map: " + map);
        
        User user2 = fromMap(map, User.class);
        System.out.println("Map 转对象：" + user2);
    }
}

八、最佳实践与注意事项

8.1 性能优化建议

public class ReflectionBestPractices {
    // ❌ 不推荐：每次都获取 Method
    public void badPractice(Object obj) throws Exception {
        for (int i = 0; i < 10000; i++) {
            Method method = obj.getClass().getMethod("toString");
            method.invoke(obj);
        }
    }
    
    // ✅ 推荐：缓存 Method 对象
    private static final Map<String, Method> methodCache = new ConcurrentHashMap<>();
    
    public void goodPractice(Object obj) throws Exception {
        Method method = methodCache.computeIfAbsent(
            obj.getClass().getName() + "#toString",
            k -> {
                try {
                    Method m = obj.getClass().getMethod("toString");
                    m.setAccessible(true); // 提前设置
                    return m;
                } catch (NoSuchMethodException e) {
                    throw new RuntimeException(e);
                }
            }
        );
        for (int i = 0; i < 10000; i++) {
            method.invoke(obj);
        }
    }
}

性能优化要点：

1. 缓存 Class、Method、Field、Constructor 对象
2. 提前调用 setAccessible(true)，避免每次检查
3. 使用 MethodHandle 替代反射（JDK 7+）
4. 避免在循环中使用反射
5. 考虑使用字节码生成（如 ASM、Javassist）

8.2 异常处理

反射操作会抛出多种异常，需要妥善处理。

public class ReflectionExceptionHandling {
    public static Object invokeMethod(Object obj, String methodName, Object... args) {
        try {
            Class<?> clazz = obj.getClass();
            Class<?>[] paramTypes = new Class[args.length];
            for (int i = 0; i < args.length; i++) {
                paramTypes[i] = args[i].getClass();
            }
            Method method = clazz.getMethod(methodName, paramTypes);
            return method.invoke(obj, args);
        } catch (NoSuchMethodException e) {
            System.err.println("方法不存在：" + methodName);
        } catch (IllegalAccessException e) {
            System.err.println("无法访问方法：" + methodName);
        } catch (InvocationTargetException e) {
            System.err.println("方法执行异常：" + e.getCause());
        } catch (Exception e) {
            System.err.println("未知异常：" + e.getMessage());
        }
        return null;
    }
}

常见异常：

8.3 安全性考虑

public class ReflectionSecurity {
    public static void main(String[] args) {
        // 1. 检查 SecurityManager
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            try {
                sm.checkPermission(new ReflectPermission("suppressAccessChecks"));
            } catch (SecurityException e) {
                System.err.println("没有反射权限");
                return;
            }
        }
        
        // 2. 谨慎使用 setAccessible
        try {
            Field field = SomeClass.class.getDeclaredField("privateField");
            // ⚠️ 破坏封装性，谨慎使用
            field.setAccessible(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        // 3. 验证输入
        String className = getUserInput();
        if (!isValidClassName(className)) {
            throw new IllegalArgumentException("非法类名");
        }
    }
    
    private static boolean isValidClassName(String className) {
        // 白名单验证
        return className.matches("^[a-zA-Z0-9.]+$");
    }
    
    private static String getUserInput() {
        return "com.example.MyClass";
    }
    
    static class SomeClass {
        private String privateField;
    }
}

安全建议：

• 不要反射用户输入的类名（可能导致代码注入）
• 谨慎使用 setAccessible(true)
• 在生产环境考虑禁用反射
• 使用白名单验证类名和方法名
• 注意 SecurityManager 的限制

8.4 线程安全

public class ReflectionThreadSafety {
    // ✅ 线程安全：使用 ConcurrentHashMap
    private static final ConcurrentHashMap<String, Method> cache = new ConcurrentHashMap<>();
    
    // ❌ 不安全：HashMap 在多线程下可能出问题
    // private static final HashMap<String, Method> cache = new HashMap<>();
    
    public static Method getMethod(Class<?> clazz, String methodName) throws NoSuchMethodException {
        String key = clazz.getName() + "#" + methodName;
        return cache.computeIfAbsent(key, k -> {
            try {
                return clazz.getMethod(methodName);
            } catch (NoSuchMethodException e) {
                throw new RuntimeException(e);
            }
        });
    }
}

8.5 常见陷阱

public class ReflectionPitfalls {
    public static void main(String[] args) throws Exception {
        // 陷阱 1：基本类型 vs 包装类型
        Method method1 = MyClass.class.getMethod("method", int.class); // ✅ 正确
        // Method method2 = MyClass.class.getMethod("method", Integer.class); // ❌ 错误
        
        // 陷阱 2：数组类型
        Method arrayMethod = MyClass.class.getMethod("arrayMethod", int[].class); // ✅ 正确
        // Method arrayMethod2 = MyClass.class.getMethod("arrayMethod", int.class); // ❌ 错误
        
        // 陷阱 3：可变参数
        Method varargMethod = MyClass.class.getMethod("varargMethod", String[].class); // ✅ 正确
        
        // 陷阱 4：私有构造方法
        Constructor<MyClass> constructor = MyClass.class.getDeclaredConstructor();
        constructor.setAccessible(true); // 必须设置
        MyClass obj = constructor.newInstance();
        
        // 陷阱 5：静态字段/方法
        Field staticField = MyClass.class.getDeclaredField("staticField");
        staticField.set(null, "new value"); // 静态字段传 null
        
        Method staticMethod = MyClass.class.getMethod("staticMethod");
        staticMethod.invoke(null); // 静态方法传 null
    }
    
    static class MyClass {
        private static String staticField = "old value";
        private MyClass() {}
        
        public void method(int param) {}
        public void arrayMethod(int[] array) {}
        public void varargMethod(String... args) {}
        
        public static void staticMethod() {}
    }
}

九、快速参考

反射核心类

常用方法对比

获取 Class 对象的三种方式

// 方式 1：类名.class（编译时已知）
Class<String> clazz1 = String.class;

// 方式 2：对象.getClass()（运行时获取）
String str = "Hello";
Class<? extends String> clazz2 = str.getClass();

// 方式 3：Class.forName()（动态加载）
Class<?> clazz3 = Class.forName("java.lang.String");

反射操作速查表

性能对比（参考值）

最佳实践清单

✅ 推荐做法：

• 仅在必要时使用反射（框架、工具类）
• 缓存 Class、Method、Field 对象
• 提前调用 setAccessible(true)
• 使用 try-catch 处理所有可能的异常
• 考虑使用 MethodHandle 替代反射
• 在性能敏感场景避免使用反射
• 使用白名单验证类名和方法名
• 充分的代码注释和文档

❌ 避免做法：

• 不要在循环中频繁使用反射
• 不要反射用户输入的类名（安全风险）
• 不要忽略异常处理
• 不要在性能关键路径使用反射
• 不要过度使用 setAccessible(true)
• 不要在多线程环境使用非线程安全的缓存

十、总结

本文档全面介绍了 Java 反射机制的核心知识：

1. 反射概述

• 反射的定义和核心功能
• 应用场景（框架开发、动态代理、注解处理）
• 优缺点分析

2. 获取 Class 对象

• 三种获取方式及使用场景
• 获取类信息（名称、包、父类、接口、修饰符）
• 类型判断和继承关系检查
• 注解获取

3. 构造方法反射

• 获取构造方法（public 和 private）
• 创建对象的多种方式
• 访问私有构造方法

4. 字段反射

• 获取字段信息
• 访问和修改字段值
• 处理静态字段

5. 方法反射

• 获取方法信息
• 调用方法（public、private、static）
• 方法参数和返回值处理

6. 实战案例

• 通用对象打印器
• 简单依赖注入
• 通用对象复制
• 动态代理
• 配置文件加载

7. 高级应用

• 泛型信息获取
• 数组操作
• 性能优化（缓存机制）
• MethodHandle（性能更好的替代方案）
• 简单 ORM 框架
• Bean 拷贝工具

8. 最佳实践

• 性能优化建议
• 异常处理
• 安全性考虑
• 线程安全
• 常见陷阱

关键要点

使用场景

学习路径

1. 入门阶段：掌握 Class 对象获取、基本的字段和方法操作
2. 进阶阶段：理解构造方法、注解、泛型信息获取
3. 高级阶段：掌握性能优化、MethodHandle、动态代理
4. 实战阶段：实现简单框架（依赖注入、ORM）

推荐资源

• Java 官方文档 - Reflection API
• 《Java 核心技术》卷 1 - 第 5 章
• 《Effective Java》- 第 65 条：优先考虑接口而不是反射
• 《深入理解 Java 虚拟机》- 第 7 章

下一步

• 深入学习动态代理（JDK 动态代理、CGLIB）
• 了解字节码操作（ASM、Javassist、ByteBuddy）
• 学习注解处理器（APT）
• 研究主流框架的反射应用（Spring、MyBatis）
• 实践：开发一个简单的依赖注入容器

记住：反射是一把双刃剑，强大但有代价。在追求灵活性的同时，要权衡性能、安全性和代码可维护性。只在真正需要的地方使用反射，并遵循最佳实践。