开发者

Java中反射的20个使用技巧分享

开发者 https://www.devze.com 2025-05-18 10:29 出处：网络 作者： 风象南
目录基础最佳实践1. 缓存反射对象2. 区分getMethods()和getDeclaredMethods()3. 正确处理InvocationTargetException4. 合理使用setAccessible(true)5. 使用泛型增强类型安全性能优化技巧6. 避免反射热点路径7. 考虑使
相关专题：Java反射Java反射技巧
目录
  • 基础最佳实践
    • 1. 缓存反射对象
    • 2. 区分getMethods()和getDeclaredMethods()
    • 3. 正确处理InvocationTargetException
    • 4. 合理使用setAccessible(true)
    • 5. 使用泛型增强类型安全
  • 性能优化技巧
    • 6. 避免反射热点路径
    • 7. 考虑使用MethodHandle而非反射
    • 8. 利用LambdaMetafactory创建高效函数接口
    • 9. 使用第三方库优化反射
    • 10. 谨慎传递大型数组或复杂对象
  • 安全性考虑
    • 11. 避免通过反射修改final字段
    • 12. 访问控制检查
    • 13. 注意JDK版本差异
    • 14. 处理动态代理的安全问题
    • 15. 避免反射调用序列化/反序列化方法
  • 高级技巧与实践
    • 16. 结合注解实现声明式编程
    • 17. 获取泛型信息
    • 18. 实现插件系统和SPI机制
    • 19. 避免反射创建原生类型数组
    • 20. 使用反射模拟依赖注入
  • 总结

    Java反射是一种强大的机制，允许程序在运行时检查和操作类、接口、字段和方法。

    尽管它提供了极大的灵活性，但反射也是一把双刃剑——使用不当会导致性能下降、安全漏洞和难以调试的代码。

    本文总结了20个关于Java反射的经验。

    基础最佳实践

    1. 缓存反射对象

    反射操作获取Class、Method、Field、Constructor等对象是昂贵的，应当尽可能缓存这些对象，特别是在循环或热点代码路径中。

    // 不推荐: 每次调用都获取方法对象
public Object invoke(Object obj, String methodName, Object... args) throws Exception {
    Method method = obj.getClass().getDeclaredMethod(methodName, getParameterTypes(args));
    return method.invoke(obj, args);
}

// 推荐: 使用缓存
private static final ConcurrentHashMap<Class<?>, Map<String, Method>> METHOD_CACHE = new ConcurrentHashMap<>();

public Object invoke(Object obj, String methodName, Object... args) throws Exception {
    Class<?> clazz = obj.getClass();
    Map<String, Method> methods = METHOD_CACHE.computeIfAbsent(clazz, 
        k -> Arrays.stream(k.getDeclaredMethods())
                   .collect(Collectors.toMap(Method::getName, m -> m, (m1, m2) -> m1)));
    Method method = methods.get(methodName);
    return method.invoke(obj, args);
}

    2. 区分getMethods()和getDeclaredMethods()

    • getMethods() 返回所有公共方法，包括继承的方法
    • getDeclaredMethods() 返回所有方法（包括私有、保护、默认和公共），但不包括继承的方法
    // 获取所有公共方法（包括从父类继承的）
Method[] publicMethods = MyClass.class.getMethods();

// 获取所有声明的方法（包括私有方法，但不包括继承方法）
Method[] declaredMethods = MyClass.class.getDeclaredMethods();

    选择正确的方法可以提高性能并避免意外访问不应访问的方法。

    3. 正确处理InvocationTarpythongetException

    使用反射调用方法时，原始异常会被包装在InvocationTargetException中，应当提取并处理原始异常。

    try {
    method.invoke(obj, args);
} catch (InvocationTargetException e) {
    // 获取并处理目标方法抛出的实际异常
    Throwable targetException = e.getTargetException();
    log.error("Method {} threw an exception: {}", method.getName(), targetException.getMessage());
    throw targetException; // 或者适当处理
} catch (IllegalAccessException e) {
    // 处理访问权限问题
    log.error("Access denied to method {}: {}", method.getName(), e.getMessage());
}

    4. 合理使用setAccessible(true)

    使用setAccessible(true)可以绕过访问检js查，访问私有成员，但应谨慎使用。

    Field privateField = MyClass.class.getDeclaredField("privateField");
privateField.setAccessible(true); // 允许访问私有字段
privateField.set(instance, newValue);

    在生产环境中，应当考虑这种操作的必要性和安全影响。

    5. 使用泛型增强类型安全

    泛型可以减少类型转换，使反射代码更安全。

    // 类型不安全的反射
Object result = method.invoke(obj, args);
String strResult = (String) result; // 可能的ClassCastException

// 使用泛型增强类型安全
public <T> T invokeMethod(Object obj, Method method, Object... args) throws Exception {
    @SuppressWarnings("unchecked")
    T result = (T) method.invoke(obj, args);
    return result;
}

    性能优化技巧

    6. 避免反射热点路径

    在性能关键的代码路径上避免使用反射。如果必须使用，考虑以下替代方案：

    • 使用工厂模式或依赖注入
    • 预先生成访问器代码
    • 使用接口而非反射
    // 不推荐: 频繁调用的代码中使用反射
for (int i = 0; i < 1000000; i++) {
    method.invoke(obj, i);
}

// 推荐: 将反射封装到工厂中，一次性创建调用器
interface Processor {
    void process(int i);
}

Processor processor = createProcessor(obj, method);
for (int i = 0; i < 1000000; i++) {
    processor.process(i);
}

    7. 考虑使用MethodHandle而非反射

    Java 7引入的MethodHandle通常比传统反射更高效，特别是在重复调用同一方法时。

    // 使用MethodHandle
MethodType methodType = MethodType.methodType(String.class, int.class);
MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodHandle handle = lookup.findVirtual(String.class, "substring", methodType);

// 调用方法（性能更好的热点路径）
String result = (String) handle.invoke("Hello World", 6);

    8. 利用LambdaMetafactory创建高效函数接口

    对于简单的getter和setter方法，可以使用LambdaMetafactory创建函数接口，性能接近直接调用。

    public static <T, R> Function<T, R> createGetter(Class<T> clazz, String propertyName) throws Exception {
    Method method = clazz.getDeclaredMethod("get" + capitalize(propertyName));
    MethodHandles.Lookup lookup = MethodHandles.lookup();
    CallSite site = LambdaMetafactory.metafactory(
            lookup,
            "apply",
            MethodType.methodType(Function.class),
            MethodType.methodType(Object.class, Object.class),
            lookup.unreflect(method),
            MethodType.methodType(method.getReturnType(), clazz));
    return (Function<T, R>) site.getTarget().invokeExact();
}

// 使用生成的函数
Function<Person, String> nameGetter = createGetter(Person.class, "name");
String name = nameGetter.apply(person); // 性能接近直接调用person.getName()

    9. 使用第三方库优化反射

    某些情况下，可以考虑使用专门针对反射优化的库：

    • ByteBuddy
    • ReflectASM
    • CGLib
    // 使用ByteBuddy优化反射调用
Getter<Person, String> nameGetter = MethodHandles.lookup()
    .in(Person.class)
    .getter(Person.class.getDeclaredField("name"))
    .bindTo(ByteBuddy.install(MethodHandles.lookup()));
    
String name = nameGetter.get(person);

    10. 谨慎传递大型数组或复杂对象

    当通过反射传递参数或返回值时，大型数组或复杂对象可能导致性能问题。考虑使用更简单的数据类型或流式处理。

    // 不推荐: 通过反射传递大数组
Object[] largeArray = new Object[10000];
method.invoke(obj, (Object) largeArray);

// 推荐: 使用更小的批次或流处理
Stream.of(largeArray)
      .collect(Collectors.groupingBy(i -> i % 100))
      .forEach((BATch, items) -> {
          try {
              method.invoke(obj, (Object) items.toArray());
          } catch (Exception e) {
              // 处理异常
          }
      });

    安全性考虑

    11. 避免通过反射修改final字段

    虽然技术上可行，但修改final字段可能导致线程安全问题和不可预测的行为。

    // 危险操作: 修改final字段
Field field = MyClass.class.getDeclaredField("CONSTANT");
field.setAccessible(true);
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
field.set(null, newValue); // 可能引起严重问题

    这种操作在Java 9后变得更加困难，并且在理论上可能导致JVM优化假设失效。

    12. 访问控制检查

    在框架或API中，要实施适当的访问控制检查，防止恶意使用反射。

    public void invokeMethod(Object target, String methodName, Object... args) {
    // 检查调用者是否有权限执行此操作
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        sm.checkPermission(new ReflectPermission("suppressAccessChecks"));
    }
    
    // 检查目标方法是否在允许调用的白名单中
    if (!ALLOWED_METHODS.contains(methodName)) {
        throw new SecuriandroidtyException("Method not in allowed list: " + methodName);
    }
    
    // 执行反射操作
    // ...
}

    13. 注意JDK版本差异

    不同JDK版本对反射的限制不同，Java 9以后的模块系统对反射访问增加了更多限制。

    // Java 9+ 访问非导出模块的类
try {
    // 尝试使用反射访问
    Class<?> clazz = Class.forName("jdk.internal.misc.Unsafe");
    // 这会抛出异常，除非使用--add-opens参数启动JVM
} catch (Exception e) {
    // 处理访问限制异常
}

    Java 11+中，推荐在启动参数中明确指定需要开放的模块：

    --add-opens java.base/jdk.internal.misc=ALL-UNNAMED

    14. 处理动态代理的安全问题

    使用反射和动态代理时，确保代理类不会被滥用。

    // 安全的代理创建
InvocationHandler handler = new MyInvocationHandler();
MyInterface proxy = (MyInterface) Proxy.newproxyInstance(
        MyInterface.class.getClassLoader(),
        new Class<?>[] { MyInterface.class },
        (pjsroxy, method, args) -> {
            // 检查是否允许调用此方法
            if (method.getDeclaringClass() == Object.class) {
                return method.invoke(handler, args); // 允许Object方法
            }
            
            if (!ALLOWED_METHODS.contains(method.getName())) {
                throw new SecurityException("Method not allowed: " + method.getName());
            }
            
            return method.invoke(target, args);
        });

    15. 避免反射调用序列化/反序列化方法

    不要使用反射调用readObject、writeObject等序列化方法，这可能导致严重安全漏洞。

    // 危险操作
Method readObject = targetClass.getDeclaredMethod("readObject", ObjectInputStream.class);
readObject.setAccessible(true);
readObject.invoke(instance, inputStream); // 可能导致反序列化漏洞

    应当使用Java标准序列化机制或安全的序列化库。

    高级技巧与实践

    16. 结合注解实现声明式编程

    反射和注解结合可以实现强大的声明式编程模型，类似Spring和JPA的实现方式。

    // 自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Transactional {
    boolean readOnly() default false;
}

// 使用反射处理注解
public void processClass(Class<?> clazz) {
    for (Method method : clazz.getDeclaredMethods()) {
        Transactional annotation = method.getAnnotation(Transactional.class);
        if (annotation != null) {
            boolean readOnly = annotation.readOnly();
            // 创建事务代理...
        }
    }
}

    17. 获取泛型信息

    尽管Java有类型擦除，但可以通过反射API获取泛型信息。

    public class GenericExample<T> {
    private List<String> stringList;
    private Map<Integer, T> genericMap;
    
    // 获取字段泛型类型
    public static void main(String[] args) throws Exception {
        Field stringListField = GenericExample.class.getDeclaredField("stringList");
        ParameterizedType stringListType = (ParameterizedType) stringListField.getGenericType();
        Class<?> stringListClass = (Class<?>) stringListType.getActualTypeArguments()[0];
        System.out.println(stringListClass); // 输出: class java.lang.String
        
        Field genericMapField = GenericExample.class.getDeclaredField("genericMap");
        ParameterizedType genericMapType = (ParameterizedType) genericMapField.getGenericType();
        Type keyType = genericMapType.getActualTypeArguments()[0]; // Integer
        Type valueType = geZjoeuGofccnericMapType.getActualTypeArguments()[1]; // T (TypeVariable)
        System.out.println(keyType + ", " + valueType);
    }
}

    18. 实现插件系统和SPI机制

    反射是实现插件系统和服务提供者接口(SPI)的关键技术。

    public class PluginLoader {
    public static List<Plugin> loadPlugins(String packageName) {
        List<Plugin> plugins = new ArrayList<>();
        
        // 扫描包中的类
        Reflections reflections = new Reflections(packageName);
        Set<Class<? extends Plugin>> pluginClasses = 
            reflections.getSubTypesOf(Plugin.class);
            
        // 实例化插件
        for (Class<? extends Plugin> pluginClass : pluginClasses) {
            try {
                // 查找@PluginInfo注解
                PluginInfo info = pluginClass.getAnnotation(PluginInfo.class);
                if (info != null && info.enabled()) {
                    // 使用反射创建插件实例
                    Plugin plugin = pluginClass.getDeclaredConstructor().newInstance();
                    plugins.add(plugin);
                }
            } catch (Exception e) {
                // 处理异常
            }
        }
        
        return plugins;
    }
}

    19. 避免反射创建原生类型数组

    创建原生类型数组需要特别注意，不能直接使用Array.newInstance()。

    // 错误: 尝试通过反射创建int[]
Object array = Array.newInstance(int.class, 10); // 正确
Object array = Array.newInstance(Integer.TYPE, 10); // 也正确

// 错误: 尝试通过反射设置值
Array.set(array, 0, 42); // 抛出IllegalArgumentException
// 正确方式
Array.setInt(array, 0, 42);

    20. 使用反射模拟依赖注入

    可以使用反射实现简单的依赖注入框架，类似Spring的核心功能。

    public class SimpleDI {
    private Map<Class<?>, Object> container = new HashMap<>();
    
    public void register(Class<?> type, Object instance) {
        container.put(type, instance);
    }
    
    public <T> T getInstance(Class<T> type) throws Exception {
        // 检查容器中是否已有实例
        if (container.containsKey(type)) {
            return type.cast(container.get(type));
        }
        
        // 创建新实例
        Constructor<T> constructor = type.getDeclaredConstructor();
        T instance = constructor.newInstance();
        
        // 注入字段
        for (Field field : type.getDeclaredFields()) {
            if (field.isAnnotationPresent(Inject.class)) {
                field.setAccessible(true);
                Class<?> fieldType = field.getType();
                Object dependency = getInstance(fieldType); // 递归解析依赖
                field.set(instance, dependency);
            }
        }
        
        container.put(type, instance);
        return instance;
    }
}

    总结

    在实际应用中，应当权衡反射带来的灵活性与潜在的性能、安全和可维护性问题。

    大多数情况下，如果有不使用反射的替代方案，应优先考虑。

    最后，优秀的框架设计应该尽量将反射细节封装起来，为最终用户提供清晰、类型安全的API，只在必要的内部实现中使用反射。

    以上就是Java中反射的20个使用技巧分享的详细内容，更多关于Java反射技巧的资料请关注编程客栈(www.devze.com)其它相关文章！

    0

    上一篇:

    :下一篇

    更多 开发 相关资讯：

    精彩评论

    暂无评论...
    登录 注册
    Qedev.com
    验证码 换一张
    取 消

    关注公众号

    热门标签

    图文推荐

    Java中的ClassLoader双亲委派机制详解

    Java中的ClassLoader双亲委派机制详解
    Java中@RequiredArgsConstructor使用详解

    Java中@RequiredArgsConstructor使用详解
    Java通过Mybatis操作Oracle的Clob和Blob的解决方式

    Java通过Mybatis操作Oracle的Clob和Blob的解决方式
    使用Python和OpenCV实现图片拼接的方法

    使用Python和OpenCV实现图片拼接的方法
    python完整卸载和重装其他版本的详细步骤

    python完整卸载和重装其他版本的详细步骤
    无法找到VS Code Python解释器的几种解决办法

    无法找到VS Code Python解释器的几种解决办法
    Python中的filter()函数的3种使用方式详解

    Python中的filter()函数的3种使用方式详解
    基于PyQt6实现智能视频分割器

    基于PyQt6实现智能视频分割器

    开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

    法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

    Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9