反射工具 - ReflectionUtils

概述

ReflectionUtils 是 Spring Framework 提供的反射工具类，位于 org.springframework.util 包下。它封装了 Java 反射 API 的常用操作，提供了缓存机制、异常处理和更便捷的 API，解决了标准 Java 反射操作繁琐、性能差、异常处理复杂等问题。

核心能力矩阵

能力	核心类	解决的问题	使用频率	学习优先级
方法操作	`ReflectionUtils`	方法查找、调用、批量处理	⭐⭐⭐⭐⭐	🔴 高
字段操作	`ReflectionUtils`	字段查找、读写、批量处理	⭐⭐⭐⭐⭐	🔴 高
访问控制	`ReflectionUtils`	突破 private 限制	⭐⭐⭐⭐	🟡 中
缓存机制	`ReflectionUtils`	性能优化	⭐⭐⭐⭐	🟡 中

1. 代码结构分析

1.1 核心类结构

1.2 源码模块划分

模块	核心方法	功能说明
方法查找	`findMethod()`, `findMethod(Class, String, Class...)`	递归查找类及其父类的方法
方法调用	`invokeMethod()`, `handleInvocationTargetException()`	包装反射调用，统一异常处理
批量方法处理	`doWithMethods()`, `doWithLocalMethods()`	批量处理方法，支持过滤
字段查找	`findField()`, `findField(Class, String, Class)`	递归查找类及其父类的字段
字段操作	`getField()`, `setField()`	读取和设置字段值
批量字段处理	`doWithFields()`, `doWithLocalFields()`	批量处理字段，支持过滤
访问控制	`makeAccessible()`	设置可访问性，突破 private
异常处理	`handleReflectionException()`, `rethrowRuntimeException()`	统一异常转换
缓存管理	`clearCache()`, `isCglibRenamedMethod()`	方法和字段缓存

1.3 设计特点

2. 主要使用场景

2.1 场景矩阵

场景	问题描述	Spring 解决方案	复杂度
依赖注入	需要调用 @Autowired 标注的方法/字段	`doWithMethods()` + 注解过滤	中
属性复制	对象间属性拷贝	`doWithFields()` + 字段匹配	中
动态代理	需要调用目标对象的方法	`invokeMethod()` + 异常包装	高
注解处理	扫描类中的注解元素	`doWithMethods/Fields()` + 过滤	中
测试工具	测试私有方法	`makeAccessible()` + `invokeMethod()`	低
JSON 序列化	获取对象所有字段值	`doWithFields()` + 递归	中

2.2 场景详细分析

场景1：依赖注入（@Autowired 处理）

场景描述：Spring 需要找到并调用所有标注了 @Autowired 的方法进行依赖注入。

原生 Java 反射的问题：

java

// 1. 需要递归查找父类
// 2. 需要处理受检异常
// 3. 需要过滤特定注解
// 4. 代码量大且重复

Spring 解决方案：

java

ReflectionUtils.doWithMethods(targetClass, method -> {
    if (method.isAnnotationPresent(Autowired.class)) {
        ReflectionUtils.makeAccessible(method);
        // 执行注入逻辑
    }
}, ReflectionUtils.USER_DECLARED_METHODS);

场景2：属性复制（BeanUtils.copyProperties）

场景描述：将一个对象的属性值复制到另一个对象。

Spring 解决方案：

java

ReflectionUtils.doWithFields(source.getClass(), field -> {
    ReflectionUtils.makeAccessible(field);
    Object value = ReflectionUtils.getField(field, source);
    
    Field targetField = ReflectionUtils.findField(target.getClass(), field.getName());
    if (targetField != null) {
        ReflectionUtils.makeAccessible(targetField);
        ReflectionUtils.setField(targetField, target, value);
    }
});

场景3：动态代理方法调用

场景描述：AOP 代理需要调用目标对象的方法。

Spring 解决方案：

java

Method method = ReflectionUtils.findMethod(targetClass, methodName, paramTypes);
if (method != null) {
    ReflectionUtils.makeAccessible(method);
    return ReflectionUtils.invokeMethod(method, target, args);
}

场景4：测试私有方法

场景描述：单元测试需要调用私有方法。

Spring 解决方案：

java

Method privateMethod = ReflectionUtils.findMethod(service.getClass(), "validateData", String.class);
ReflectionUtils.makeAccessible(privateMethod);
Boolean result = (Boolean) ReflectionUtils.invokeMethod(privateMethod, service, "test");

3. 围绕主要场景的封装设计

3.1 封装设计目标

目标	说明	实现方式
简化 API	一行代码完成常见反射操作	提供高级封装方法
类型安全	减少强制类型转换	泛型方法设计
异常统一	统一处理反射异常	运行时异常包装
性能优化	缓存 + 批量操作	内置缓存策略
链式操作	支持流畅的 API 调用	返回 this 或 Builder

3.2 封装架构设计

3.3 封装 API 设计

3.3.1 门面类设计

java

/**
 * LinsirReflection - 反射工具门面类
 * 
 * 设计要点：
 * 1. 工具类，禁止实例化
 * 2. 所有方法静态，便于调用
 * 3. 泛型方法提供类型安全
 * 4. 异常统一包装为运行时异常
 * 5. 内置缓存提升性能
 */
public final class LinsirReflection {
    
    // 私有构造器
    private LinsirReflection() {
        throw new AssertionError("工具类禁止实例化");
    }
    
    // ==================== 方法操作 ====================
    
    /**
     * 查找方法（递归查找父类）
     * 
     * @param clazz 目标类
     * @param name 方法名
     * @param paramTypes 参数类型
     * @return Method 对象，未找到返回 null
     */
    public static Method findMethod(Class<?> clazz, String name, Class<?>... paramTypes);
    
    /**
     * 调用方法（自动处理可访问性）
     * 
     * @param method 方法对象
     * @param target 目标对象
     * @param args 参数
     * @return 返回值
     * @throws ReflectionException 反射异常
     */
    public static Object invokeMethod(Method method, Object target, Object... args);
    
    /**
     * 类型安全的调用方法
     * 
     * @param method 方法对象
     * @param target 目标对象
     * @param args 参数
     * @param <T> 返回类型
     * @return 返回值
     */
    public static <T> T invokeMethod(Method method, Object target, Class<T> returnType, Object... args);
    
    /**
     * 批量处理方法
     * 
     * @param clazz 目标类
     * @param callback 处理回调
     * @param filter 过滤器（可选）
     */
    public static void doWithMethods(Class<?> clazz, MethodCallback callback, MethodFilter filter);
    
    // ==================== 字段操作 ====================
    
    /**
     * 查找字段（递归查找父类）
     * 
     * @param clazz 目标类
     * @param name 字段名
     * @return Field 对象，未找到返回 null
     */
    public static Field findField(Class<?> clazz, String name);
    
    /**
     * 获取字段值
     * 
     * @param field 字段对象
     * @param target 目标对象
     * @return 字段值
     */
    public static Object getFieldValue(Field field, Object target);
    
    /**
     * 类型安全的获取字段值
     * 
     * @param field 字段对象
     * @param target 目标对象
     * @param <T> 字段类型
     * @return 字段值
     */
    public static <T> T getFieldValue(Field field, Object target, Class<T> fieldType);
    
    /**
     * 设置字段值
     * 
     * @param field 字段对象
     * @param target 目标对象
     * @param value 字段值
     */
    public static void setFieldValue(Field field, Object target, Object value);
    
    /**
     * 批量处理字段
     * 
     * @param clazz 目标类
     * @param callback 处理回调
     * @param filter 过滤器（可选）
     */
    public static void doWithFields(Class<?> clazz, FieldCallback callback, FieldFilter filter);
    
    // ==================== 高级封装 ====================
    
    /**
     * 复制对象属性
     * 
     * @param source 源对象
     * @param target 目标对象
     * @param ignoreProperties 忽略的属性名
     */
    public static void copyProperties(Object source, Object target, String... ignoreProperties);
    
    /**
     * 获取所有字段值映射
     * 
     * @param object 目标对象
     * @return 字段名 -> 字段值 的映射
     */
    public static Map<String, Object> getFieldValues(Object object);
    
    /**
     * 调用指定名称的方法
     * 
     * @param target 目标对象
     * @param methodName 方法名
     * @param args 参数
     * @return 返回值
     */
    public static Object invokeMethodByName(Object target, String methodName, Object... args);
    
    /**
     * 获取指定注解标注的方法列表
     * 
     * @param clazz 目标类
     * @param annotationType 注解类型
     * @return 方法列表
     */
    public static List<Method> getAnnotatedMethods(Class<?> clazz, Class<? extends Annotation> annotationType);
    
    /**
     * 获取指定注解标注的字段列表
     * 
     * @param clazz 目标类
     * @param annotationType 注解类型
     * @return 字段列表
     */
    public static List<Field> getAnnotatedFields(Class<?> clazz, Class<? extends Annotation> annotationType);
    
    // ==================== 缓存管理 ====================
    
    /**
     * 清除反射缓存
     */
    public static void clearCache();
    
    /**
     * 获取缓存统计信息
     * 
     * @return 缓存统计
     */
    public static CacheStats getCacheStats();
}

3.3.2 回调接口设计

java

/**
 * 方法回调接口
 */
@FunctionalInterface
public interface MethodCallback {
    void doWith(Method method) throws IllegalArgumentException, IllegalAccessException;
}

/**
 * 方法过滤器接口
 */
@FunctionalInterface
public interface MethodFilter {
    boolean matches(Method method);
}

/**
 * 字段回调接口
 */
@FunctionalInterface
public interface FieldCallback {
    void doWith(Field field) throws IllegalArgumentException, IllegalAccessException;
}

/**
 * 字段过滤器接口
 */
@FunctionalInterface
public interface FieldFilter {
    boolean matches(Field field);
}

3.3.3 异常体系设计

java

/**
 * 反射操作异常
 */
public class ReflectionException extends RuntimeException {
    
    public ReflectionException(String message) {
        super(message);
    }
    
    public ReflectionException(String message, Throwable cause) {
        super(message, cause);
    }
    
    public ReflectionException(Throwable cause) {
        super(cause);
    }
}

/**
 * 方法调用异常
 */
public class MethodInvocationException extends ReflectionException {
    
    private final Method method;
    private final Object target;
    private final Object[] args;
    
    // 构造器和 getter...
}

/**
 * 字段访问异常
 */
public class FieldAccessException extends ReflectionException {
    
    private final Field field;
    private final Object target;
    
    // 构造器和 getter...
}

3.3.4 缓存设计

java

/**
 * 反射缓存管理器
 */
public class ReflectionCache {
    
    // 方法缓存：类 -> 方法数组
    private final ConcurrentMap<Class<?>, Method[]> declaredMethodsCache = 
        new ConcurrentHashMap<>(256);
    
    // 字段缓存：类 -> 字段数组
    private final ConcurrentMap<Class<?>, Field[]> declaredFieldsCache = 
        new ConcurrentHashMap<>(256);
    
    // 方法查找缓存：类+方法名+参数类型 -> Method
    private final ConcurrentMap<MethodCacheKey, Method> methodLookupCache = 
        new ConcurrentHashMap<>(256);
    
    // 字段查找缓存：类+字段名 -> Field
    private final ConcurrentMap<FieldCacheKey, Field> fieldLookupCache = 
        new ConcurrentHashMap<>(256);
    
    /**
     * 获取声明的方法（带缓存）
     */
    public Method[] getDeclaredMethods(Class<?> clazz);
    
    /**
     * 获取声明的字段（带缓存）
     */
    public Field[] getDeclaredFields(Class<?> clazz);
    
    /**
     * 缓存方法查找结果
     */
    public void cacheMethod(MethodCacheKey key, Method method);
    
    /**
     * 缓存字段查找结果
     */
    public void cacheField(FieldCacheKey key, Field field);
    
    /**
     * 清除缓存
     */
    public void clear();
    
    /**
     * 获取缓存统计
     */
    public CacheStats getStats();
}

3.4 使用示例

示例1：依赖注入场景

java

// 封装前（Spring 原生）
ReflectionUtils.doWithMethods(targetClass, method -> {
    if (method.isAnnotationPresent(Autowired.class)) {
        ReflectionUtils.makeAccessible(method);
        Object[] args = resolveDependencies(method);
        ReflectionUtils.invokeMethod(method, target, args);
    }
}, ReflectionUtils.USER_DECLARED_METHODS);

// 封装后
LinsirReflection.getAnnotatedMethods(targetClass, Autowired.class)
    .forEach(method -> {
        Object[] args = resolveDependencies(method);
        LinsirReflection.invokeMethod(method, target, args);
    });

示例2：属性复制场景

java

// 封装前
ReflectionUtils.doWithFields(source.getClass(), field -> {
    ReflectionUtils.makeAccessible(field);
    Object value = ReflectionUtils.getField(field, source);
    Field targetField = ReflectionUtils.findField(target.getClass(), field.getName());
    if (targetField != null) {
        ReflectionUtils.makeAccessible(targetField);
        ReflectionUtils.setField(targetField, target, value);
    }
});

// 封装后
LinsirReflection.copyProperties(source, target, "id", "createTime");

示例3：获取对象所有字段值

java

// 封装前
Map<String, Object> values = new HashMap<>();
ReflectionUtils.doWithFields(object.getClass(), field -> {
    ReflectionUtils.makeAccessible(field);
    values.put(field.getName(), ReflectionUtils.getField(field, object));
});

// 封装后
Map<String, Object> values = LinsirReflection.getFieldValues(object);

4. 扩展该模块分析

4.1 扩展点识别

4.2 扩展点详细设计

4.2.1 缓存策略扩展

扩展目标：支持不同的缓存策略（LRU、TTL、软引用等）

java

/**
 * 缓存策略接口
 */
public interface CacheStrategy<K, V> {
    
    /**
     * 获取缓存值
     */
    V get(K key);
    
    /**
     * 放入缓存
     */
    void put(K key, V value);
    
    /**
     * 移除缓存
     */
    void remove(K key);
    
    /**
     * 清空缓存
     */
    void clear();
    
    /**
     * 获取缓存大小
     */
    int size();
}

/**
 * LRU 缓存策略实现
 */
public class LruCacheStrategy<K, V> implements CacheStrategy<K, V> {
    private final LinkedHashMap<K, V> cache;
    private final int maxSize;
    
    public LruCacheStrategy(int maxSize) {
        this.maxSize = maxSize;
        this.cache = new LinkedHashMap<K, V>(maxSize, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
                return size() > maxSize;
            }
        };
    }
    
    // 实现接口方法...
}

/**
 * TTL 缓存策略实现（带过期时间）
 */
public class TtlCacheStrategy<K, V> implements CacheStrategy<K, V> {
    private final ConcurrentHashMap<K, CacheEntry<V>> cache;
    private final long ttlMillis;
    
    private static class CacheEntry<V> {
        final V value;
        final long expireTime;
        
        CacheEntry(V value, long ttlMillis) {
            this.value = value;
            this.expireTime = System.currentTimeMillis() + ttlMillis;
        }
        
        boolean isExpired() {
            return System.currentTimeMillis() > expireTime;
        }
    }
    
    // 实现接口方法...
}

扩展配置：

java

// 配置 LRU 缓存
LinsirReflection.setCacheStrategy(new LruCacheStrategy<>(1000));

// 配置 TTL 缓存（5分钟过期）
LinsirReflection.setCacheStrategy(new TtlCacheStrategy<>(300000));

4.2.2 异常处理扩展

扩展目标：支持自定义异常处理策略

java

/**
 * 异常处理器接口
 */
public interface ExceptionHandler {
    
    /**
     * 处理方法调用异常
     * 
     * @param method 方法
     * @param target 目标对象
     * @param args 参数
     * @param exception 异常
     * @return 是否已处理
     */
    boolean handleMethodInvocationException(Method method, Object target, 
            Object[] args, Exception exception);
    
    /**
     * 处理字段访问异常
     * 
     * @param field 字段
     * @param target 目标对象
     * @param value 值（设置时）
     * @param exception 异常
     * @return 是否已处理
     */
    boolean handleFieldAccessException(Field field, Object target, 
            Object value, Exception exception);
}

/**
 * 日志记录异常处理器
 */
public class LoggingExceptionHandler implements ExceptionHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(LoggingExceptionHandler.class);
    
    @Override
    public boolean handleMethodInvocationException(Method method, Object target, 
            Object[] args, Exception exception) {
        logger.error("方法调用失败: {}.{}, 参数: {}", 
            target.getClass().getName(), method.getName(), args, exception);
        return false; // 未处理，继续抛出
    }
    
    @Override
    public boolean handleFieldAccessException(Field field, Object target, 
            Object value, Exception exception) {
        logger.error("字段访问失败: {}.{}, 值: {}", 
            target.getClass().getName(), field.getName(), value, exception);
        return false;
    }
}

/**
 * 默认值异常处理器
 */
public class DefaultValueExceptionHandler implements ExceptionHandler {
    
    private final Map<Class<?>, Object> defaultValues = new HashMap<>();
    
    public DefaultValueExceptionHandler() {
        defaultValues.put(int.class, 0);
        defaultValues.put(long.class, 0L);
        defaultValues.put(boolean.class, false);
        defaultValues.put(String.class, "");
        // ... 其他默认值
    }
    
    @Override
    public boolean handleMethodInvocationException(Method method, Object target, 
            Object[] args, Exception exception) {
        Class<?> returnType = method.getReturnType();
        if (defaultValues.containsKey(returnType)) {
            // 返回默认值，标记为已处理
            return true;
        }
        return false;
    }
    
    @Override
    public boolean handleFieldAccessException(Field field, Object target, 
            Object value, Exception exception) {
        return false;
    }
}

4.2.3 安全控制扩展

扩展目标：控制反射访问的权限

java

/**
 * 反射安全管理器
 */
public interface ReflectionSecurityManager {
    
    /**
     * 检查是否允许访问方法
     * 
     * @param method 方法
     * @param caller 调用者类
     * @return 是否允许
     */
    boolean canInvoke(Method method, Class<?> caller);
    
    /**
     * 检查是否允许访问字段
     * 
     * @param field 字段
     * @param caller 调用者类
     * @param forWrite 是否为写入操作
     * @return 是否允许
     */
    boolean canAccess(Field field, Class<?> caller, boolean forWrite);
    
    /**
     * 检查是否允许设置可访问性
     * 
     * @param object 可访问对象
     * @param caller 调用者类
     * @return 是否允许
     */
    boolean canMakeAccessible(AccessibleObject object, Class<?> caller);
}

/**
 * 包级安全控制实现
 */
public class PackageSecurityManager implements ReflectionSecurityManager {
    
    private final Set<String> allowedPackages = new HashSet<>();
    private final Set<String> forbiddenPackages = new HashSet<>();
    
    public PackageSecurityManager() {
        // 默认禁止访问系统包
        forbiddenPackages.add("java.lang.reflect");
        forbiddenPackages.add("sun.reflect");
    }
    
    @Override
    public boolean canInvoke(Method method, Class<?> caller) {
        String packageName = method.getDeclaringClass().getPackage().getName();
        return !forbiddenPackages.contains(packageName) && 
               (allowedPackages.isEmpty() || allowedPackages.contains(packageName));
    }
    
    @Override
    public boolean canAccess(Field field, Class<?> caller, boolean forWrite) {
        // 禁止访问 final 字段的写入
        if (forWrite && Modifier.isFinal(field.getModifiers())) {
            return false;
        }
        String packageName = field.getDeclaringClass().getPackage().getName();
        return !forbiddenPackages.contains(packageName);
    }
    
    @Override
    public boolean canMakeAccessible(AccessibleObject object, Class<?> caller) {
        // 只允许访问同一包或公开 API
        return true;
    }
    
    public void allowPackage(String packageName) {
        allowedPackages.add(packageName);
    }
    
    public void forbidPackage(String packageName) {
        forbiddenPackages.add(packageName);
    }
}

4.2.4 方法匹配扩展

扩展目标：支持复杂的方法匹配规则

java

/**
 * 方法匹配器接口
 */
public interface MethodMatcher {
    
    /**
     * 匹配方法
     * 
     * @param method 方法
     * @return 是否匹配
     */
    boolean matches(Method method);
    
    /**
     * 是否匹配运行时参数
     * 
     * @param method 方法
     * @param args 参数
     * @return 是否匹配
     */
    default boolean matches(Method method, Object[] args) {
        return matches(method);
    }
}

/**
 * 注解方法匹配器
 */
public class AnnotationMethodMatcher implements MethodMatcher {
    
    private final Class<? extends Annotation> annotationType;
    
    public AnnotationMethodMatcher(Class<? extends Annotation> annotationType) {
        this.annotationType = annotationType;
    }
    
    @Override
    public boolean matches(Method method) {
        return method.isAnnotationPresent(annotationType);
    }
}

/**
 * 名称模式方法匹配器
 */
public class NamePatternMethodMatcher implements MethodMatcher {
    
    private final Pattern pattern;
    
    public NamePatternMethodMatcher(String regex) {
        this.pattern = Pattern.compile(regex);
    }
    
    @Override
    public boolean matches(Method method) {
        return pattern.matcher(method.getName()).matches();
    }
}

/**
 * 组合方法匹配器（支持 AND/OR）
 */
public class CompositeMethodMatcher implements MethodMatcher {
    
    private final List<MethodMatcher> matchers;
    private final boolean matchAll; // true = AND, false = OR
    
    public CompositeMethodMatcher(boolean matchAll, MethodMatcher... matchers) {
        this.matchAll = matchAll;
        this.matchers = Arrays.asList(matchers);
    }
    
    @Override
    public boolean matches(Method method) {
        if (matchAll) {
            return matchers.stream().allMatch(m -> m.matches(method));
        } else {
            return matchers.stream().anyMatch(m -> m.matches(method));
        }
    }
    
    public static MethodMatcher and(MethodMatcher... matchers) {
        return new CompositeMethodMatcher(true, matchers);
    }
    
    public static MethodMatcher or(MethodMatcher... matchers) {
        return new CompositeMethodMatcher(false, matchers);
    }
}

4.2.5 字段转换扩展

扩展目标：支持字段值的类型转换

java

/**
 * 字段转换器接口
 */
public interface FieldConverter {
    
    /**
     * 是否支持该类型的转换
     * 
     * @param sourceType 源类型
     * @param targetType 目标类型
     * @return 是否支持
     */
    boolean supports(Class<?> sourceType, Class<?> targetType);
    
    /**
     * 转换值
     * 
     * @param source 源值
     * @param targetType 目标类型
     * @return 转换后的值
     */
    Object convert(Object source, Class<?> targetType);
}

/**
 * 基础类型转换器
 */
public class PrimitiveFieldConverter implements FieldConverter {
    
    @Override
    public boolean supports(Class<?> sourceType, Class<?> targetType) {
        // 支持基本类型和包装类型之间的转换
        if (sourceType == targetType) return true;
        if (sourceType.isPrimitive() || targetType.isPrimitive()) {
            return isWrapperType(sourceType, targetType) || 
                   isWrapperType(targetType, sourceType);
        }
        return false;
    }
    
    private boolean isWrapperType(Class<?> type, Class<?> primitiveType) {
        if (!primitiveType.isPrimitive()) return false;
        if (primitiveType == int.class) return type == Integer.class;
        if (primitiveType == long.class) return type == Long.class;
        if (primitiveType == boolean.class) return type == Boolean.class;
        // ... 其他类型
        return false;
    }
    
    @Override
    public Object convert(Object source, Class<?> targetType) {
        if (source == null) return getDefaultValue(targetType);
        // 类型转换逻辑...
        return source;
    }
    
    private Object getDefaultValue(Class<?> type) {
        if (type == int.class || type == Integer.class) return 0;
        if (type == long.class || type == Long.class) return 0L;
        if (type == boolean.class || type == Boolean.class) return false;
        return null;
    }
}

/**
 * 字符串转换器
 */
public class StringFieldConverter implements FieldConverter {
    
    private final Map<Class<?>, Function<String, Object>> converters = new HashMap<>();
    
    public StringFieldConverter() {
        converters.put(int.class, Integer::parseInt);
        converters.put(Integer.class, Integer::parseInt);
        converters.put(long.class, Long::parseLong);
        converters.put(Long.class, Long::parseLong);
        converters.put(double.class, Double::parseDouble);
        converters.put(Double.class, Double::parseDouble);
        converters.put(boolean.class, Boolean::parseBoolean);
        converters.put(Boolean.class, Boolean::parseBoolean);
    }
    
    @Override
    public boolean supports(Class<?> sourceType, Class<?> targetType) {
        return sourceType == String.class && converters.containsKey(targetType);
    }
    
    @Override
    public Object convert(Object source, Class<?> targetType) {
        Function<String, Object> converter = converters.get(targetType);
        return converter != null ? converter.apply((String) source) : source;
    }
}

4.2.6 代理创建扩展

扩展目标：支持创建动态代理对象

java

/**
 * 代理工厂接口
 */
public interface ProxyFactory {
    
    /**
     * 创建代理对象
     * 
     * @param target 目标对象
     * @param interceptor 方法拦截器
     * @return 代理对象
     */
    Object createProxy(Object target, MethodInterceptor interceptor);
    
    /**
     * 创建接口代理
     * 
     * @param interfaces 接口数组
     * @param handler 调用处理器
     * @return 代理对象
     */
    Object createInterfaceProxy(Class<?>[] interfaces, InvocationHandler handler);
}

/**
 * 方法拦截器接口
 */
public interface MethodInterceptor {
    
    /**
     * 拦截方法调用
     * 
     * @param invocation 方法调用信息
     * @return 返回值
     * @throws Throwable 异常
     */
    Object invoke(MethodInvocation invocation) throws Throwable;
}

/**
 * 方法调用信息
 */
public interface MethodInvocation {
    
    Method getMethod();
    
    Object[] getArguments();
    
    Object getTarget();
    
    Object proceed() throws Throwable;
}

/**
 * JDK 动态代理工厂实现
 */
public class JdkProxyFactory implements ProxyFactory {
    
    @Override
    public Object createProxy(Object target, MethodInterceptor interceptor) {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (proxy, method, args) -> interceptor.invoke(
                new DefaultMethodInvocation(target, method, args))
        );
    }
    
    @Override
    public Object createInterfaceProxy(Class<?>[] interfaces, InvocationHandler handler) {
        return Proxy.newProxyInstance(
            Thread.currentThread().getContextClassLoader(),
            interfaces,
            handler
        );
    }
}

4.3 扩展配置示例

java

// 配置缓存策略
LinsirReflection.setCacheStrategy(new LruCacheStrategy<>(1000));

// 配置异常处理器
LinsirReflection.addExceptionHandler(new LoggingExceptionHandler());
LinsirReflection.addExceptionHandler(new DefaultValueExceptionHandler());

// 配置安全管理器
PackageSecurityManager securityManager = new PackageSecurityManager();
securityManager.forbidPackage("java.lang.reflect");
LinsirReflection.setSecurityManager(securityManager);

// 配置字段转换器
LinsirReflection.addFieldConverter(new PrimitiveFieldConverter());
LinsirReflection.addFieldConverter(new StringFieldConverter());

// 配置代理工厂
LinsirReflection.setProxyFactory(new JdkProxyFactory());

4.4 扩展点应用场景

扩展点	应用场景	实现复杂度
缓存策略	高并发系统、内存敏感场景	中
异常处理	日志记录、降级处理	低
安全控制	多租户系统、沙箱环境	高
方法匹配	AOP 切面、注解处理	中
字段转换	配置绑定、数据映射	中
代理创建	事务管理、权限控制	高

类型系统

反射工具 - ReflectionUtils

概述

核心能力矩阵

1. 代码结构分析

1.1 核心类结构

1.2 源码模块划分

1.3 设计特点

2. 主要使用场景

2.1 场景矩阵

2.2 场景详细分析

场景1：依赖注入（@Autowired 处理）

场景2：属性复制（BeanUtils.copyProperties）

场景3：动态代理方法调用

场景4：测试私有方法

3. 围绕主要场景的封装设计

3.1 封装设计目标

3.2 封装架构设计

3.3 封装 API 设计

3.3.1 门面类设计

3.3.2 回调接口设计

3.3.3 异常体系设计

3.3.4 缓存设计

3.4 使用示例

示例1：依赖注入场景

示例2：属性复制场景

示例3：获取对象所有字段值

4. 扩展该模块分析

4.1 扩展点识别

4.2 扩展点详细设计

4.2.1 缓存策略扩展

4.2.2 异常处理扩展

4.2.3 安全控制扩展

4.2.4 方法匹配扩展

4.2.5 字段转换扩展

4.2.6 代理创建扩展

4.3 扩展配置示例

4.4 扩展点应用场景

相关链接

反射工具 - ReflectionUtils ​

概述 ​

核心能力矩阵 ​

1. 代码结构分析 ​

1.1 核心类结构 ​

1.2 源码模块划分 ​

1.3 设计特点 ​

2. 主要使用场景 ​

2.1 场景矩阵 ​

2.2 场景详细分析 ​

场景1：依赖注入（@Autowired 处理） ​

场景2：属性复制（BeanUtils.copyProperties） ​

场景3：动态代理方法调用 ​

场景4：测试私有方法 ​

3. 围绕主要场景的封装设计 ​

3.1 封装设计目标 ​

3.2 封装架构设计 ​

3.3 封装 API 设计 ​

3.3.1 门面类设计 ​

3.3.2 回调接口设计 ​

3.3.3 异常体系设计 ​

3.3.4 缓存设计 ​

3.4 使用示例 ​

示例1：依赖注入场景 ​

示例2：属性复制场景 ​

示例3：获取对象所有字段值 ​

4. 扩展该模块分析 ​

4.1 扩展点识别 ​

4.2 扩展点详细设计 ​

4.2.1 缓存策略扩展 ​

4.2.2 异常处理扩展 ​

4.2.3 安全控制扩展 ​

4.2.4 方法匹配扩展 ​

4.2.5 字段转换扩展 ​

4.2.6 代理创建扩展 ​

4.3 扩展配置示例 ​

4.4 扩展点应用场景 ​

相关链接 ​

反射工具 - ReflectionUtils

概述

核心能力矩阵

1. 代码结构分析

1.1 核心类结构

1.2 源码模块划分

1.3 设计特点

2. 主要使用场景

2.1 场景矩阵

2.2 场景详细分析

场景1：依赖注入（@Autowired 处理）

场景2：属性复制（BeanUtils.copyProperties）

场景3：动态代理方法调用

场景4：测试私有方法

3. 围绕主要场景的封装设计

3.1 封装设计目标

3.2 封装架构设计

3.3 封装 API 设计

3.3.1 门面类设计

3.3.2 回调接口设计

3.3.3 异常体系设计

3.3.4 缓存设计

3.4 使用示例

示例1：依赖注入场景

示例2：属性复制场景

示例3：获取对象所有字段值

4. 扩展该模块分析

4.1 扩展点识别

4.2 扩展点详细设计

4.2.1 缓存策略扩展

4.2.2 异常处理扩展

4.2.3 安全控制扩展

4.2.4 方法匹配扩展

4.2.5 字段转换扩展

4.2.6 代理创建扩展

4.3 扩展配置示例

4.4 扩展点应用场景

相关链接