反射的性能代价：Method.invoke比直接调用慢多少倍

适读人群：Java中高级开发者、对框架底层有兴趣的后端工程师 | 阅读时长：约14分钟 | 文章类型：性能测试+原理分析

---

开篇故事

有一次code review，看到一个同事在一个每秒调用万次的热点方法里用了反射调用：

// 配置驱动的数据处理器，每个字段都用反射调用setter
for (FieldConfig config : fieldConfigs) {
    Method setter = targetClass.getMethod("set" + capitalize(config.getFieldName()),
        config.getFieldType());
    setter.invoke(target, value);
}

我问他为什么这里用反射，他说："框架需要灵活配置，反射是最方便的实现方式。"

这没错，但问题是这段代码在每次请求里都会执行，而且每次都在重新getMethod，没有缓存Method对象。

我让他压测了一下，qps上来之后，这里的反射调用占了CPU时间的30%。

换成预先缓存Method对象，性能提升了6倍。再换成MethodHandle（JDK 7+），性能又提升了一倍多。如果换成代码生成（ASM/Byte Buddy），基本就和直接调用一样了。

今天从头到尾把反射的性能代价说清楚，以及在什么情况下应该怎么优化。

---

一、反射调用为什么慢

反射调用的执行路径

直接调用一个方法，JVM可以做很多优化：

• 方法内联（JIT把被调用方法的代码直接嵌入调用处）
• 逃逸分析（判断对象是否可以在栈上分配）
• 常量折叠等

而Method.invoke的调用链是：

Method.invoke()
  → Method的安全检查（访问权限验证）
  → MethodAccessor.invoke()
  → DelegatingMethodAccessor（或NativeMethodAccessor / GeneratedMethodAccessor）
    → 经过Object[]包装参数
    → JNI Native调用（或字节码生成的直接调用）

主要开销来自：

1. 安全检查：Method.invoke默认每次都检查调用者是否有权限访问该方法
2. 装箱/拆箱：参数必须包装成Object[]，基本类型需要装箱
3. 不可内联：JIT无法直接内联反射调用的目标方法
4. JNI开销：如果用Native实现，有JNI边界开销

getMethod vs 缓存Method

除了invoke本身，getMethod()也很慢：

• 需要遍历类的方法列表
• 需要做安全检查
• 涉及字符串比较和类型匹配

所以"每次getMethod + invoke"的代价远大于"缓存Method + invoke"。

---

二、核心原理深挖

MethodAccessor的演进

Method.invoke内部有一个MethodAccessor，负责实际的调用。JVM默认行为：

1. 前N次（默认15次）：使用NativeMethodAccessor（JNI调用，有Native边界开销）
2. 第N+1次开始：JVM动态生成GeneratedMethodAccessor（字节码调用，更快）

这个行为由sun.reflect.inflationThreshold控制，默认15。

所以如果你的反射调用次数少于15次，你看到的性能更差，因为都是Native调用。

JDK 9+的MethodHandles

MethodHandle（JDK 7引入，java.lang.invoke包）是一种更底层的方法引用，它可以被JIT更好地优化，甚至可以内联：

MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodHandle mh = lookup.findVirtual(String.class, "length", MethodType.methodType(int.class));
int len = (int) mh.invoke("hello"); // 5

各方式的性能层级

---

三、完整代码实现

代码一：JMH基准测试（不同反射方式性能对比）

package com.laozhang.reflect.performance;

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;

/**
 * 反射性能基准测试
 * 使用JMH框架（实际运行需要添加JMH依赖）
 *
 * 典型结果（JDK 17，MacBook M1 Pro）：
 * 直接调用:              ~1.5 ns/op
 * MethodHandle:          ~2.0 ns/op  (1.3x slower)
 * 缓存Method+setAccessible: ~8 ns/op  (5x slower)
 * 缓存Method（默认）:     ~35 ns/op  (23x slower)
 * 每次getMethod:          ~2000 ns/op (1300x slower)
 */
// @BenchmarkMode(Mode.AverageTime)
// @OutputTimeUnit(TimeUnit.NANOSECONDS)
// @State(Scope.Benchmark)
// @Fork(1) @Warmup(iterations = 3) @Measurement(iterations = 5)
public class ReflectPerformanceBenchmark {

    private static final String TEST_STR = "hello world";

    // 预先缓存Method对象
    private static Method lengthMethod;
    private static Method lengthMethodAccessible; // setAccessible(true)
    private static MethodHandle lengthMethodHandle;

    static {
        try {
            // 初始化Method
            lengthMethod = String.class.getMethod("length");

            lengthMethodAccessible = String.class.getMethod("length");
            lengthMethodAccessible.setAccessible(true); // 跳过访问检查

            // 初始化MethodHandle
            MethodHandles.Lookup lookup = MethodHandles.lookup();
            lengthMethodHandle = lookup.findVirtual(String.class, "length",
                MethodType.methodType(int.class));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 方式1：直接调用（基准）
     */
    // @Benchmark
    public int directCall() {
        return TEST_STR.length();
    }

    /**
     * 方式2：缓存Method + setAccessible(true) + invoke
     */
    // @Benchmark
    public int cachedMethodAccessible() throws Exception {
        return (int) lengthMethodAccessible.invoke(TEST_STR);
    }

    /**
     * 方式3：缓存Method（默认，每次检查权限）
     */
    // @Benchmark
    public int cachedMethod() throws Exception {
        return (int) lengthMethod.invoke(TEST_STR);
    }

    /**
     * 方式4：MethodHandle
     */
    // @Benchmark
    public int methodHandle() throws Throwable {
        return (int) lengthMethodHandle.invoke(TEST_STR);
    }

    /**
     * 方式5：每次getMethod（最慢）
     */
    // @Benchmark
    public int everyTimeGetMethod() throws Exception {
        Method m = String.class.getMethod("length");
        return (int) m.invoke(TEST_STR);
    }

    /**
     * 手动性能测试（不依赖JMH）
     * 可以直接运行这个main方法做快速验证
     */
    public static void main(String[] args) throws Exception {
        ReflectPerformanceBenchmark bench = new ReflectPerformanceBenchmark();
        final int WARMUP = 100_000;
        final int ITERATIONS = 1_000_000;

        // 预热
        for (int i = 0; i < WARMUP; i++) {
            bench.directCall();
            bench.cachedMethodAccessible();
            bench.cachedMethod();
            bench.methodHandle();
        }

        System.out.println("=== 反射性能对比（" + ITERATIONS + "次调用）===");

        long start;

        // 1. 直接调用
        start = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) bench.directCall();
        long directTime = System.nanoTime() - start;
        System.out.printf("直接调用:             %,d ns (%.1f ns/op)%n",
            directTime, (double) directTime / ITERATIONS);

        // 2. MethodHandle
        start = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) bench.methodHandle();
        long mhTime = System.nanoTime() - start;
        System.out.printf("MethodHandle:         %,d ns (%.1f ns/op, %.1fx slower)%n",
            mhTime, (double) mhTime / ITERATIONS, (double) mhTime / directTime);

        // 3. 缓存Method + accessible
        start = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) bench.cachedMethodAccessible();
        long cmaTime = System.nanoTime() - start;
        System.out.printf("缓存Method+accessible:%,d ns (%.1f ns/op, %.1fx slower)%n",
            cmaTime, (double) cmaTime / ITERATIONS, (double) cmaTime / directTime);

        // 4. 缓存Method（默认）
        start = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) bench.cachedMethod();
        long cmTime = System.nanoTime() - start;
        System.out.printf("缓存Method(默认):      %,d ns (%.1f ns/op, %.1fx slower)%n",
            cmTime, (double) cmTime / ITERATIONS, (double) cmTime / directTime);

        // 5. 每次getMethod（只测10000次，因为太慢了）
        final int SMALL_N = 10_000;
        start = System.nanoTime();
        for (int i = 0; i < SMALL_N; i++) bench.everyTimeGetMethod();
        long egmTime = System.nanoTime() - start;
        System.out.printf("每次getMethod:        %,d ns (%.1f ns/op, %.1fx slower, 10000次)%n",
            egmTime, (double) egmTime / SMALL_N, ((double) egmTime / SMALL_N) / ((double) directTime / ITERATIONS));
    }
}

代码二：生产环境中反射的正确使用模式

package com.laozhang.reflect.performance;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 生产环境中反射的高性能使用模式
 *
 * 核心原则：
 * 1. 缓存Method/Field对象，不要每次getMethod/getField
 * 2. 调用setAccessible(true)跳过权限检查
 * 3. 高频热点路径考虑MethodHandle或代码生成
 */
public class ReflectBestPractice {

    /**
     * 方式1：手动缓存Method对象（Map<String, Method>）
     * 适合：调用次数多，method种类少
     */
    public static class MethodCache {
        // ConcurrentHashMap保证线程安全的缓存
        private static final ConcurrentHashMap<String, Method> CACHE = new ConcurrentHashMap<>();

        /**
         * 获取缓存的Method（首次缓存，后续从缓存取）
         */
        public static Method getMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) {
            String key = clazz.getName() + "#" + methodName;
            return CACHE.computeIfAbsent(key, k -> {
                try {
                    Method m = clazz.getMethod(methodName, paramTypes);
                    m.setAccessible(true); // 关键：跳过访问检查
                    return m;
                } catch (NoSuchMethodException e) {
                    throw new RuntimeException("方法不存在: " + k, e);
                }
            });
        }

        /**
         * 使用缓存的Method调用
         */
        public static Object invoke(Object target, String methodName,
                                    Class<?>[] paramTypes, Object... args) throws Exception {
            Method m = getMethod(target.getClass(), methodName, paramTypes);
            return m.invoke(target, args);
        }
    }

    /**
     * 方式2：基于字段的Bean属性复制（反射实现）
     * 类似BeanUtils.copyProperties，但有缓存优化
     */
    public static class BeanCopier {
        // 缓存类的所有字段
        private static final ConcurrentHashMap<Class<?>, Map<String, Field>> FIELD_CACHE
            = new ConcurrentHashMap<>();

        private static Map<String, Field> getFieldMap(Class<?> clazz) {
            return FIELD_CACHE.computeIfAbsent(clazz, c -> {
                Map<String, Field> map = new HashMap<>();
                Class<?> current = c;
                while (current != null && current != Object.class) {
                    for (Field f : current.getDeclaredFields()) {
                        f.setAccessible(true);
                        map.putIfAbsent(f.getName(), f); // 子类字段优先
                    }
                    current = current.getSuperclass();
                }
                return map;
            });
        }

        /**
         * 按字段名复制属性（忽略类型不匹配的字段）
         */
        public static void copy(Object source, Object target) throws IllegalAccessException {
            Map<String, Field> sourceFields = getFieldMap(source.getClass());
            Map<String, Field> targetFields = getFieldMap(target.getClass());

            for (Map.Entry<String, Field> entry : targetFields.entrySet()) {
                String fieldName = entry.getKey();
                Field targetField = entry.getValue();
                Field sourceField = sourceFields.get(fieldName);

                if (sourceField != null &&
                    targetField.getType().isAssignableFrom(sourceField.getType())) {
                    Object value = sourceField.get(source);
                    targetField.set(target, value);
                }
            }
        }
    }

    // 测试用的Bean
    static class UserDTO {
        private String name;
        private int age;
        private String email;

        UserDTO() {}
        UserDTO(String name, int age, String email) {
            this.name = name; this.age = age; this.email = email;
        }
        // getters/setters
        public String getName() { return name; }
        public int getAge() { return age; }
        public String toString() { return "UserDTO{name='" + name + "', age=" + age + "}"; }
    }

    static class UserEntity {
        private String name;
        private int age;
        private String email;
        private String extraField = "extra";
        public String toString() { return "UserEntity{name='" + name + "', age=" + age + "}"; }
    }

    public static void main(String[] args) throws Exception {
        System.out.println("=== Method缓存测试 ===");
        String str = "Hello World";

        // 首次调用（缓存Miss，会创建缓存）
        Object result1 = MethodCache.invoke(str, "length", new Class[0]);
        System.out.println("length(): " + result1);

        // 第二次调用（缓存Hit）
        Object result2 = MethodCache.invoke(str, "length", new Class[0]);
        System.out.println("length(): " + result2);

        System.out.println("\n=== BeanCopier测试 ===");
        UserDTO dto = new UserDTO("张三", 28, "zhang@example.com");
        UserEntity entity = new UserEntity();
        BeanCopier.copy(dto, entity);
        System.out.println("复制结果: " + entity);

        System.out.println("\n=== 性能对比（各缓存效果）===");
        final int N = 100_000;
        long start;

        // 不缓存
        start = System.nanoTime();
        for (int i = 0; i < N; i++) {
            Method m = String.class.getMethod("length");
            m.invoke(str);
        }
        System.out.printf("每次getMethod: %.2fms%n",
            (System.nanoTime() - start) / 1_000_000.0);

        // 使用缓存
        start = System.nanoTime();
        for (int i = 0; i < N; i++) {
            MethodCache.invoke(str, "length", new Class[0]);
        }
        System.out.printf("缓存Method:    %.2fms%n",
            (System.nanoTime() - start) / 1_000_000.0);
    }
}

---

四、踩坑实录

坑1：热点路径里每次getMethod，性能崩溃

报错现象：

没有Exception，但接口响应时间在高负载下显著变慢，火焰图显示大量时间花在getMethod和相关的类反射操作上。

根本原因：

// 每次请求都执行这段代码
Method setter = targetClass.getMethod("setXxx", String.class);
setter.invoke(target, value);

getMethod涉及字符串匹配、方法列表遍历、安全检查，比invoke还慢。

具体解法：

// 应用启动时，把所有需要的Method缓存起来
private static final Map<String, Method> METHOD_CACHE = new ConcurrentHashMap<>();

static {
    Method m = TargetClass.class.getMethod("setXxx", String.class);
    m.setAccessible(true);
    METHOD_CACHE.put("setXxx", m);
}

// 运行时直接从缓存取
Method setter = METHOD_CACHE.get("setXxx");
setter.invoke(target, value);

坑2：没有setAccessible导致安全检查开销

报错现象：

换成缓存Method之后，性能比预期还是慢很多，火焰图显示checkAccess仍然占用大量CPU。

根本原因：

// 没有setAccessible，每次invoke都要执行权限检查
Method m = SomeClass.class.getMethod("someMethod");
// 缺少：m.setAccessible(true);
m.invoke(target, args); // 每次invoke都有checkAccess开销

具体解法：

Method m = SomeClass.class.getMethod("someMethod");
m.setAccessible(true); // 关键：关闭访问检查，只需设置一次
m.invoke(target, args); // 后续调用不再有checkAccess开销

注意：在Java 16+的强封装模块下，setAccessible对某些模块的私有成员可能会被拒绝，需要--add-opensJVM参数。

坑3：反射调用基本类型参数，装箱拆箱开销

报错现象：

反射调用一个接受int参数的方法，性能比预期差，因为Object[]传参导致int被装箱为Integer。

根本原因：

Method.invoke的参数是Object[]，基本类型int需要装箱成Integer才能放进数组。如果这个方法被频繁调用，装箱拆箱本身就有不小的开销。

具体解法：

// 方案1：用MethodHandle，可以直接传基本类型
MethodHandle mh = MethodHandles.lookup()
    .findVirtual(SomeClass.class, "setCount", MethodType.methodType(void.class, int.class));
mh.invoke(target, 42); // int直接传，不装箱

// 方案2：使用invokeExact（更快，但参数类型必须完全匹配）
mh.invokeExact(target, 42); // 最快，类型不匹配会抛WrongMethodTypeException

---

五、总结与延伸

反射的性能优化，有一个简单的决策树：

不在热点路径？ → 直接用反射，可读性优先，不用优化

在热点路径，但每秒调用次数 < 万次？ → 缓存Method + setAccessible，基本够用

每秒调用次数 > 万次，需要进一步优化？ → 考虑MethodHandle

极致性能要求（每秒百万次以上）？ → 代码生成（Byte Buddy / ASM），运行时生成不含反射的字节码

实际上，Spring、MyBatis、Jackson等主流框架的底层都做了类似的优化：

• Spring用BeanWrapper缓存反射信息
• Jackson用ClassIntrospector缓存序列化/反序列化用的Method和Field
• MyBatis的BoundSql缓存了参数绑定相关的反射对象

理解了反射的性能特性，就能理解为什么这些框架都要费心做缓存，以及为什么说"不要在循环里重复反射"。