📚 第13章 Java反射机制

13.1 反射基础概念

13.1.1 什么是反射

反射（Reflection）是Java语言的一个重要特性，它允许程序在运行时检查和操作类、接口、字段和方法的信息。通过反射，我们可以：

• 在运行时获取类的信息
• 动态创建对象
• 动态调用方法
• 动态访问和修改字段
• 处理注解

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

// 反射基础演示
public class ReflectionBasics {
    
    public static void main(String[] args) {
        // 演示反射的基本概念
        demonstrateBasicReflection();
        
        // 演示Class对象的获取方式
        demonstrateClassObjectCreation();
        
        // 演示类信息获取
        demonstrateClassInformation();
    }
    
    // 基本反射演示
    public static void demonstrateBasicReflection() {
        System.out.println("=== 反射基础演示 ===");
        
        try {
            // 1. 获取Class对象
            Class<?> stringClass = String.class;
            
            // 2. 获取类名
            System.out.println("类名: " + stringClass.getName());
            System.out.println("简单类名: " + stringClass.getSimpleName());
            
            // 3. 获取包名
            System.out.println("包名: " + stringClass.getPackage().getName());
            
            // 4. 获取修饰符
            int modifiers = stringClass.getModifiers();
            System.out.println("是否为public: " + Modifier.isPublic(modifiers));
            System.out.println("是否为final: " + Modifier.isFinal(modifiers));
            
            // 5. 获取父类
            Class<?> superClass = stringClass.getSuperclass();
            System.out.println("父类: " + (superClass != null ? superClass.getName() : "无"));
            
            // 6. 获取接口
            Class<?>[] interfaces = stringClass.getInterfaces();
            System.out.println("实现的接口数量: " + interfaces.length);
            for (Class<?> intf : interfaces) {
                System.out.println("  - " + intf.getName());
            }
            
        } catch (Exception e) {
            System.err.println("反射操作出错: " + e.getMessage());
        }
    }
    
    // Class对象获取方式演示
    public static void demonstrateClassObjectCreation() {
        System.out.println("\n=== Class对象获取方式 ===");
        
        try {
            // 方式1: 通过类名.class
            Class<?> class1 = String.class;
            System.out.println("方式1 - 类名.class: " + class1.getName());
            
            // 方式2: 通过对象.getClass()
            String str = "Hello";
            Class<?> class2 = str.getClass();
            System.out.println("方式2 - 对象.getClass(): " + class2.getName());
            
            // 方式3: 通过Class.forName()
            Class<?> class3 = Class.forName("java.lang.String");
            System.out.println("方式3 - Class.forName(): " + class3.getName());
            
            // 验证三种方式获取的是同一个Class对象
            System.out.println("三种方式获取的是同一个对象: " + 
                             (class1 == class2 && class2 == class3));
            
            // 基本类型的Class对象
            System.out.println("\n基本类型的Class对象:");
            System.out.println("int.class: " + int.class.getName());
            System.out.println("Integer.TYPE: " + Integer.TYPE.getName());
            System.out.println("int.class == Integer.TYPE: " + (int.class == Integer.TYPE));
            
            // 数组类型的Class对象
            System.out.println("\n数组类型的Class对象:");
            Class<?> intArrayClass = int[].class;
            System.out.println("int[].class: " + intArrayClass.getName());
            System.out.println("是否为数组: " + intArrayClass.isArray());
            System.out.println("数组元素类型: " + intArrayClass.getComponentType().getName());
            
        } catch (ClassNotFoundException e) {
            System.err.println("类未找到: " + e.getMessage());
        }
    }
    
    // 类信息获取演示
    public static void demonstrateClassInformation() {
        System.out.println("\n=== 类信息获取演示 ===");
        
        try {
            Class<?> listClass = ArrayList.class;
            
            // 获取类的详细信息
            System.out.println("类的完整信息:");
            System.out.println("  类名: " + listClass.getName());
            System.out.println("  简单名: " + listClass.getSimpleName());
            System.out.println("  规范名: " + listClass.getCanonicalName());
            
            // 类型检查
            System.out.println("\n类型检查:");
            System.out.println("  是否为接口: " + listClass.isInterface());
            System.out.println("  是否为抽象类: " + Modifier.isAbstract(listClass.getModifiers()));
            System.out.println("  是否为枚举: " + listClass.isEnum());
            System.out.println("  是否为注解: " + listClass.isAnnotation());
            System.out.println("  是否为数组: " + listClass.isArray());
            System.out.println("  是否为基本类型: " + listClass.isPrimitive());
            
            // 继承关系
            System.out.println("\n继承关系:");
            Class<?> currentClass = listClass;
            int level = 0;
            while (currentClass != null) {
                System.out.println("  " + "  ".repeat(level) + currentClass.getSimpleName());
                currentClass = currentClass.getSuperclass();
                level++;
            }
            
            // 实现的接口
            System.out.println("\n实现的接口:");
            Class<?>[] interfaces = listClass.getInterfaces();
            for (Class<?> intf : interfaces) {
                System.out.println("  - " + intf.getSimpleName());
            }
            
        } catch (Exception e) {
            System.err.println("获取类信息出错: " + e.getMessage());
        }
    }
}

13.1.2 反射的应用场景

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

// 反射应用场景演示
public class ReflectionApplications {
    
    public static void main(String[] args) {
        // 1. 框架开发中的依赖注入
        demonstrateDependencyInjection();
        
        // 2. 配置文件驱动的对象创建
        demonstrateConfigDrivenCreation();
        
        // 3. 通用的对象复制
        demonstrateGenericObjectCopy();
        
        // 4. 动态代理
        demonstrateDynamicProxy();
    }
    
    // 简单的依赖注入演示
    public static void demonstrateDependencyInjection() {
        System.out.println("=== 依赖注入演示 ===");
        
        try {
            // 创建一个简单的IoC容器
            SimpleIoCContainer container = new SimpleIoCContainer();
            
            // 注册服务
            container.register("userService", UserService.class);
            container.register("userRepository", UserRepository.class);
            
            // 获取服务（自动注入依赖）
            UserService userService = container.get("userService", UserService.class);
            
            // 使用服务
            userService.createUser("张三", "zhangsan@example.com");
            User user = userService.findUser(1L);
            System.out.println("找到用户: " + user);
            
        } catch (Exception e) {
            System.err.println("依赖注入演示出错: " + e.getMessage());
        }
    }
    
    // 配置驱动的对象创建
    public static void demonstrateConfigDrivenCreation() {
        System.out.println("\n=== 配置驱动对象创建 ===");
        
        // 模拟配置信息
        Map<String, String> config = new HashMap<>();
        config.put("database.driver", "com.mysql.cj.jdbc.Driver");
        config.put("database.url", "jdbc:mysql://localhost:3306/test");
        config.put("database.username", "root");
        config.put("database.password", "password");
        
        try {
            // 根据配置创建数据库连接配置对象
            DatabaseConfig dbConfig = createObjectFromConfig(DatabaseConfig.class, config, "database");
            System.out.println("创建的数据库配置: " + dbConfig);
            
        } catch (Exception e) {
            System.err.println("配置驱动创建出错: " + e.getMessage());
        }
    }
    
    // 通用对象复制
    public static void demonstrateGenericObjectCopy() {
        System.out.println("\n=== 通用对象复制 ===");
        
        try {
            // 创建源对象
            User sourceUser = new User(1L, "李四", "lisi@example.com");
            System.out.println("源对象: " + sourceUser);
            
            // 使用反射进行深度复制
            User copiedUser = deepCopy(sourceUser, User.class);
            System.out.println("复制对象: " + copiedUser);
            
            // 验证是不同的对象
            System.out.println("是否为同一对象: " + (sourceUser == copiedUser));
            System.out.println("内容是否相同: " + sourceUser.equals(copiedUser));
            
        } catch (Exception e) {
            System.err.println("对象复制出错: " + e.getMessage());
        }
    }
    
    // 动态代理演示
    public static void demonstrateDynamicProxy() {
        System.out.println("\n=== 动态代理演示 ===");
        
        try {
            // 创建真实对象
            CalculatorService realService = new CalculatorServiceImpl();
            
            // 创建代理对象
            CalculatorService proxyService = (CalculatorService) Proxy.newProxyInstance(
                CalculatorService.class.getClassLoader(),
                new Class[]{CalculatorService.class},
                new LoggingInvocationHandler(realService)
            );
            
            // 使用代理对象
            System.out.println("使用代理对象进行计算:");
            int result1 = proxyService.add(10, 20);
            System.out.println("10 + 20 = " + result1);
            
            int result2 = proxyService.multiply(5, 6);
            System.out.println("5 * 6 = " + result2);
            
        } catch (Exception e) {
            System.err.println("动态代理演示出错: " + e.getMessage());
        }
    }
    
    // 简单的IoC容器实现
    public static class SimpleIoCContainer {
        private final Map<String, Class<?>> services = new HashMap<>();
        private final Map<String, Object> instances = new HashMap<>();
        
        public void register(String name, Class<?> serviceClass) {
            services.put(name, serviceClass);
        }
        
        @SuppressWarnings("unchecked")
        public <T> T get(String name, Class<T> type) throws Exception {
            if (instances.containsKey(name)) {
                return (T) instances.get(name);
            }
            
            Class<?> serviceClass = services.get(name);
            if (serviceClass == null) {
                throw new IllegalArgumentException("服务未注册: " + name);
            }
            
            // 创建实例
            Object instance = createInstance(serviceClass);
            instances.put(name, instance);
            
            return (T) instance;
        }
        
        private Object createInstance(Class<?> clazz) throws Exception {
            Constructor<?> constructor = clazz.getDeclaredConstructor();
            Object instance = constructor.newInstance();
            
            // 简单的字段注入
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                if (field.isAnnotationPresent(Inject.class)) {
                    field.setAccessible(true);
                    
                    // 根据字段类型查找服务
                    String serviceName = findServiceByType(field.getType());
                    if (serviceName != null) {
                        Object dependency = get(serviceName, field.getType());
                        field.set(instance, dependency);
                    }
                }
            }
            
            return instance;
        }
        
        private String findServiceByType(Class<?> type) {
            for (Map.Entry<String, Class<?>> entry : services.entrySet()) {
                if (type.isAssignableFrom(entry.getValue())) {
                    return entry.getKey();
                }
            }
            return null;
        }
    }
    
    // 根据配置创建对象
    public static <T> T createObjectFromConfig(Class<T> clazz, Map<String, String> config, String prefix) 
            throws Exception {
        Constructor<T> constructor = clazz.getDeclaredConstructor();
        T instance = constructor.newInstance();
        
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            String configKey = prefix + "." + field.getName();
            String configValue = config.get(configKey);
            
            if (configValue != null) {
                field.setAccessible(true);
                
                // 简单的类型转换
                Object value = convertValue(configValue, field.getType());
                field.set(instance, value);
            }
        }
        
        return instance;
    }
    
    // 简单的类型转换
    private static Object convertValue(String value, Class<?> targetType) {
        if (targetType == String.class) {
            return value;
        } else if (targetType == int.class || targetType == Integer.class) {
            return Integer.parseInt(value);
        } else if (targetType == long.class || targetType == Long.class) {
            return Long.parseLong(value);
        } else if (targetType == boolean.class || targetType == Boolean.class) {
            return Boolean.parseBoolean(value);
        }
        return value;
    }
    
    // 深度复制
    public static <T> T deepCopy(T source, Class<T> clazz) throws Exception {
        if (source == null) {
            return null;
        }
        
        Constructor<T> constructor = clazz.getDeclaredConstructor();
        T copy = constructor.newInstance();
        
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            Object value = field.get(source);
            
            // 简单的深度复制（只处理基本类型和String）
            if (value != null && (field.getType().isPrimitive() || 
                                field.getType() == String.class ||
                                Number.class.isAssignableFrom(field.getType()))) {
                field.set(copy, value);
            }
        }
        
        return copy;
    }
}

// 依赖注入注解
@interface Inject {
}

// 用户实体类
class User {
    private Long id;
    private String name;
    private String email;
    
    public User() {}
    
    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }
    
    // getter和setter方法
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    
    @Override
    public String toString() {
        return "User{id=" + id + ", name='" + name + "', email='" + email + "'}";
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        User user = (User) obj;
        return Objects.equals(id, user.id) && 
               Objects.equals(name, user.name) && 
               Objects.equals(email, user.email);
    }
}

// 用户仓库
class UserRepository {
    private final Map<Long, User> users = new HashMap<>();
    private Long nextId = 1L;
    
    public User save(User user) {
        if (user.getId() == null) {
            user.setId(nextId++);
        }
        users.put(user.getId(), user);
        System.out.println("保存用户到数据库: " + user);
        return user;
    }
    
    public User findById(Long id) {
        User user = users.get(id);
        System.out.println("从数据库查找用户: " + id + " -> " + user);
        return user;
    }
}

// 用户服务
class UserService {
    @Inject
    private UserRepository userRepository;
    
    public User createUser(String name, String email) {
        User user = new User(null, name, email);
        return userRepository.save(user);
    }
    
    public User findUser(Long id) {
        return userRepository.findById(id);
    }
}

// 数据库配置类
class DatabaseConfig {
    private String driver;
    private String url;
    private String username;
    private String password;
    
    // getter和setter方法
    public String getDriver() { return driver; }
    public void setDriver(String driver) { this.driver = driver; }
    
    public String getUrl() { return url; }
    public void setUrl(String url) { this.url = url; }
    
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    
    @Override
    public String toString() {
        return "DatabaseConfig{driver='" + driver + "', url='" + url + 
               "', username='" + username + "', password='***'}";
    }
}

// 计算器服务接口
interface CalculatorService {
    int add(int a, int b);
    int multiply(int a, int b);
}

// 计算器服务实现
class CalculatorServiceImpl implements CalculatorService {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
    
    @Override
    public int multiply(int a, int b) {
        return a * b;
    }
}

// 日志记录的调用处理器
class LoggingInvocationHandler implements InvocationHandler {
    private final Object target;
    
    public LoggingInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("[LOG] 调用方法: " + method.getName() + 
                         ", 参数: " + Arrays.toString(args));
        
        long startTime = System.currentTimeMillis();
        
        try {
            Object result = method.invoke(target, args);
            long endTime = System.currentTimeMillis();
            
            System.out.println("[LOG] 方法执行完成, 耗时: " + (endTime - startTime) + "ms, 结果: " + result);
            
            return result;
        } catch (Exception e) {
            System.out.println("[LOG] 方法执行出错: " + e.getMessage());
            throw e;
        }
    }
}

13.2 Class类详解

13.2.1 Class类的基本操作

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

// Class类详细演示
public class ClassDetailedDemo {
    
    public static void main(String[] args) {
        // Class对象的基本信息
        demonstrateClassBasicInfo();
        
        // 类的修饰符
        demonstrateClassModifiers();
        
        // 类的继承关系
        demonstrateClassHierarchy();
        
        // 泛型信息
        demonstrateGenericInfo();
    }
    
    // Class基本信息演示
    public static void demonstrateClassBasicInfo() {
        System.out.println("=== Class基本信息 ===");
        
        try {
            Class<?> clazz = ArrayList.class;
            
            // 基本名称信息
            System.out.println("完整类名: " + clazz.getName());
            System.out.println("简单类名: " + clazz.getSimpleName());
            System.out.println("规范类名: " + clazz.getCanonicalName());
            System.out.println("类型名称: " + clazz.getTypeName());
            
            // 包信息
            Package pkg = clazz.getPackage();
            if (pkg != null) {
                System.out.println("包名: " + pkg.getName());
                System.out.println("包实现标题: " + pkg.getImplementationTitle());
                System.out.println("包实现版本: " + pkg.getImplementationVersion());
            }
            
            // 类加载器信息
            ClassLoader classLoader = clazz.getClassLoader();
            System.out.println("类加载器: " + classLoader);
            
            // 类的位置
            java.security.ProtectionDomain domain = clazz.getProtectionDomain();
            if (domain != null && domain.getCodeSource() != null) {
                System.out.println("类文件位置: " + domain.getCodeSource().getLocation());
            }
            
        } catch (Exception e) {
            System.err.println("获取Class基本信息出错: " + e.getMessage());
        }
    }
    
    // 类修饰符演示
    public static void demonstrateClassModifiers() {
        System.out.println("\n=== 类修饰符演示 ===");
        
        Class<?>[] testClasses = {
            String.class,
            ArrayList.class,
            List.class,
            Thread.State.class,
            Override.class
        };
        
        for (Class<?> clazz : testClasses) {
            System.out.println("\n类: " + clazz.getSimpleName());
            
            int modifiers = clazz.getModifiers();
            
            System.out.println("  修饰符值: " + modifiers);
            System.out.println("  修饰符字符串: " + Modifier.toString(modifiers));
            
            // 详细的修饰符检查
            System.out.println("  是否为public: " + Modifier.isPublic(modifiers));
            System.out.println("  是否为private: " + Modifier.isPrivate(modifiers));
            System.out.println("  是否为protected: " + Modifier.isProtected(modifiers));
            System.out.println("  是否为static: " + Modifier.isStatic(modifiers));
            System.out.println("  是否为final: " + Modifier.isFinal(modifiers));
            System.out.println("  是否为abstract: " + Modifier.isAbstract(modifiers));
            
            // 类型检查
            System.out.println("  是否为接口: " + clazz.isInterface());
            System.out.println("  是否为枚举: " + clazz.isEnum());
            System.out.println("  是否为注解: " + clazz.isAnnotation());
            System.out.println("  是否为数组: " + clazz.isArray());
            System.out.println("  是否为基本类型: " + clazz.isPrimitive());
        }
    }
    
    // 类继承关系演示
    public static void demonstrateClassHierarchy() {
        System.out.println("\n=== 类继承关系演示 ===");
        
        Class<?> clazz = ArrayList.class;
        
        // 父类链
        System.out.println("父类链:");
        Class<?> currentClass = clazz;
        int level = 0;
        while (currentClass != null) {
            System.out.println("  " + "  ".repeat(level) + currentClass.getSimpleName());
            currentClass = currentClass.getSuperclass();
            level++;
        }
        
        // 直接实现的接口
        System.out.println("\n直接实现的接口:");
        Class<?>[] interfaces = clazz.getInterfaces();
        for (Class<?> intf : interfaces) {
            System.out.println("  - " + intf.getSimpleName());
        }
        
        // 所有接口（包括父类实现的）
        System.out.println("\n所有接口（递归获取）:");
        Set<Class<?>> allInterfaces = getAllInterfaces(clazz);
        for (Class<?> intf : allInterfaces) {
            System.out.println("  - " + intf.getSimpleName());
        }
        
        // 类型检查
        System.out.println("\n类型检查:");
        System.out.println("  ArrayList是否为List: " + List.class.isAssignableFrom(ArrayList.class));
        System.out.println("  ArrayList是否为Collection: " + Collection.class.isAssignableFrom(ArrayList.class));
        System.out.println("  ArrayList是否为Object: " + Object.class.isAssignableFrom(ArrayList.class));
        
        // 实例检查
        ArrayList<String> list = new ArrayList<>();
        System.out.println("\n实例检查:");
        System.out.println("  list是否为ArrayList实例: " + ArrayList.class.isInstance(list));
        System.out.println("  list是否为List实例: " + List.class.isInstance(list));
        System.out.println("  list是否为Collection实例: " + Collection.class.isInstance(list));
    }
    
    // 泛型信息演示
    public static void demonstrateGenericInfo() {
        System.out.println("\n=== 泛型信息演示 ===");
        
        try {
            Class<?> clazz = ArrayList.class;
            
            // 类型参数
            TypeVariable<?>[] typeParameters = clazz.getTypeParameters();
            System.out.println("类型参数数量: " + typeParameters.length);
            for (TypeVariable<?> typeParam : typeParameters) {
                System.out.println("  类型参数: " + typeParam.getName());
                
                Type[] bounds = typeParam.getBounds();
                System.out.println("  边界数量: " + bounds.length);
                for (Type bound : bounds) {
                    System.out.println("    边界: " + bound.getTypeName());
                }
            }
            
            // 泛型父类
            Type genericSuperclass = clazz.getGenericSuperclass();
            System.out.println("\n泛型父类: " + genericSuperclass);
            if (genericSuperclass instanceof ParameterizedType) {
                ParameterizedType paramType = (ParameterizedType) genericSuperclass;
                System.out.println("  原始类型: " + paramType.getRawType());
                Type[] actualTypes = paramType.getActualTypeArguments();
                System.out.println("  实际类型参数: " + Arrays.toString(actualTypes));
            }
            
            // 泛型接口
            Type[] genericInterfaces = clazz.getGenericInterfaces();
            System.out.println("\n泛型接口数量: " + genericInterfaces.length);
            for (Type genericInterface : genericInterfaces) {
                System.out.println("  泛型接口: " + genericInterface);
                if (genericInterface instanceof ParameterizedType) {
                    ParameterizedType paramType = (ParameterizedType) genericInterface;
                    System.out.println("    原始类型: " + paramType.getRawType());
                    Type[] actualTypes = paramType.getActualTypeArguments();
                    System.out.println("    实际类型参数: " + Arrays.toString(actualTypes));
                }
            }
            
        } catch (Exception e) {
            System.err.println("获取泛型信息出错: " + e.getMessage());
        }
    }
    
    // 递归获取所有接口
    private static Set<Class<?>> getAllInterfaces(Class<?> clazz) {
        Set<Class<?>> interfaces = new HashSet<>();
        
        while (clazz != null) {
            // 添加当前类直接实现的接口
            Class<?>[] directInterfaces = clazz.getInterfaces();
            for (Class<?> intf : directInterfaces) {
                interfaces.add(intf);
                // 递归添加接口的父接口
                interfaces.addAll(getAllInterfaces(intf));
            }
            
            // 移动到父类
            clazz = clazz.getSuperclass();
        }
        
        return interfaces;
    }
}

13.2.2 Class类的实用方法

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

// Class类实用方法演示
public class ClassUtilityMethods {
    
    public static void main(String[] args) {
        // 资源访问
        demonstrateResourceAccess();
        
        // 类型转换和检查
        demonstrateTypeConversion();
        
        // 数组操作
        demonstrateArrayOperations();
        
        // 枚举常量
        demonstrateEnumConstants();
    }
    
    // 资源访问演示
    public static void demonstrateResourceAccess() {
        System.out.println("=== 资源访问演示 ===");
        
        try {
            Class<?> clazz = ClassUtilityMethods.class;
            
            // 获取资源URL
            java.net.URL resourceUrl = clazz.getResource("/");
            System.out.println("根路径资源URL: " + resourceUrl);
            
            // 获取类文件的URL
            String className = clazz.getSimpleName() + ".class";
            java.net.URL classUrl = clazz.getResource(className);
            System.out.println("类文件URL: " + classUrl);
            
            // 获取资源流（模拟读取配置文件）
            try (InputStream stream = clazz.getResourceAsStream("/application.properties")) {
                if (stream != null) {
                    Properties props = new Properties();
                    props.load(stream);
                    System.out.println("加载的配置: " + props);
                } else {
                    System.out.println("配置文件不存在，创建默认配置演示");
                    Properties defaultProps = new Properties();
                    defaultProps.setProperty("app.name", "ReflectionDemo");
                    defaultProps.setProperty("app.version", "1.0.0");
                    System.out.println("默认配置: " + defaultProps);
                }
            }
            
        } catch (Exception e) {
            System.err.println("资源访问出错: " + e.getMessage());
        }
    }
    
    // 类型转换和检查演示
    public static void demonstrateTypeConversion() {
        System.out.println("\n=== 类型转换和检查演示 ===");
        
        try {
            // 基本类型和包装类型
            Class<?>[] primitiveTypes = {
                boolean.class, byte.class, char.class, short.class,
                int.class, long.class, float.class, double.class
            };
            
            Class<?>[] wrapperTypes = {
                Boolean.class, Byte.class, Character.class, Short.class,
                Integer.class, Long.class, Float.class, Double.class
            };
            
            System.out.println("基本类型和包装类型对应关系:");
            for (int i = 0; i < primitiveTypes.length; i++) {
                Class<?> primitive = primitiveTypes[i];
                Class<?> wrapper = wrapperTypes[i];
                
                System.out.printf("  %s <-> %s\n", 
                    primitive.getSimpleName(), wrapper.getSimpleName());
                
                // 获取包装类型的TYPE字段
                try {
                    Field typeField = wrapper.getField("TYPE");
                    Class<?> typeValue = (Class<?>) typeField.get(null);
                    System.out.printf("    %s.TYPE == %s: %s\n", 
                        wrapper.getSimpleName(), 
                        primitive.getSimpleName(), 
                        typeValue == primitive);
                } catch (NoSuchFieldException e) {
                    // Character没有TYPE字段
                }
            }
            
            // 类型检查方法
            System.out.println("\n类型检查方法:");
            Object[] testObjects = {
                "Hello", 42, 3.14, true, new ArrayList<>(), new int[5]
            };
            
            for (Object obj : testObjects) {
                Class<?> objClass = obj.getClass();
                System.out.println("\n对象: " + obj + " (" + objClass.getSimpleName() + ")");
                System.out.println("  是否为数组: " + objClass.isArray());
                System.out.println("  是否为基本类型: " + objClass.isPrimitive());
                System.out.println("  是否为接口: " + objClass.isInterface());
                System.out.println("  是否为枚举: " + objClass.isEnum());
                System.out.println("  是否为注解: " + objClass.isAnnotation());
                System.out.println("  是否为匿名类: " + objClass.isAnonymousClass());
                System.out.println("  是否为局部类: " + objClass.isLocalClass());
                System.out.println("  是否为成员类: " + objClass.isMemberClass());
                
                if (objClass.isArray()) {
                    System.out.println("  数组元素类型: " + objClass.getComponentType().getSimpleName());
                }
            }
            
        } catch (Exception e) {
            System.err.println("类型转换和检查出错: " + e.getMessage());
        }
    }
    
    // 数组操作演示
    public static void demonstrateArrayOperations() {
        System.out.println("\n=== 数组操作演示 ===");
        
        try {
            // 创建数组
            Class<?> intArrayClass = Array.newInstance(int.class, 5).getClass();
            System.out.println("创建的数组类型: " + intArrayClass.getName());
            
            // 多维数组
            Object multiArray = Array.newInstance(String.class, 3, 4);
            Class<?> multiArrayClass = multiArray.getClass();
            System.out.println("多维数组类型: " + multiArrayClass.getName());
            System.out.println("数组维度: " + getDimensionCount(multiArrayClass));
            
            // 数组操作
            int[] intArray = (int[]) Array.newInstance(int.class, 5);
            for (int i = 0; i < Array.getLength(intArray); i++) {
                Array.setInt(intArray, i, i * i);
            }
            
            System.out.println("\n数组内容:");
            for (int i = 0; i < Array.getLength(intArray); i++) {
                int value = Array.getInt(intArray, i);
                System.out.println("  [" + i + "] = " + value);
            }
            
            // 不同类型的数组
            System.out.println("\n不同类型数组的Class对象:");
            Class<?>[] arrayTypes = {
                int[].class,
                String[].class,
                Object[].class,
                int[][].class,
                List[].class
            };
            
            for (Class<?> arrayType : arrayTypes) {
                System.out.println("  " + arrayType.getName() + " -> 元素类型: " + 
                    arrayType.getComponentType().getSimpleName());
            }
            
        } catch (Exception e) {
            System.err.println("数组操作出错: " + e.getMessage());
        }
    }
    
    // 枚举常量演示
    public static void demonstrateEnumConstants() {
        System.out.println("\n=== 枚举常量演示 ===");
        
        try {
            // Thread.State枚举
            Class<Thread.State> stateClass = Thread.State.class;
            System.out.println("枚举类: " + stateClass.getSimpleName());
            System.out.println("是否为枚举: " + stateClass.isEnum());
            
            // 获取所有枚举常量
            Thread.State[] states = stateClass.getEnumConstants();
            System.out.println("\n枚举常量:");
            for (Thread.State state : states) {
                System.out.println("  - " + state.name() + " (序号: " + state.ordinal() + ")");
            }
            
            // 自定义枚举演示
            Class<Priority> priorityClass = Priority.class;
            Priority[] priorities = priorityClass.getEnumConstants();
            System.out.println("\n自定义枚举常量:");
            for (Priority priority : priorities) {
                System.out.println("  - " + priority.name() + 
                    " (值: " + priority.getValue() + 
                    ", 描述: " + priority.getDescription() + ")");
            }
            
            // 枚举方法调用
            System.out.println("\n枚举方法调用:");
            Method valueOfMethod = priorityClass.getMethod("valueOf", String.class);
            Priority high = (Priority) valueOfMethod.invoke(null, "HIGH");
            System.out.println("通过反射获取的枚举: " + high);
            
            Method valuesMethod = priorityClass.getMethod("values");
            Priority[] allPriorities = (Priority[]) valuesMethod.invoke(null);
            System.out.println("通过反射获取所有枚举: " + Arrays.toString(allPriorities));
            
        } catch (Exception e) {
            System.err.println("枚举常量演示出错: " + e.getMessage());
        }
    }
    
    // 计算数组维度
    private static int getDimensionCount(Class<?> arrayClass) {
        int count = 0;
        while (arrayClass.isArray()) {
            count++;
            arrayClass = arrayClass.getComponentType();
        }
        return count;
    }
}

// 自定义枚举
enum Priority {
    LOW(1, "低优先级"),
    MEDIUM(2, "中等优先级"),
    HIGH(3, "高优先级"),
    URGENT(4, "紧急");
    
    private final int value;
    private final String description;
    
    Priority(int value, String description) {
        this.value = value;
        this.description = description;
    }
    
    public int getValue() {
        return value;
    }
    
    public String getDescription() {
        return description;
    }
}

13.3 构造器反射

13.3.1 获取和使用构造器

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

// 构造器反射演示
public class ConstructorReflectionDemo {
    
    public static void main(String[] args) {
        // 获取构造器
        demonstrateGetConstructors();
        
        // 使用构造器创建对象
        demonstrateCreateObjects();
        
        // 构造器参数分析
        demonstrateConstructorParameters();
        
        // 私有构造器访问
        demonstratePrivateConstructors();
    }
    
    // 获取构造器演示
    public static void demonstrateGetConstructors() {
        System.out.println("=== 获取构造器演示 ===");
        
        try {
            Class<?> clazz = ArrayList.class;
            
            // 获取所有公共构造器
            Constructor<?>[] publicConstructors = clazz.getConstructors();
            System.out.println("公共构造器数量: " + publicConstructors.length);
            
            for (int i = 0; i < publicConstructors.length; i++) {
                Constructor<?> constructor = publicConstructors[i];
                System.out.println("\n构造器 " + (i + 1) + ":");
                System.out.println("  声明: " + constructor);
                System.out.println("  修饰符: " + Modifier.toString(constructor.getModifiers()));
                System.out.println("  参数数量: " + constructor.getParameterCount());
                
                // 参数类型
                Class<?>[] paramTypes = constructor.getParameterTypes();
                if (paramTypes.length > 0) {
                    System.out.println("  参数类型:");
                    for (int j = 0; j < paramTypes.length; j++) {
                        System.out.println("    [" + j + "] " + paramTypes[j].getSimpleName());
                    }
                }
                
                // 异常类型
                Class<?>[] exceptionTypes = constructor.getExceptionTypes();
                if (exceptionTypes.length > 0) {
                    System.out.println("  可能抛出的异常:");
                    for (Class<?> exType : exceptionTypes) {
                        System.out.println("    - " + exType.getSimpleName());
                    }
                }
            }
            
            // 获取所有构造器（包括私有的）
            Constructor<?>[] allConstructors = clazz.getDeclaredConstructors();
            System.out.println("\n所有构造器数量（包括私有）: " + allConstructors.length);
            
            // 获取特定的构造器
            try {
                Constructor<?> defaultConstructor = clazz.getConstructor();
                System.out.println("\n默认构造器: " + defaultConstructor);
            } catch (NoSuchMethodException e) {
                System.out.println("\n没有公共的默认构造器");
            }
            
            try {
                Constructor<?> intConstructor = clazz.getConstructor(int.class);
                System.out.println("int参数构造器: " + intConstructor);
            } catch (NoSuchMethodException e) {
                System.out.println("没有int参数的构造器");
            }
            
        } catch (Exception e) {
            System.err.println("获取构造器出错: " + e.getMessage());
        }
    }
    
    // 使用构造器创建对象演示
    public static void demonstrateCreateObjects() {
        System.out.println("\n=== 使用构造器创建对象演示 ===");
        
        try {
            Class<?> clazz = ArrayList.class;
            
            // 使用默认构造器
            Constructor<?> defaultConstructor = clazz.getConstructor();
            Object list1 = defaultConstructor.newInstance();
            System.out.println("使用默认构造器创建: " + list1.getClass().getSimpleName());
            
            // 使用带参数的构造器
            Constructor<?> capacityConstructor = clazz.getConstructor(int.class);
            Object list2 = capacityConstructor.newInstance(20);
            System.out.println("使用容量构造器创建: " + list2.getClass().getSimpleName());
            
            // 使用Collection参数的构造器
            Constructor<?> collectionConstructor = clazz.getConstructor(Collection.class);
            List<String> sourceList = Arrays.asList("A", "B", "C");
            Object list3 = collectionConstructor.newInstance(sourceList);
            System.out.println("使用Collection构造器创建: " + list3);
            
            // 创建自定义类的对象
            System.out.println("\n创建自定义类对象:");
            Class<?> personClass = Person.class;
            
            // 默认构造器
            Constructor<?> personDefaultConstructor = personClass.getConstructor();
            Person person1 = (Person) personDefaultConstructor.newInstance();
            System.out.println("默认构造器创建: " + person1);
            
            // 带参数构造器
            Constructor<?> personParamConstructor = personClass.getConstructor(String.class, int.class);
            Person person2 = (Person) personParamConstructor.newInstance("张三", 25);
            System.out.println("参数构造器创建: " + person2);
            
            // 全参数构造器
            Constructor<?> personFullConstructor = personClass.getConstructor(String.class, int.class, String.class);
            Person person3 = (Person) personFullConstructor.newInstance("李四", 30, "工程师");
            System.out.println("全参数构造器创建: " + person3);
            
        } catch (Exception e) {
            System.err.println("创建对象出错: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    // 构造器参数分析演示
    public static void demonstrateConstructorParameters() {
        System.out.println("\n=== 构造器参数分析演示 ===");
        
        try {
            Class<?> clazz = Person.class;
            Constructor<?>[] constructors = clazz.getConstructors();
            
            for (int i = 0; i < constructors.length; i++) {
                Constructor<?> constructor = constructors[i];
                System.out.println("\n构造器 " + (i + 1) + ": " + constructor);
                
                // 参数信息
                Parameter[] parameters = constructor.getParameters();
                System.out.println("参数数量: " + parameters.length);
                
                for (int j = 0; j < parameters.length; j++) {
                    Parameter param = parameters[j];
                    System.out.println("  参数 " + (j + 1) + ":");
                    System.out.println("    名称: " + param.getName());
                    System.out.println("    类型: " + param.getType().getSimpleName());
                    System.out.println("    修饰符: " + Modifier.toString(param.getModifiers()));
                    System.out.println("    是否为可变参数: " + param.isVarArgs());
                    System.out.println("    是否有名称: " + param.isNamePresent());
                }
                
                // 泛型参数信息
                Type[] genericParamTypes = constructor.getGenericParameterTypes();
                if (genericParamTypes.length > 0) {
                    System.out.println("  泛型参数类型:");
                    for (int j = 0; j < genericParamTypes.length; j++) {
                        System.out.println("    [" + j + "] " + genericParamTypes[j]);
                    }
                }
                
                // 注解信息
                Annotation[][] paramAnnotations = constructor.getParameterAnnotations();
                for (int j = 0; j < paramAnnotations.length; j++) {
                    if (paramAnnotations[j].length > 0) {
                        System.out.println("  参数 " + (j + 1) + " 的注解:");
                        for (Annotation annotation : paramAnnotations[j]) {
                            System.out.println("    - " + annotation);
                        }
                    }
                }
            }
            
        } catch (Exception e) {
            System.err.println("分析构造器参数出错: " + e.getMessage());
        }
    }
    
    // 私有构造器访问演示
    public static void demonstratePrivateConstructors() {
        System.out.println("\n=== 私有构造器访问演示 ===");
        
        try {
            Class<?> clazz = Singleton.class;
            
            // 尝试获取公共构造器（应该没有）
            Constructor<?>[] publicConstructors = clazz.getConstructors();
            System.out.println("公共构造器数量: " + publicConstructors.length);
            
            // 获取所有构造器（包括私有的）
            Constructor<?>[] allConstructors = clazz.getDeclaredConstructors();
            System.out.println("所有构造器数量: " + allConstructors.length);
            
            for (Constructor<?> constructor : allConstructors) {
                System.out.println("\n构造器: " + constructor);
                System.out.println("修饰符: " + Modifier.toString(constructor.getModifiers()));
                System.out.println("是否为私有: " + Modifier.isPrivate(constructor.getModifiers()));
                
                if (Modifier.isPrivate(constructor.getModifiers())) {
                    // 设置可访问
                    constructor.setAccessible(true);
                    
                    // 创建实例
                    Object instance = constructor.newInstance();
                    System.out.println("通过私有构造器创建的实例: " + instance);
                    
                    // 验证是否为单例
                    Singleton singleton1 = Singleton.getInstance();
                    System.out.println("单例实例: " + singleton1);
                    System.out.println("是否为同一实例: " + (instance == singleton1));
                }
            }
            
        } catch (Exception e) {
            System.err.println("访问私有构造器出错: " + e.getMessage());
        }
    }
}

// 测试用的Person类
class Person {
    private String name;
    private int age;
    private String occupation;
    
    // 默认构造器
    public Person() {
        this.name = "未知";
        this.age = 0;
        this.occupation = "无";
    }
    
    // 带参数构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        this.occupation = "无";
    }
    
    // 全参数构造器
    public Person(String name, int age, String occupation) {
        this.name = name;
        this.age = age;
        this.occupation = occupation;
    }
    
    // getter和setter方法
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    
    public String getOccupation() { return occupation; }
    public void setOccupation(String occupation) { this.occupation = occupation; }
    
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", occupation='" + occupation + "'}";
    }
}

// 单例模式类（用于演示私有构造器）
class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    
    // 私有构造器
    private Singleton() {
        System.out.println("Singleton构造器被调用");
    }
    
    public static Singleton getInstance() {
        return INSTANCE;
    }
    
    @Override
    public String toString() {
        return "Singleton@" + Integer.toHexString(hashCode());
    }
}

13.4 字段反射

13.4.1 获取和操作字段

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

// 字段反射演示
public class FieldReflectionDemo {
    
    public static void main(String[] args) {
        // 获取字段信息
        demonstrateGetFields();
        
        // 字段值的读取和设置
        demonstrateFieldAccess();
        
        // 静态字段操作
        demonstrateStaticFields();
        
        // 私有字段访问
        demonstratePrivateFields();
    }
    
    // 获取字段信息演示
    public static void demonstrateGetFields() {
        System.out.println("=== 获取字段信息演示 ===");
        
        try {
            Class<?> clazz = Student.class;
            
            // 获取所有公共字段（包括继承的）
            Field[] publicFields = clazz.getFields();
            System.out.println("公共字段数量: " + publicFields.length);
            
            for (Field field : publicFields) {
                System.out.println("\n公共字段: " + field.getName());
                System.out.println("  类型: " + field.getType().getSimpleName());
                System.out.println("  修饰符: " + Modifier.toString(field.getModifiers()));
                System.out.println("  声明类: " + field.getDeclaringClass().getSimpleName());
            }
            
            // 获取所有声明的字段（包括私有的，但不包括继承的）
            Field[] declaredFields = clazz.getDeclaredFields();
            System.out.println("\n声明的字段数量: " + declaredFields.length);
            
            for (Field field : declaredFields) {
                System.out.println("\n声明字段: " + field.getName());
                System.out.println("  类型: " + field.getType().getSimpleName());
                System.out.println("  泛型类型: " + field.getGenericType());
                System.out.println("  修饰符: " + Modifier.toString(field.getModifiers()));
                System.out.println("  是否为静态: " + Modifier.isStatic(field.getModifiers()));
                System.out.println("  是否为final: " + Modifier.isFinal(field.getModifiers()));
                System.out.println("  是否为volatile: " + Modifier.isVolatile(field.getModifiers()));
                System.out.println("  是否为transient: " + Modifier.isTransient(field.getModifiers()));
            }
            
            // 获取特定字段
            try {
                Field nameField = clazz.getDeclaredField("name");
                System.out.println("\n特定字段 'name': " + nameField);
            } catch (NoSuchFieldException e) {
                System.out.println("\n字段 'name' 不存在");
            }
            
        } catch (Exception e) {
            System.err.println("获取字段信息出错: " + e.getMessage());
        }
    }
    
    // 字段值访问演示
    public static void demonstrateFieldAccess() {
        System.out.println("\n=== 字段值访问演示 ===");
        
        try {
            // 创建测试对象
            Student student = new Student("张三", 20, "计算机科学");
            Class<?> clazz = student.getClass();
            
            System.out.println("原始对象: " + student);
            
            // 获取并读取字段值
            Field[] fields = clazz.getDeclaredFields();
            System.out.println("\n读取所有字段值:");
            
            for (Field field : fields) {
                field.setAccessible(true); // 设置可访问私有字段
                
                Object value = field.get(student);
                System.out.println("  " + field.getName() + " = " + value + 
                    " (" + field.getType().getSimpleName() + ")");
            }
            
            // 修改字段值
            System.out.println("\n修改字段值:");
            
            Field nameField = clazz.getDeclaredField("name");
            nameField.setAccessible(true);
            System.out.println("修改前 name: " + nameField.get(student));
            nameField.set(student, "李四");
            System.out.println("修改后 name: " + nameField.get(student));
            
            Field ageField = clazz.getDeclaredField("age");
            ageField.setAccessible(true);
            System.out.println("修改前 age: " + ageField.get(student));
            ageField.setInt(student, 22); // 使用类型特定的方法
            System.out.println("修改后 age: " + ageField.get(student));
            
            Field majorField = clazz.getDeclaredField("major");
            majorField.setAccessible(true);
            System.out.println("修改前 major: " + majorField.get(student));
            majorField.set(student, "软件工程");
            System.out.println("修改后 major: " + majorField.get(student));
            
            System.out.println("\n修改后的对象: " + student);
            
        } catch (Exception e) {
            System.err.println("字段值访问出错: " + e.getMessage());
        }
    }
    
    // 静态字段操作演示
    public static void demonstrateStaticFields() {
        System.out.println("\n=== 静态字段操作演示 ===");
        
        try {
            Class<?> clazz = Student.class;
            
            // 获取静态字段
            Field countField = clazz.getDeclaredField("studentCount");
            countField.setAccessible(true);
            
            System.out.println("静态字段信息:");
            System.out.println("  名称: " + countField.getName());
            System.out.println("  类型: " + countField.getType().getSimpleName());
            System.out.println("  是否为静态: " + Modifier.isStatic(countField.getModifiers()));
            
            // 读取静态字段值（不需要实例）
            int currentCount = countField.getInt(null);
            System.out.println("\n当前学生数量: " + currentCount);
            
            // 修改静态字段值
            countField.setInt(null, 100);
            System.out.println("修改后学生数量: " + countField.getInt(null));
            
            // 创建新学生，验证静态字段
            Student student1 = new Student("王五", 19, "数学");
            Student student2 = new Student("赵六", 21, "物理");
            
            System.out.println("创建两个学生后的数量: " + countField.getInt(null));
            
            // 恢复原值
            countField.setInt(null, currentCount);
            
        } catch (Exception e) {
            System.err.println("静态字段操作出错: " + e.getMessage());
        }
    }
    
    // 私有字段访问演示
    public static void demonstratePrivateFields() {
        System.out.println("\n=== 私有字段访问演示 ===");
        
        try {
            BankAccount account = new BankAccount("123456789", 1000.0);
            Class<?> clazz = account.getClass();
            
            System.out.println("银行账户对象: " + account);
            
            // 访问私有字段
            Field balanceField = clazz.getDeclaredField("balance");
            System.out.println("\n私有字段 'balance':");
            System.out.println("  是否可访问: " + balanceField.isAccessible());
            
            // 尝试直接访问（会失败）
            try {
                double balance = balanceField.getDouble(account);
                System.out.println("  直接访问余额: " + balance);
            } catch (IllegalAccessException e) {
                System.out.println("  直接访问失败: " + e.getMessage());
            }
            
            // 设置可访问后再访问
            balanceField.setAccessible(true);
            System.out.println("  设置可访问后: " + balanceField.isAccessible());
            
            double balance = balanceField.getDouble(account);
            System.out.println("  当前余额: " + balance);
            
            // 修改私有字段（绕过业务逻辑）
            System.out.println("\n绕过业务逻辑修改余额:");
            balanceField.setDouble(account, 999999.99);
            System.out.println("  修改后余额: " + balanceField.getDouble(account));
            System.out.println("  账户对象: " + account);
            
            // 访问私有final字段
            Field accountNumberField = clazz.getDeclaredField("accountNumber");
            accountNumberField.setAccessible(true);
            
            System.out.println("\n私有final字段 'accountNumber':");
            System.out.println("  当前账号: " + accountNumberField.get(account));
            System.out.println("  是否为final: " + Modifier.isFinal(accountNumberField.getModifiers()));
            
            // 尝试修改final字段（可能成功，但不推荐）
            try {
                accountNumberField.set(account, "987654321");
                System.out.println("  修改后账号: " + accountNumberField.get(account));
            } catch (Exception e) {
                System.out.println("  修改final字段失败: " + e.getMessage());
            }
            
        } catch (Exception e) {
            System.err.println("私有字段访问出错: " + e.getMessage());
        }
    }
}

// 学生类（用于字段反射演示）
class Student {
    // 静态字段
    private static int studentCount = 0;
    
    // 实例字段
    private String name;
    private int age;
    private String major;
    public String school = "某某大学"; // 公共字段
    
    public Student(String name, int age, String major) {
        this.name = name;
        this.age = age;
        this.major = major;
        studentCount++;
    }
    
    // getter方法
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getMajor() { return major; }
    public static int getStudentCount() { return studentCount; }
    
    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + ", major='" + major + 
               "', school='" + school + "'}";
    }
}

// 银行账户类（用于私有字段演示）
class BankAccount {
    private final String accountNumber;
    private double balance;
    
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }
    
    public String getAccountNumber() {
        return accountNumber;
    }
    
    public double getBalance() {
        return balance;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
    
    @Override
    public String toString() {
        return "BankAccount{accountNumber='" + accountNumber + "', balance=" + balance + "}";
    }
}

13.5 方法反射

13.5.1 获取和调用方法

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

// 方法反射演示
public class MethodReflectionDemo {
    
    public static void main(String[] args) {
        // 获取方法信息
        demonstrateGetMethods();
        
        // 方法调用
        demonstrateMethodInvocation();
        
        // 静态方法调用
        demonstrateStaticMethods();
        
        // 私有方法访问
        demonstratePrivateMethods();
        
        // 方法参数和返回值分析
        demonstrateMethodAnalysis();
    }
    
    // 获取方法信息演示
    public static void demonstrateGetMethods() {
        System.out.println("=== 获取方法信息演示 ===");
        
        try {
            Class<?> clazz = Calculator.class;
            
            // 获取所有公共方法（包括继承的）
            Method[] publicMethods = clazz.getMethods();
            System.out.println("公共方法数量: " + publicMethods.length);
            
            // 只显示自定义的方法（排除Object的方法）
            System.out.println("\n自定义的公共方法:");
            for (Method method : publicMethods) {
                if (method.getDeclaringClass() == clazz) {
                    System.out.println("  " + method.getName() + "(" + 
                        getParameterTypeNames(method.getParameterTypes()) + ") : " +
                        method.getReturnType().getSimpleName());
                }
            }
            
            // 获取所有声明的方法（包括私有的）
            Method[] declaredMethods = clazz.getDeclaredMethods();
            System.out.println("\n声明的方法数量: " + declaredMethods.length);
            
            for (Method method : declaredMethods) {
                System.out.println("\n方法: " + method.getName());
                System.out.println("  完整签名: " + method);
                System.out.println("  修饰符: " + Modifier.toString(method.getModifiers()));
                System.out.println("  返回类型: " + method.getReturnType().getSimpleName());
                System.out.println("  参数数量: " + method.getParameterCount());
                
                Class<?>[] paramTypes = method.getParameterTypes();
                if (paramTypes.length > 0) {
                    System.out.println("  参数类型: " + Arrays.toString(paramTypes));
                }
                
                Class<?>[] exceptionTypes = method.getExceptionTypes();
                if (exceptionTypes.length > 0) {
                    System.out.println("  异常类型: " + Arrays.toString(exceptionTypes));
                }
            }
            
            // 获取特定方法
            try {
                Method addMethod = clazz.getMethod("add", double.class, double.class);
                System.out.println("\n特定方法 'add': " + addMethod);
            } catch (NoSuchMethodException e) {
                System.out.println("\n方法 'add' 不存在");
            }
            
        } catch (Exception e) {
            System.err.println("获取方法信息出错: " + e.getMessage());
        }
    }
    
    // 方法调用演示
    public static void demonstrateMethodInvocation() {
        System.out.println("\n=== 方法调用演示 ===");
        
        try {
            Calculator calculator = new Calculator();
            Class<?> clazz = calculator.getClass();
            
            // 调用无参数方法
            Method resetMethod = clazz.getMethod("reset");
            resetMethod.invoke(calculator);
            System.out.println("调用reset()方法");
            
            // 调用带参数的方法
            Method addMethod = clazz.getMethod("add", double.class, double.class);
            Object result1 = addMethod.invoke(calculator, 10.5, 20.3);
            System.out.println("add(10.5, 20.3) = " + result1);
            
            Method subtractMethod = clazz.getMethod("subtract", double.class, double.class);
            Object result2 = subtractMethod.invoke(calculator, 50.0, 15.5);
            System.out.println("subtract(50.0, 15.5) = " + result2);
            
            Method multiplyMethod = clazz.getMethod("multiply", double.class, double.class);
            Object result3 = multiplyMethod.invoke(calculator, 6.0, 7.0);
            System.out.println("multiply(6.0, 7.0) = " + result3);
            
            Method divideMethod = clazz.getMethod("divide", double.class, double.class);
            Object result4 = divideMethod.invoke(calculator, 100.0, 4.0);
            System.out.println("divide(100.0, 4.0) = " + result4);
            
            // 调用可能抛出异常的方法
            try {
                Object result5 = divideMethod.invoke(calculator, 10.0, 0.0);
                System.out.println("divide(10.0, 0.0) = " + result5);
            } catch (InvocationTargetException e) {
                System.out.println("方法调用抛出异常: " + e.getCause().getMessage());
            }
            
            // 调用返回复杂对象的方法
            Method getHistoryMethod = clazz.getMethod("getHistory");
            Object history = getHistoryMethod.invoke(calculator);
            System.out.println("计算历史: " + history);
            
        } catch (Exception e) {
            System.err.println("方法调用出错: " + e.getMessage());
        }
    }
    
    // 静态方法调用演示
    public static void demonstrateStaticMethods() {
        System.out.println("\n=== 静态方法调用演示 ===");
        
        try {
            Class<?> clazz = MathUtils.class;
            
            // 获取静态方法
            Method maxMethod = clazz.getMethod("max", int.class, int.class);
            System.out.println("静态方法: " + maxMethod);
            System.out.println("是否为静态: " + Modifier.isStatic(maxMethod.getModifiers()));
            
            // 调用静态方法（第一个参数为null）
            Object result1 = maxMethod.invoke(null, 15, 25);
            System.out.println("max(15, 25) = " + result1);
            
            Method minMethod = clazz.getMethod("min", int.class, int.class);
            Object result2 = minMethod.invoke(null, 15, 25);
            System.out.println("min(15, 25) = " + result2);
            
            Method absMethod = clazz.getMethod("abs", int.class);
            Object result3 = absMethod.invoke(null, -42);
            System.out.println("abs(-42) = " + result3);
            
            Method powerMethod = clazz.getMethod("power", int.class, int.class);
            Object result4 = powerMethod.invoke(null, 2, 8);
            System.out.println("power(2, 8) = " + result4);
            
            // 调用可变参数的静态方法
            Method sumMethod = clazz.getMethod("sum", int[].class);
            Object result5 = sumMethod.invoke(null, (Object) new int[]{1, 2, 3, 4, 5});
            System.out.println("sum(1, 2, 3, 4, 5) = " + result5);
            
        } catch (Exception e) {
            System.err.println("静态方法调用出错: " + e.getMessage());
        }
    }
    
    // 私有方法访问演示
    public static void demonstratePrivateMethods() {
        System.out.println("\n=== 私有方法访问演示 ===");
        
        try {
            SecretCalculator secretCalc = new SecretCalculator();
            Class<?> clazz = secretCalc.getClass();
            
            // 获取私有方法
            Method secretMethod = clazz.getDeclaredMethod("secretCalculation", int.class, int.class);
            System.out.println("私有方法: " + secretMethod);
            System.out.println("是否可访问: " + secretMethod.isAccessible());
            
            // 尝试直接调用（会失败）
            try {
                Object result = secretMethod.invoke(secretCalc, 10, 20);
                System.out.println("直接调用结果: " + result);
            } catch (IllegalAccessException e) {
                System.out.println("直接调用失败: " + e.getMessage());
            }
            
            // 设置可访问后调用
            secretMethod.setAccessible(true);
            System.out.println("设置可访问后: " + secretMethod.isAccessible());
            
            Object result = secretMethod.invoke(secretCalc, 10, 20);
            System.out.println("私有方法调用结果: " + result);
            
            // 调用私有静态方法
            Method privateStaticMethod = clazz.getDeclaredMethod("privateStaticHelper", String.class);
            privateStaticMethod.setAccessible(true);
            
            Object staticResult = privateStaticMethod.invoke(null, "Hello");
            System.out.println("私有静态方法调用结果: " + staticResult);
            
        } catch (Exception e) {
            System.err.println("私有方法访问出错: " + e.getMessage());
        }
    }
    
    // 方法参数和返回值分析演示
    public static void demonstrateMethodAnalysis() {
        System.out.println("\n=== 方法参数和返回值分析演示 ===");
        
        try {
            Class<?> clazz = GenericMethodDemo.class;
            Method[] methods = clazz.getDeclaredMethods();
            
            for (Method method : methods) {
                if (method.getName().startsWith("demo")) {
                    System.out.println("\n方法: " + method.getName());
                    
                    // 参数分析
                    Parameter[] parameters = method.getParameters();
                    System.out.println("参数数量: " + parameters.length);
                    
                    for (int i = 0; i < parameters.length; i++) {
                        Parameter param = parameters[i];
                        System.out.println("  参数 " + (i + 1) + ":");
                        System.out.println("    名称: " + param.getName());
                        System.out.println("    类型: " + param.getType());
                        System.out.println("    泛型类型: " + param.getParameterizedType());
                        System.out.println("    是否可变参数: " + param.isVarArgs());
                    }
                    
                    // 返回值分析
                    System.out.println("返回类型: " + method.getReturnType());
                    System.out.println("泛型返回类型: " + method.getGenericReturnType());
                    
                    // 泛型信息
                    TypeVariable<?>[] typeParams = method.getTypeParameters();
                    if (typeParams.length > 0) {
                        System.out.println("类型参数:");
                        for (TypeVariable<?> typeParam : typeParams) {
                            System.out.println("  - " + typeParam.getName());
                        }
                    }
                    
                    // 异常信息
                    Class<?>[] exceptionTypes = method.getExceptionTypes();
                    if (exceptionTypes.length > 0) {
                        System.out.println("异常类型: " + Arrays.toString(exceptionTypes));
                    }
                }
            }
            
        } catch (Exception e) {
            System.err.println("方法分析出错: " + e.getMessage());
        }
    }
    
    // 辅助方法：获取参数类型名称
    private static String getParameterTypeNames(Class<?>[] paramTypes) {
        if (paramTypes.length == 0) {
            return "";
        }
        
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < paramTypes.length; i++) {
            if (i > 0) {
                sb.append(", ");
            }
            sb.append(paramTypes[i].getSimpleName());
        }
        return sb.toString();
    }
}

// 计算器类（用于方法反射演示）
class Calculator {
    private List<String> history = new ArrayList<>();
    
    public double add(double a, double b) {
        double result = a + b;
        history.add(a + " + " + b + " = " + result);
        return result;
    }
    
    public double subtract(double a, double b) {
        double result = a - b;
        history.add(a + " - " + b + " = " + result);
        return result;
    }
    
    public double multiply(double a, double b) {
        double result = a * b;
        history.add(a + " * " + b + " = " + result);
        return result;
    }
    
    public double divide(double a, double b) throws ArithmeticException {
        if (b == 0) {
            throw new ArithmeticException("除数不能为零");
        }
        double result = a / b;
        history.add(a + " / " + b + " = " + result);
        return result;
    }
    
    public void reset() {
        history.clear();
    }
    
    public List<String> getHistory() {
        return new ArrayList<>(history);
    }
}

// 数学工具类（用于静态方法演示）
class MathUtils {
    
    public static int max(int a, int b) {
        return a > b ? a : b;
    }
    
    public static int min(int a, int b) {
        return a < b ? a : b;
    }
    
    public static int abs(int value) {
        return value < 0 ? -value : value;
    }
    
    public static long power(int base, int exponent) {
        long result = 1;
        for (int i = 0; i < exponent; i++) {
            result *= base;
        }
        return result;
    }
    
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
}

// 秘密计算器类（用于私有方法演示）
class SecretCalculator {
    
    public int publicCalculation(int a, int b) {
        return secretCalculation(a, b);
    }
    
    private int secretCalculation(int a, int b) {
        return (a * b) + privateStaticHelper("secret").length();
    }
    
    private static String privateStaticHelper(String input) {
        return "[" + input.toUpperCase() + "]";
    }
}

// 泛型方法演示类
class GenericMethodDemo {
    
    public <T> T demoGenericMethod(T input, List<T> list) {
        return input;
    }
    
    public <T extends Number> double demoNumberMethod(T number, T... others) {
        return number.doubleValue();
    }
    
    public Map<String, Integer> demoComplexReturn(Set<String> input) throws IllegalArgumentException {
        return new HashMap<>();
    }
    
    public <K, V> Map<K, V> demoMultipleGenerics(K key, V value, Map<K, V> existing) {
        existing.put(key, value);
        return existing;
    }
}

13.6 注解处理

13.6.1 注解的反射操作

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

// 注解处理演示
public class AnnotationReflectionDemo {
    
    public static void main(String[] args) {
        // 类级别注解处理
        demonstrateClassAnnotations();
        
        // 字段注解处理
        demonstrateFieldAnnotations();
        
        // 方法注解处理
        demonstrateMethodAnnotations();
        
        // 参数注解处理
        demonstrateParameterAnnotations();
        
        // 注解处理器示例
        demonstrateAnnotationProcessor();
    }
    
    // 类级别注解处理演示
    public static void demonstrateClassAnnotations() {
        System.out.println("=== 类级别注解处理演示 ===");
        
        try {
            Class<?> clazz = AnnotatedUser.class;
            
            // 检查是否有特定注解
            boolean hasEntity = clazz.isAnnotationPresent(Entity.class);
            System.out.println("是否有@Entity注解: " + hasEntity);
            
            if (hasEntity) {
                Entity entity = clazz.getAnnotation(Entity.class);
                System.out.println("@Entity注解信息:");
                System.out.println("  表名: " + entity.tableName());
                System.out.println("  描述: " + entity.description());
            }
            
            // 获取所有注解
            Annotation[] annotations = clazz.getAnnotations();
            System.out.println("\n所有注解数量: " + annotations.length);
            
            for (Annotation annotation : annotations) {
                System.out.println("注解: " + annotation.annotationType().getSimpleName());
                System.out.println("  完整信息: " + annotation);
                
                // 获取注解的属性
                Method[] annotationMethods = annotation.annotationType().getDeclaredMethods();
                for (Method method : annotationMethods) {
                    try {
                        Object value = method.invoke(annotation);
                        System.out.println("  " + method.getName() + " = " + value);
                    } catch (Exception e) {
                        System.out.println("  " + method.getName() + " = <无法获取>");
                    }
                }
            }
            
            // 获取声明的注解（不包括继承的）
            Annotation[] declaredAnnotations = clazz.getDeclaredAnnotations();
            System.out.println("\n声明的注解数量: " + declaredAnnotations.length);
            
        } catch (Exception e) {
            System.err.println("类注解处理出错: " + e.getMessage());
        }
    }
    
    // 字段注解处理演示
    public static void demonstrateFieldAnnotations() {
        System.out.println("\n=== 字段注解处理演示 ===");
        
        try {
            Class<?> clazz = AnnotatedUser.class;
            Field[] fields = clazz.getDeclaredFields();
            
            for (Field field : fields) {
                System.out.println("\n字段: " + field.getName());
                
                // 检查字段注解
                Annotation[] fieldAnnotations = field.getAnnotations();
                System.out.println("注解数量: " + fieldAnnotations.length);
                
                for (Annotation annotation : fieldAnnotations) {
                    System.out.println("  注解: " + annotation.annotationType().getSimpleName());
                    
                    if (annotation instanceof Column) {
                        Column column = (Column) annotation;
                        System.out.println("    列名: " + column.name());
                        System.out.println("    是否可空: " + column.nullable());
                        System.out.println("    长度: " + column.length());
                    } else if (annotation instanceof Id) {
                        System.out.println("    这是主键字段");
                    } else if (annotation instanceof Transient) {
                        System.out.println("    这是临时字段");
                    }
                }
                
                // 检查特定注解
                if (field.isAnnotationPresent(Validate.class)) {
                    Validate validate = field.getAnnotation(Validate.class);
                    System.out.println("  验证规则:");
                    System.out.println("    是否必需: " + validate.required());
                    System.out.println("    最小长度: " + validate.minLength());
                    System.out.println("    最大长度: " + validate.maxLength());
                    System.out.println("    正则表达式: " + validate.pattern());
                }
            }
            
        } catch (Exception e) {
            System.err.println("字段注解处理出错: " + e.getMessage());
        }
    }
    
    // 方法注解处理演示
    public static void demonstrateMethodAnnotations() {
        System.out.println("\n=== 方法注解处理演示 ===");
        
        try {
            Class<?> clazz = AnnotatedUser.class;
            Method[] methods = clazz.getDeclaredMethods();
            
            for (Method method : methods) {
                Annotation[] methodAnnotations = method.getAnnotations();
                if (methodAnnotations.length > 0) {
                    System.out.println("\n方法: " + method.getName());
                    
                    for (Annotation annotation : methodAnnotations) {
                        System.out.println("  注解: " + annotation.annotationType().getSimpleName());
                        
                        if (annotation instanceof Cacheable) {
                            Cacheable cacheable = (Cacheable) annotation;
                            System.out.println("    缓存键: " + cacheable.key());
                            System.out.println("    过期时间: " + cacheable.expireTime());
                        } else if (annotation instanceof LogExecution) {
                            LogExecution logExecution = (LogExecution) annotation;
                            System.out.println("    日志级别: " + logExecution.level());
                            System.out.println("    包含参数: " + logExecution.includeArgs());
                            System.out.println("    包含返回值: " + logExecution.includeResult());
                        }
                    }
                }
            }
            
        } catch (Exception e) {
            System.err.println("方法注解处理出错: " + e.getMessage());
        }
    }
    
    // 参数注解处理演示
    public static void demonstrateParameterAnnotations() {
        System.out.println("\n=== 参数注解处理演示 ===");
        
        try {
            Class<?> clazz = AnnotatedUser.class;
            Method updateMethod = clazz.getMethod("updateUser", String.class, String.class, Integer.class);
            
            System.out.println("方法: " + updateMethod.getName());
            
            Parameter[] parameters = updateMethod.getParameters();
            Annotation[][] paramAnnotations = updateMethod.getParameterAnnotations();
            
            for (int i = 0; i < parameters.length; i++) {
                Parameter param = parameters[i];
                System.out.println("\n参数 " + (i + 1) + ": " + param.getName() + 
                    " (" + param.getType().getSimpleName() + ")");
                
                Annotation[] annotations = paramAnnotations[i];
                for (Annotation annotation : annotations) {
                    System.out.println("  注解: " + annotation.annotationType().getSimpleName());
                    
                    if (annotation instanceof NotNull) {
                        NotNull notNull = (NotNull) annotation;
                        System.out.println("    消息: " + notNull.message());
                    } else if (annotation instanceof Size) {
                        Size size = (Size) annotation;
                        System.out.println("    最小值: " + size.min());
                        System.out.println("    最大值: " + size.max());
                    }
                }
            }
            
        } catch (Exception e) {
            System.err.println("参数注解处理出错: " + e.getMessage());
        }
    }
    
    // 注解处理器示例
    public static void demonstrateAnnotationProcessor() {
        System.out.println("\n=== 注解处理器示例 ===");
        
        try {
            AnnotatedUser user = new AnnotatedUser();
            user.setName("张三");
            user.setEmail("zhangsan@example.com");
            user.setAge(25);
            
            // 验证对象
            ValidationProcessor.validate(user);
            
            // 生成SQL
            String sql = SQLGenerator.generateInsertSQL(user);
            System.out.println("\n生成的SQL: " + sql);
            
            // 缓存处理
            CacheProcessor.processCache(AnnotatedUser.class);
            
        } catch (Exception e) {
            System.err.println("注解处理器示例出错: " + e.getMessage());
        }
    }
}

// 自定义注解定义

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Entity {
    String tableName();
    String description() default "";
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Id {
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Column {
    String name();
    boolean nullable() default true;
    int length() default 255;
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Transient {
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Validate {
    boolean required() default false;
    int minLength() default 0;
    int maxLength() default Integer.MAX_VALUE;
    String pattern() default "";
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Cacheable {
    String key();
    int expireTime() default 3600; // 秒
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface LogExecution {
    String level() default "INFO";
    boolean includeArgs() default true;
    boolean includeResult() default true;
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
@interface NotNull {
    String message() default "参数不能为空";
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
@interface Size {
    int min() default 0;
    int max() default Integer.MAX_VALUE;
}

// 带注解的用户类
@Entity(tableName = "users", description = "用户表")
class AnnotatedUser {
    
    @Id
    @Column(name = "id", nullable = false)
    private Long id;
    
    @Column(name = "username", nullable = false, length = 50)
    @Validate(required = true, minLength = 3, maxLength = 20, pattern = "^[a-zA-Z0-9_]+$")
    private String name;
    
    @Column(name = "email", nullable = false, length = 100)
    @Validate(required = true, pattern = "^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")
    private String email;
    
    @Column(name = "age", nullable = true)
    private Integer age;
    
    @Transient
    private String temporaryData;
    
    // 构造器
    public AnnotatedUser() {}
    
    // getter和setter方法
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    
    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
    
    public String getTemporaryData() { return temporaryData; }
    public void setTemporaryData(String temporaryData) { this.temporaryData = temporaryData; }
    
    @Cacheable(key = "user_#{id}", expireTime = 1800)
    @LogExecution(level = "DEBUG", includeArgs = true, includeResult = false)
    public AnnotatedUser findById(Long id) {
        // 模拟数据库查询
        System.out.println("从数据库查询用户: " + id);
        return this;
    }
    
    @LogExecution(level = "INFO")
    public void updateUser(@NotNull(message = "用户名不能为空") @Size(min = 3, max = 20) String name,
                          @NotNull(message = "邮箱不能为空") String email,
                          Integer age) {
        this.name = name;
        this.email = email;
        this.age = age;
        System.out.println("更新用户信息");
    }
    
    @Override
    public String toString() {
        return "AnnotatedUser{id=" + id + ", name='" + name + "', email='" + email + 
               "', age=" + age + "}";
    }
}

// 验证处理器
class ValidationProcessor {
    
    public static void validate(Object obj) throws Exception {
        Class<?> clazz = obj.getClass();
        Field[] fields = clazz.getDeclaredFields();
        
        System.out.println("验证对象: " + clazz.getSimpleName());
        
        for (Field field : fields) {
            if (field.isAnnotationPresent(Validate.class)) {
                field.setAccessible(true);
                Object value = field.get(obj);
                
                Validate validate = field.getAnnotation(Validate.class);
                
                System.out.println("验证字段: " + field.getName());
                
                // 必需验证
                if (validate.required() && (value == null || value.toString().trim().isEmpty())) {
                    System.out.println("  ❌ 字段 " + field.getName() + " 是必需的");
                    continue;
                }
                
                if (value != null && value instanceof String) {
                    String strValue = (String) value;
                    
                    // 长度验证
                    if (strValue.length() < validate.minLength()) {
                        System.out.println("  ❌ 字段 " + field.getName() + " 长度不能小于 " + validate.minLength());
                        continue;
                    }
                    
                    if (strValue.length() > validate.maxLength()) {
                        System.out.println("  ❌ 字段 " + field.getName() + " 长度不能大于 " + validate.maxLength());
                        continue;
                    }
                    
                    // 正则验证
                    if (!validate.pattern().isEmpty() && !strValue.matches(validate.pattern())) {
                        System.out.println("  ❌ 字段 " + field.getName() + " 格式不正确");
                        continue;
                    }
                }
                
                System.out.println("  ✅ 字段 " + field.getName() + " 验证通过");
            }
        }
    }
}

// SQL生成器
class SQLGenerator {
    
    public static String generateInsertSQL(Object obj) throws Exception {
        Class<?> clazz = obj.getClass();
        
        // 获取表名
        String tableName = "unknown_table";
        if (clazz.isAnnotationPresent(Entity.class)) {
            Entity entity = clazz.getAnnotation(Entity.class);
            tableName = entity.tableName();
        }
        
        StringBuilder columns = new StringBuilder();
        StringBuilder values = new StringBuilder();
        
        Field[] fields = clazz.getDeclaredFields();
        boolean first = true;
        
        for (Field field : fields) {
            // 跳过临时字段
            if (field.isAnnotationPresent(Transient.class)) {
                continue;
            }
            
            field.setAccessible(true);
            Object value = field.get(obj);
            
            if (value != null) {
                if (!first) {
                    columns.append(", ");
                    values.append(", ");
                }
                
                // 获取列名
                String columnName = field.getName();
                if (field.isAnnotationPresent(Column.class)) {
                    Column column = field.getAnnotation(Column.class);
                    columnName = column.name();
                }
                
                columns.append(columnName);
                
                if (value instanceof String) {
                    values.append("'").append(value).append("'");
                } else {
                    values.append(value);
                }
                
                first = false;
            }
        }
        
        return "INSERT INTO " + tableName + " (" + columns + ") VALUES (" + values + ")";
    }
}

// 缓存处理器
class CacheProcessor {
    
    public static void processCache(Class<?> clazz) {
        System.out.println("\n处理缓存注解: " + clazz.getSimpleName());
        
        Method[] methods = clazz.getDeclaredMethods();
        
        for (Method method : methods) {
             if (method.isAnnotationPresent(Cacheable.class)) {
                 Cacheable cacheable = method.getAnnotation(Cacheable.class);
                 
                 System.out.println("发现可缓存方法: " + method.getName());
                 System.out.println("  缓存键模板: " + cacheable.key());
                 System.out.println("  过期时间: " + cacheable.expireTime() + " 秒");
                 System.out.println("  -> 已注册到缓存管理器");
             }
         }
     }
 }

13.7 动态代理

13.7.1 JDK动态代理

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

// 动态代理演示
public class DynamicProxyDemo {
    
    public static void main(String[] args) {
        // JDK动态代理演示
        demonstrateJDKProxy();
        
        // 代理链演示
        demonstrateProxyChain();
        
        // 代理工厂演示
        demonstrateProxyFactory();
    }
    
    // JDK动态代理演示
    public static void demonstrateJDKProxy() {
        System.out.println("=== JDK动态代理演示 ===");
        
        // 创建真实对象
        UserService realUserService = new UserServiceImpl();
        
        // 创建代理对象
        UserService proxyUserService = (UserService) Proxy.newProxyInstance(
            UserService.class.getClassLoader(),
            new Class[]{UserService.class},
            new LoggingInvocationHandler(realUserService)
        );
        
        System.out.println("真实对象类型: " + realUserService.getClass().getName());
        System.out.println("代理对象类型: " + proxyUserService.getClass().getName());
        System.out.println("是否为代理: " + Proxy.isProxyClass(proxyUserService.getClass()));
        
        // 调用代理方法
        System.out.println("\n调用代理方法:");
        User user = proxyUserService.findById(1L);
        System.out.println("返回结果: " + user);
        
        proxyUserService.save(new User(2L, "李四", "lisi@example.com"));
        
        proxyUserService.delete(1L);
    }
    
    // 代理链演示
    public static void demonstrateProxyChain() {
        System.out.println("\n=== 代理链演示 ===");
        
        UserService realService = new UserServiceImpl();
        
        // 创建多层代理
        UserService loggedService = (UserService) Proxy.newProxyInstance(
            UserService.class.getClassLoader(),
            new Class[]{UserService.class},
            new LoggingInvocationHandler(realService)
        );
        
        UserService cachedService = (UserService) Proxy.newProxyInstance(
            UserService.class.getClassLoader(),
            new Class[]{UserService.class},
            new CachingInvocationHandler(loggedService)
        );
        
        UserService securedService = (UserService) Proxy.newProxyInstance(
            UserService.class.getClassLoader(),
            new Class[]{UserService.class},
            new SecurityInvocationHandler(cachedService)
        );
        
        System.out.println("调用多层代理:");
        User user = securedService.findById(1L);
        System.out.println("最终结果: " + user);
    }
    
    // 代理工厂演示
    public static void demonstrateProxyFactory() {
        System.out.println("\n=== 代理工厂演示 ===");
        
        UserService userService = ProxyFactory.createProxy(
            new UserServiceImpl(),
            UserService.class,
            new LoggingInvocationHandler(null),
            new CachingInvocationHandler(null),
            new PerformanceInvocationHandler(null)
        );
        
        System.out.println("通过工厂创建的代理:");
        userService.findById(1L);
        userService.findById(1L); // 第二次调用，测试缓存
    }
}

// 用户服务接口
interface UserService {
    User findById(Long id);
    void save(User user);
    void delete(Long id);
    List<User> findAll();
}

// 用户服务实现
class UserServiceImpl implements UserService {
    private Map<Long, User> users = new HashMap<>();
    
    public UserServiceImpl() {
        users.put(1L, new User(1L, "张三", "zhangsan@example.com"));
        users.put(2L, new User(2L, "李四", "lisi@example.com"));
    }
    
    @Override
    public User findById(Long id) {
        System.out.println("[UserServiceImpl] 查找用户: " + id);
        return users.get(id);
    }
    
    @Override
    public void save(User user) {
        System.out.println("[UserServiceImpl] 保存用户: " + user);
        users.put(user.getId(), user);
    }
    
    @Override
    public void delete(Long id) {
        System.out.println("[UserServiceImpl] 删除用户: " + id);
        users.remove(id);
    }
    
    @Override
    public List<User> findAll() {
        System.out.println("[UserServiceImpl] 查找所有用户");
        return new ArrayList<>(users.values());
    }
}

// 用户实体类
class User {
    private Long id;
    private String name;
    private String email;
    
    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }
    
    // getter和setter方法
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    
    @Override
    public String toString() {
        return "User{id=" + id + ", name='" + name + "', email='" + email + "'}";
    }
}

// 日志记录调用处理器
class LoggingInvocationHandler implements InvocationHandler {
    private Object target;
    
    public LoggingInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("[LOG] 调用方法: " + method.getName() + 
            " 参数: " + Arrays.toString(args));
        
        long startTime = System.currentTimeMillis();
        
        try {
            Object result = method.invoke(target, args);
            
            long endTime = System.currentTimeMillis();
            System.out.println("[LOG] 方法执行成功，耗时: " + (endTime - startTime) + "ms");
            
            return result;
        } catch (Exception e) {
            System.out.println("[LOG] 方法执行失败: " + e.getMessage());
            throw e;
        }
    }
}

// 缓存调用处理器
class CachingInvocationHandler implements InvocationHandler {
    private Object target;
    private Map<String, Object> cache = new HashMap<>();
    
    public CachingInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 只缓存查询方法
        if (method.getName().startsWith("find")) {
            String cacheKey = method.getName() + Arrays.toString(args);
            
            if (cache.containsKey(cacheKey)) {
                System.out.println("[CACHE] 缓存命中: " + cacheKey);
                return cache.get(cacheKey);
            }
            
            System.out.println("[CACHE] 缓存未命中: " + cacheKey);
            Object result = method.invoke(target, args);
            cache.put(cacheKey, result);
            return result;
        }
        
        return method.invoke(target, args);
    }
}

// 安全检查调用处理器
class SecurityInvocationHandler implements InvocationHandler {
    private Object target;
    private Set<String> allowedMethods = Set.of("findById", "findAll");
    
    public SecurityInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("[SECURITY] 检查方法权限: " + method.getName());
        
        if (!allowedMethods.contains(method.getName())) {
            throw new SecurityException("没有权限调用方法: " + method.getName());
        }
        
        System.out.println("[SECURITY] 权限检查通过");
        return method.invoke(target, args);
    }
}

// 性能监控调用处理器
class PerformanceInvocationHandler implements InvocationHandler {
    private Object target;
    
    public PerformanceInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.nanoTime();
        
        try {
            Object result = method.invoke(target, args);
            
            long endTime = System.nanoTime();
            double duration = (endTime - startTime) / 1_000_000.0;
            
            System.out.println("[PERFORMANCE] " + method.getName() + 
                " 执行时间: " + String.format("%.2f", duration) + "ms");
            
            return result;
        } catch (Exception e) {
            long endTime = System.nanoTime();
            double duration = (endTime - startTime) / 1_000_000.0;
            
            System.out.println("[PERFORMANCE] " + method.getName() + 
                " 执行失败，耗时: " + String.format("%.2f", duration) + "ms");
            
            throw e;
        }
    }
}

// 代理工厂
class ProxyFactory {
    
    @SuppressWarnings("unchecked")
    public static <T> T createProxy(Object target, Class<T> interfaceClass, 
                                   InvocationHandler... handlers) {
        Object proxy = target;
        
        // 从内到外创建代理链
        for (InvocationHandler handler : handlers) {
            // 设置处理器的目标对象
            setTarget(handler, proxy);
            
            proxy = Proxy.newProxyInstance(
                interfaceClass.getClassLoader(),
                new Class[]{interfaceClass},
                handler
            );
        }
        
        return (T) proxy;
    }
    
    private static void setTarget(InvocationHandler handler, Object target) {
        try {
            Field targetField = handler.getClass().getDeclaredField("target");
            targetField.setAccessible(true);
            targetField.set(handler, target);
        } catch (Exception e) {
            // 忽略设置失败
        }
    }
}

13.8 反射的性能优化

13.8.1 性能测试和优化技巧

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

// 反射性能优化演示
public class ReflectionPerformanceDemo {
    
    private static final int ITERATIONS = 1_000_000;
    
    public static void main(String[] args) {
        // 基础性能对比
        demonstrateBasicPerformance();
        
        // 缓存优化
        demonstrateCaching();
        
        // 访问权限优化
        demonstrateAccessibleOptimization();
        
        // 方法句柄优化
        demonstrateMethodHandles();
    }
    
    // 基础性能对比
    public static void demonstrateBasicPerformance() {
        System.out.println("=== 基础性能对比 ===");
        
        TestObject obj = new TestObject();
        
        // 直接调用
        long startTime = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) {
            obj.setValue(i);
            obj.getValue();
        }
        long directTime = System.nanoTime() - startTime;
        
        // 反射调用（每次获取Method）
        startTime = System.nanoTime();
        try {
            Class<?> clazz = obj.getClass();
            for (int i = 0; i < ITERATIONS; i++) {
                Method setMethod = clazz.getMethod("setValue", int.class);
                Method getMethod = clazz.getMethod("getValue");
                setMethod.invoke(obj, i);
                getMethod.invoke(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long reflectionTime = System.nanoTime() - startTime;
        
        // 反射调用（缓存Method）
        startTime = System.nanoTime();
        try {
            Class<?> clazz = obj.getClass();
            Method setMethod = clazz.getMethod("setValue", int.class);
            Method getMethod = clazz.getMethod("getValue");
            
            for (int i = 0; i < ITERATIONS; i++) {
                setMethod.invoke(obj, i);
                getMethod.invoke(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long cachedReflectionTime = System.nanoTime() - startTime;
        
        System.out.println("直接调用时间: " + formatTime(directTime));
        System.out.println("反射调用时间（每次获取Method）: " + formatTime(reflectionTime));
        System.out.println("反射调用时间（缓存Method）: " + formatTime(cachedReflectionTime));
        System.out.println("反射性能损失（未缓存）: " + (reflectionTime / (double) directTime) + "倍");
        System.out.println("反射性能损失（缓存）: " + (cachedReflectionTime / (double) directTime) + "倍");
    }
    
    // 缓存优化演示
    public static void demonstrateCaching() {
        System.out.println("\n=== 缓存优化演示 ===");
        
        TestObject obj = new TestObject();
        
        // 使用反射缓存
        ReflectionCache cache = new ReflectionCache();
        
        long startTime = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) {
            cache.invokeMethod(obj, "setValue", i);
            cache.invokeMethod(obj, "getValue");
        }
        long cachedTime = System.nanoTime() - startTime;
        
        // 不使用缓存
        startTime = System.nanoTime();
        try {
            Class<?> clazz = obj.getClass();
            for (int i = 0; i < ITERATIONS; i++) {
                Method setMethod = clazz.getMethod("setValue", int.class);
                Method getMethod = clazz.getMethod("getValue");
                setMethod.invoke(obj, i);
                getMethod.invoke(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long uncachedTime = System.nanoTime() - startTime;
        
        System.out.println("使用缓存时间: " + formatTime(cachedTime));
        System.out.println("不使用缓存时间: " + formatTime(uncachedTime));
        System.out.println("缓存性能提升: " + (uncachedTime / (double) cachedTime) + "倍");
    }
    
    // 访问权限优化演示
    public static void demonstrateAccessibleOptimization() {
        System.out.println("\n=== 访问权限优化演示 ===");
        
        TestObject obj = new TestObject();
        
        try {
            Class<?> clazz = obj.getClass();
            Field field = clazz.getDeclaredField("value");
            
            // 每次设置accessible
            long startTime = System.nanoTime();
            for (int i = 0; i < ITERATIONS; i++) {
                field.setAccessible(true);
                field.set(obj, i);
                field.get(obj);
            }
            long everyTimeTime = System.nanoTime() - startTime;
            
            // 只设置一次accessible
            field.setAccessible(true);
            startTime = System.nanoTime();
            for (int i = 0; i < ITERATIONS; i++) {
                field.set(obj, i);
                field.get(obj);
            }
            long onceTime = System.nanoTime() - startTime;
            
            System.out.println("每次设置accessible时间: " + formatTime(everyTimeTime));
            System.out.println("只设置一次accessible时间: " + formatTime(onceTime));
            System.out.println("优化性能提升: " + (everyTimeTime / (double) onceTime) + "倍");
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    // 方法句柄优化演示
    public static void demonstrateMethodHandles() {
        System.out.println("\n=== 方法句柄优化演示 ===");
        
        TestObject obj = new TestObject();
        
        try {
            // 使用反射
            Class<?> clazz = obj.getClass();
            Method setMethod = clazz.getMethod("setValue", int.class);
            Method getMethod = clazz.getMethod("getValue");
            
            long startTime = System.nanoTime();
            for (int i = 0; i < ITERATIONS; i++) {
                setMethod.invoke(obj, i);
                getMethod.invoke(obj);
            }
            long reflectionTime = System.nanoTime() - startTime;
            
            // 使用方法句柄
            MethodHandles.Lookup lookup = MethodHandles.lookup();
            MethodHandle setHandle = lookup.findVirtual(clazz, "setValue", 
                MethodType.methodType(void.class, int.class));
            MethodHandle getHandle = lookup.findVirtual(clazz, "getValue", 
                MethodType.methodType(int.class));
            
            startTime = System.nanoTime();
            for (int i = 0; i < ITERATIONS; i++) {
                setHandle.invoke(obj, i);
                getHandle.invoke(obj);
            }
            long methodHandleTime = System.nanoTime() - startTime;
            
            System.out.println("反射调用时间: " + formatTime(reflectionTime));
            System.out.println("方法句柄时间: " + formatTime(methodHandleTime));
            System.out.println("方法句柄性能提升: " + (reflectionTime / (double) methodHandleTime) + "倍");
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    private static String formatTime(long nanos) {
        return String.format("%.2f ms", nanos / 1_000_000.0);
    }
}

// 测试对象
class TestObject {
    private int value;
    
    public int getValue() {
        return value;
    }
    
    public void setValue(int value) {
        this.value = value;
    }
}

// 反射缓存类
class ReflectionCache {
    private final Map<String, Method> methodCache = new ConcurrentHashMap<>();
    private final Map<String, Field> fieldCache = new ConcurrentHashMap<>();
    private final Map<String, Constructor<?>> constructorCache = new ConcurrentHashMap<>();
    
    public Method getMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) {
        String key = clazz.getName() + "." + methodName + Arrays.toString(paramTypes);
        return methodCache.computeIfAbsent(key, k -> {
            try {
                Method method = clazz.getMethod(methodName, paramTypes);
                method.setAccessible(true);
                return method;
            } catch (NoSuchMethodException e) {
                throw new RuntimeException(e);
            }
        });
    }
    
    public 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 Constructor<?> getConstructor(Class<?> clazz, Class<?>... paramTypes) {
        String key = clazz.getName() + ".constructor" + Arrays.toString(paramTypes);
        return constructorCache.computeIfAbsent(key, k -> {
            try {
                Constructor<?> constructor = clazz.getConstructor(paramTypes);
                constructor.setAccessible(true);
                return constructor;
            } catch (NoSuchMethodException e) {
                throw new RuntimeException(e);
            }
        });
    }
    
    public Object invokeMethod(Object target, String methodName, Object... args) {
        try {
            Class<?>[] paramTypes = new Class[args.length];
            for (int i = 0; i < args.length; i++) {
                paramTypes[i] = args[i].getClass();
                // 处理基本类型
                if (paramTypes[i] == Integer.class) paramTypes[i] = int.class;
                else if (paramTypes[i] == Long.class) paramTypes[i] = long.class;
                else if (paramTypes[i] == Double.class) paramTypes[i] = double.class;
                else if (paramTypes[i] == Boolean.class) paramTypes[i] = boolean.class;
                // 可以添加更多基本类型的处理
            }
            
            Method method = getMethod(target.getClass(), methodName, paramTypes);
            return method.invoke(target, args);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    public Object getFieldValue(Object target, String fieldName) {
        try {
            Field field = getField(target.getClass(), fieldName);
            return field.get(target);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    public void setFieldValue(Object target, String fieldName, Object value) {
        try {
            Field field = getField(target.getClass(), fieldName);
            field.set(target, value);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    public Object createInstance(Class<?> clazz, Object... args) {
        try {
            Class<?>[] paramTypes = new Class[args.length];
            for (int i = 0; i < args.length; i++) {
                paramTypes[i] = args[i].getClass();
            }
            
            Constructor<?> constructor = getConstructor(clazz, paramTypes);
            return constructor.newInstance(args);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    // 清理缓存
    public void clearCache() {
        methodCache.clear();
        fieldCache.clear();
        constructorCache.clear();
    }
    
    // 获取缓存统计信息
    public void printCacheStats() {
        System.out.println("缓存统计信息:");
        System.out.println("  方法缓存数量: " + methodCache.size());
        System.out.println("  字段缓存数量: " + fieldCache.size());
        System.out.println("  构造器缓存数量: " + constructorCache.size());
    }
}

13.9 反射的最佳实践

13.9.1 使用指南和注意事项

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

// 反射最佳实践演示
public class ReflectionBestPracticesDemo {
    
    public static void main(String[] args) {
        // 安全使用反射
        demonstrateSafety();
        
        // 错误处理
        demonstrateErrorHandling();
        
        // 类型安全
        demonstrateTypeSafety();
        
        // 反射工具类
        demonstrateUtilityClass();
    }
    
    // 安全使用反射
    public static void demonstrateSafety() {
        System.out.println("=== 安全使用反射 ===");
        
        // 1. 检查安全管理器
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            System.out.println("检测到安全管理器，需要相应权限");
        }
        
        // 2. 验证类的来源
        Class<?> clazz = String.class;
        System.out.println("类加载器: " + clazz.getClassLoader());
        System.out.println("保护域: " + clazz.getProtectionDomain());
        
        // 3. 限制反射操作的范围
        SafeReflectionHelper helper = new SafeReflectionHelper();
        
        // 只允许操作特定包下的类
        helper.addAllowedPackage("com.example.model");
        helper.addAllowedPackage("com.example.dto");
        
        try {
            // 安全的反射操作
            Object result = helper.safeInvoke(new TestModel(), "getValue");
            System.out.println("安全调用结果: " + result);
        } catch (SecurityException e) {
            System.out.println("安全检查失败: " + e.getMessage());
        }
    }
    
    // 错误处理演示
    public static void demonstrateErrorHandling() {
        System.out.println("\n=== 错误处理演示 ===");
        
        ReflectionErrorHandler handler = new ReflectionErrorHandler();
        
        // 处理各种反射异常
        handler.handleClassNotFound("com.nonexistent.Class");
        handler.handleMethodNotFound(String.class, "nonExistentMethod");
        handler.handleFieldNotFound(String.class, "nonExistentField");
        handler.handleIllegalAccess(String.class, "value");
        handler.handleInvocationTarget(TestModel.class, "throwException");
    }
    
    // 类型安全演示
    public static void demonstrateTypeSafety() {
        System.out.println("\n=== 类型安全演示 ===");
        
        TypeSafeReflection reflection = new TypeSafeReflection();
        
        TestModel model = new TestModel();
        
        // 类型安全的字段操作
        reflection.setField(model, "value", 42);
        Integer value = reflection.getField(model, "value", Integer.class);
        System.out.println("类型安全获取字段值: " + value);
        
        // 类型安全的方法调用
        String result = reflection.invokeMethod(model, "toString", String.class);
        System.out.println("类型安全方法调用: " + result);
        
        // 类型安全的对象创建
        TestModel newModel = reflection.createInstance(TestModel.class, 100);
        System.out.println("类型安全创建对象: " + newModel);
    }
    
    // 反射工具类演示
    public static void demonstrateUtilityClass() {
        System.out.println("\n=== 反射工具类演示 ===");
        
        TestModel source = new TestModel("源对象", 100);
        TestModel target = new TestModel();
        
        // 对象复制
        ReflectionUtils.copyProperties(source, target);
        System.out.println("复制后的目标对象: " + target);
        
        // 对象比较
        TestModel another = new TestModel("源对象", 100);
        boolean equals = ReflectionUtils.deepEquals(source, another);
        System.out.println("深度比较结果: " + equals);
        
        // 对象转Map
        Map<String, Object> map = ReflectionUtils.objectToMap(source);
        System.out.println("对象转Map: " + map);
        
        // Map转对象
        TestModel fromMap = ReflectionUtils.mapToObject(map, TestModel.class);
        System.out.println("Map转对象: " + fromMap);
    }
}

// 测试模型类
class TestModel {
    private String name;
    private Integer value;
    
    public TestModel() {}
    
    public TestModel(String name, Integer value) {
        this.name = name;
        this.value = value;
    }
    
    public TestModel(Integer value) {
        this.value = value;
    }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public Integer getValue() { return value; }
    public void setValue(Integer value) { this.value = value; }
    
    public void throwException() {
        throw new RuntimeException("测试异常");
    }
    
    @Override
    public String toString() {
        return "TestModel{name='" + name + "', value=" + value + "}";
    }
}

// 安全反射助手
class SafeReflectionHelper {
    private final Set<String> allowedPackages = new HashSet<>();
    private final Set<String> blockedClasses = new HashSet<>();
    
    public void addAllowedPackage(String packageName) {
        allowedPackages.add(packageName);
    }
    
    public void addBlockedClass(String className) {
        blockedClasses.add(className);
    }
    
    public Object safeInvoke(Object target, String methodName, Object... args) {
        // 安全检查
        checkSecurity(target.getClass());
        
        try {
            Class<?> clazz = target.getClass();
            Method method = findMethod(clazz, methodName, args);
            
            if (method == null) {
                throw new NoSuchMethodException("方法不存在: " + methodName);
            }
            
            return method.invoke(target, args);
        } catch (Exception e) {
            throw new RuntimeException("安全调用失败", e);
        }
    }
    
    private void checkSecurity(Class<?> clazz) {
        String className = clazz.getName();
        String packageName = clazz.getPackage() != null ? clazz.getPackage().getName() : "";
        
        // 检查是否在黑名单中
        if (blockedClasses.contains(className)) {
            throw new SecurityException("类被禁止访问: " + className);
        }
        
        // 检查是否在允许的包中
        if (!allowedPackages.isEmpty()) {
            boolean allowed = allowedPackages.stream()
                .anyMatch(packageName::startsWith);
            
            if (!allowed) {
                throw new SecurityException("包不在允许列表中: " + packageName);
            }
        }
        
        // 禁止访问系统关键类
        if (className.startsWith("java.lang.System") ||
            className.startsWith("java.lang.Runtime") ||
            className.startsWith("java.lang.ProcessBuilder")) {
            throw new SecurityException("禁止访问系统关键类: " + className);
        }
    }
    
    private Method findMethod(Class<?> clazz, String methodName, Object... args) {
        Method[] methods = clazz.getMethods();
        
        for (Method method : methods) {
            if (method.getName().equals(methodName) && 
                method.getParameterCount() == args.length) {
                return method;
            }
        }
        
        return null;
    }
}

// 反射错误处理器
class ReflectionErrorHandler {
    
    public void handleClassNotFound(String className) {
        try {
            Class.forName(className);
        } catch (ClassNotFoundException e) {
            System.out.println("处理ClassNotFoundException: 类 " + className + " 不存在");
            // 记录日志、提供默认实现等
        }
    }
    
    public void handleMethodNotFound(Class<?> clazz, String methodName) {
        try {
            clazz.getMethod(methodName);
        } catch (NoSuchMethodException e) {
            System.out.println("处理NoSuchMethodException: 方法 " + methodName + " 不存在");
            // 提供替代方法、记录警告等
        }
    }
    
    public void handleFieldNotFound(Class<?> clazz, String fieldName) {
        try {
            clazz.getDeclaredField(fieldName);
        } catch (NoSuchFieldException e) {
            System.out.println("处理NoSuchFieldException: 字段 " + fieldName + " 不存在");
            // 使用默认值、记录警告等
        }
    }
    
    public void handleIllegalAccess(Class<?> clazz, String fieldName) {
        try {
            Field field = clazz.getDeclaredField(fieldName);
            field.get(null); // 故意触发异常
        } catch (NoSuchFieldException e) {
            System.out.println("字段不存在: " + fieldName);
        } catch (IllegalAccessException e) {
            System.out.println("处理IllegalAccessException: 无法访问字段 " + fieldName);
            // 尝试设置accessible、使用公共方法等
        }
    }
    
    public void handleInvocationTarget(Class<?> clazz, String methodName) {
        try {
            Object instance = clazz.getDeclaredConstructor().newInstance();
            Method method = clazz.getMethod(methodName);
            method.invoke(instance);
        } catch (InvocationTargetException e) {
            System.out.println("处理InvocationTargetException: 方法执行异常");
            System.out.println("原始异常: " + e.getCause().getMessage());
            // 处理业务异常、重试、降级等
        } catch (Exception e) {
            System.out.println("其他异常: " + e.getMessage());
        }
    }
}

// 类型安全反射
class TypeSafeReflection {
    
    @SuppressWarnings("unchecked")
    public <T> T getField(Object target, String fieldName, Class<T> expectedType) {
        try {
            Field field = target.getClass().getDeclaredField(fieldName);
            field.setAccessible(true);
            Object value = field.get(target);
            
            if (value == null) {
                return null;
            }
            
            if (!expectedType.isInstance(value)) {
                throw new ClassCastException("字段类型不匹配，期望: " + expectedType.getName() + 
                    ", 实际: " + value.getClass().getName());
            }
            
            return (T) value;
        } catch (Exception e) {
            throw new RuntimeException("获取字段失败: " + fieldName, e);
        }
    }
    
    public void setField(Object target, String fieldName, Object value) {
        try {
            Field field = target.getClass().getDeclaredField(fieldName);
            field.setAccessible(true);
            
            // 类型检查
            Class<?> fieldType = field.getType();
            if (value != null && !isAssignable(fieldType, value.getClass())) {
                throw new IllegalArgumentException("值类型不匹配，字段类型: " + fieldType.getName() + 
                    ", 值类型: " + value.getClass().getName());
            }
            
            field.set(target, value);
        } catch (Exception e) {
            throw new RuntimeException("设置字段失败: " + fieldName, e);
        }
    }
    
    @SuppressWarnings("unchecked")
    public <T> T invokeMethod(Object target, String methodName, Class<T> returnType, Object... args) {
        try {
            Class<?>[] paramTypes = new Class[args.length];
            for (int i = 0; i < args.length; i++) {
                paramTypes[i] = args[i] != null ? args[i].getClass() : Object.class;
            }
            
            Method method = findCompatibleMethod(target.getClass(), methodName, paramTypes);
            if (method == null) {
                throw new NoSuchMethodException("找不到兼容的方法: " + methodName);
            }
            
            Object result = method.invoke(target, args);
            
            if (result == null) {
                return null;
            }
            
            if (!returnType.isInstance(result)) {
                throw new ClassCastException("返回类型不匹配，期望: " + returnType.getName() + 
                    ", 实际: " + result.getClass().getName());
            }
            
            return (T) result;
        } catch (Exception e) {
            throw new RuntimeException("调用方法失败: " + methodName, e);
        }
    }
    
    public <T> T createInstance(Class<T> clazz, Object... args) {
        try {
            if (args.length == 0) {
                return clazz.getDeclaredConstructor().newInstance();
            }
            
            Class<?>[] paramTypes = new Class[args.length];
            for (int i = 0; i < args.length; i++) {
                paramTypes[i] = args[i] != null ? args[i].getClass() : Object.class;
            }
            
            Constructor<T> constructor = findCompatibleConstructor(clazz, paramTypes);
            if (constructor == null) {
                throw new NoSuchMethodException("找不到兼容的构造器");
            }
            
            return constructor.newInstance(args);
        } catch (Exception e) {
            throw new RuntimeException("创建实例失败: " + clazz.getName(), e);
        }
    }
    
    private boolean isAssignable(Class<?> target, Class<?> source) {
        if (target.isAssignableFrom(source)) {
            return true;
        }
        
        // 处理基本类型和包装类型
        if (target.isPrimitive()) {
            if (target == int.class && source == Integer.class) return true;
            if (target == long.class && source == Long.class) return true;
            if (target == double.class && source == Double.class) return true;
            if (target == boolean.class && source == Boolean.class) return true;
            // 可以添加更多类型
        }
        
        return false;
    }
    
    private Method findCompatibleMethod(Class<?> clazz, String methodName, Class<?>[] paramTypes) {
        Method[] methods = clazz.getMethods();
        
        for (Method method : methods) {
            if (method.getName().equals(methodName) && 
                isParametersCompatible(method.getParameterTypes(), paramTypes)) {
                return method;
            }
        }
        
        return null;
    }
    
    private <T> Constructor<T> findCompatibleConstructor(Class<T> clazz, Class<?>[] paramTypes) {
        @SuppressWarnings("unchecked")
        Constructor<T>[] constructors = (Constructor<T>[]) clazz.getConstructors();
        
        for (Constructor<T> constructor : constructors) {
            if (isParametersCompatible(constructor.getParameterTypes(), paramTypes)) {
                return constructor;
            }
        }
        
        return null;
    }
    
    private boolean isParametersCompatible(Class<?>[] methodParams, Class<?>[] argTypes) {
        if (methodParams.length != argTypes.length) {
            return false;
        }
        
        for (int i = 0; i < methodParams.length; i++) {
            if (!isAssignable(methodParams[i], argTypes[i])) {
                return false;
            }
        }
        
        return true;
    }
}

// 反射工具类
class ReflectionUtils {
    
    // 复制对象属性
    public static void copyProperties(Object source, Object target) {
        if (source == null || target == null) {
            return;
        }
        
        Class<?> sourceClass = source.getClass();
        Class<?> targetClass = target.getClass();
        
        Field[] sourceFields = sourceClass.getDeclaredFields();
        
        for (Field sourceField : sourceFields) {
            try {
                Field targetField = targetClass.getDeclaredField(sourceField.getName());
                
                if (targetField.getType().isAssignableFrom(sourceField.getType())) {
                    sourceField.setAccessible(true);
                    targetField.setAccessible(true);
                    
                    Object value = sourceField.get(source);
                    targetField.set(target, value);
                }
            } catch (NoSuchFieldException e) {
                // 目标对象没有对应字段，跳过
            } catch (Exception e) {
                throw new RuntimeException("复制属性失败: " + sourceField.getName(), e);
            }
        }
    }
    
    // 深度比较对象
    public static boolean deepEquals(Object obj1, Object obj2) {
        if (obj1 == obj2) {
            return true;
        }
        
        if (obj1 == null || obj2 == null) {
            return false;
        }
        
        if (!obj1.getClass().equals(obj2.getClass())) {
            return false;
        }
        
        Field[] fields = obj1.getClass().getDeclaredFields();
        
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                Object value1 = field.get(obj1);
                Object value2 = field.get(obj2);
                
                if (!Objects.equals(value1, value2)) {
                    return false;
                }
            } catch (Exception e) {
                throw new RuntimeException("比较字段失败: " + field.getName(), e);
            }
        }
        
        return true;
    }
    
    // 对象转Map
    public static Map<String, Object> objectToMap(Object obj) {
        if (obj == null) {
            return new HashMap<>();
        }
        
        Map<String, Object> map = new HashMap<>();
        Field[] fields = obj.getClass().getDeclaredFields();
        
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                Object value = field.get(obj);
                map.put(field.getName(), value);
            } catch (Exception e) {
                throw new RuntimeException("转换字段失败: " + field.getName(), e);
            }
        }
        
        return map;
    }
    
    // Map转对象
    public static <T> T mapToObject(Map<String, Object> map, Class<T> clazz) {
        try {
            T instance = clazz.getDeclaredConstructor().newInstance();
            
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                try {
                    Field field = clazz.getDeclaredField(entry.getKey());
                    field.setAccessible(true);
                    field.set(instance, entry.getValue());
                } catch (NoSuchFieldException e) {
                    // 字段不存在，跳过
                }
            }
            
            return instance;
        } catch (Exception e) {
            throw new RuntimeException("Map转对象失败: " + clazz.getName(), e);
        }
    }
}

13.10 本章小结

13.10.1 反射机制总结

反射是Java语言的一个重要特性，它提供了在运行时检查和操作类、方法、字段等程序结构的能力。通过本章的学习，我们了解了：

核心概念： - Class对象是反射的入口点 - 反射可以获取类的完整信息 - 反射可以动态创建对象和调用方法 - 反射可以访问私有成员

主要应用场景： - 框架开发（Spring、Hibernate等） - 依赖注入和控制反转 - 动态代理和AOP - 序列化和反序列化 - 配置驱动的程序设计 - 通用工具类开发

性能考虑： - 反射比直接调用慢10-100倍 - 缓存反射对象可以显著提升性能 - 设置accessible一次即可 - 方法句柄比反射性能更好

最佳实践： - 进行安全检查，防止恶意访问 - 妥善处理各种反射异常 - 使用类型安全的反射操作 - 缓存反射对象以提升性能 - 谨慎使用反射，优先考虑其他设计模式

13.10.2 下一章预告

下一章我们将学习Java I/O编程，包括： - 文件操作和目录管理 - 字节流和字符流 - 缓冲流和转换流 - 序列化和反序列化 - NIO和NIO.2 - 文件监控和异步I/O

13.10.3 练习题

1. 基础练习：编写一个通用的对象复制工具，使用反射复制任意对象的所有字段。

2. 进阶练习：实现一个简单的依赖注入容器，支持构造器注入和字段注入。

3. 高级练习：创建一个动态代理工厂，支持多种切面（日志、缓存、事务、安全）的组合。

4. 性能练习：比较反射、方法句柄和直接调用的性能差异，并实现一个高性能的反射缓存。

5. 实战练习：开发一个通用的对象验证框架，支持注解驱动的字段验证规则。 “`