Java反射动态调用不同参数个数方法报参数数量异常如何解决

问题根因 #

抛出IllegalArgumentException: wrong number of arguments的核心原因有两点：

• 方法匹配逻辑存在缺陷：现有代码仅通过方法名定位目标方法，没有校验方法的参数个数、参数类型是否和传入的参数列表匹配，遍历过程中很可能先拿到同名但参数列表不匹配的重载方法，调用时自然会报参数数量错误。
• 对Method.invoke的传参逻辑存在误解：invoke方法的签名为public Object invoke(Object obj, Object... args)，本身就支持传入任意数量的参数。当传入Object[]类型的参数集合时，Java会自动将数组中的每个元素作为独立参数传给目标方法，这个逻辑本身是成立的，前提是定位到的Method对象和传入参数完全匹配。

正确实现代码 #

定位方法时必须同时校验方法名、参数个数、参数类型的兼容性，匹配到正确方法后直接传入参数数组即可完成调用，不需要手动展开参数：

import java.lang.reflect.Method;

public class ReflectCaller {

    public static void foo(Object obj, String objectiveMethod, Object... params) throws Exception {
        Class<?> objClass = obj.getClass();
        for (Method method : objClass.getDeclaredMethods()) {
            // 1. 匹配方法名
            if (!objectiveMethod.equals(method.getName())) {
                continue;
            }
            Class<?>[] paramTypes = method.getParameterTypes();
            // 2. 匹配参数个数
            if (paramTypes.length != params.length) {
                continue;
            }
            // 3. 逐个匹配参数类型兼容性（支持自动拆装箱、子类赋值）
            boolean isMatch = true;
            for (int i = 0; i < paramTypes.length; i++) {
                Object param = params[i];
                Class<?> expectedType = paramTypes[i];
                // 处理null值：基本类型不能接收null，引用类型可以
                if (param == null) {
                    if (expectedType.isPrimitive()) {
                        isMatch = false;
                        break;
                    }
                    continue;
                }
                Class<?> actualType = param.getClass();
                // 处理基本类型自动拆装箱匹配
                if (expectedType.isPrimitive()) {
                    Class<?> wrapperType = primitiveToWrapper(expectedType);
                    if (!wrapperType.isAssignableFrom(actualType)) {
                        isMatch = false;
                        break;
                    }
                } else {
                    if (!expectedType.isAssignableFrom(actualType)) {
                        isMatch = false;
                        break;
                    }
                }
            }
            if (!isMatch) {
                continue;
            }
            // 跳过访问权限检查（可选，用于调用私有方法）
            method.setAccessible(true);
            // 直接传入参数数组即可，可变参数会自动展开为对应个数的实参
            method.invoke(obj, params);
            // 若仅需要调用第一个匹配的方法，找到后直接退出循环
            break;
        }
    }

    // 基本类型转对应包装类的辅助方法
    private static Class<?> primitiveToWrapper(Class<?> primitiveType) {
        if (primitiveType == int.class) return Integer.class;
        if (primitiveType == boolean.class) return Boolean.class;
        if (primitiveType == long.class) return Long.class;
        if (primitiveType == double.class) return Double.class;
        if (primitiveType == float.class) return Float.class;
        if (primitiveType == short.class) return Short.class;
        if (primitiveType == byte.class) return Byte.class;
        if (primitiveType == char.class) return Character.class;
        return primitiveType;
    }

    // 测试用例
    public static void main(String[] args) throws Exception {
        // 调用2个参数的方法
        Object[] argsForA = {"arg1", "arg2"};
        foo(new A(), "method_A", argsForA);
        // 调用1个参数的方法
        Object[] argsForB = {"arg1"};
        foo(new B(), "method_B", argsForB);
        // 调用3个参数的方法
        Object[] argsForC = {"arg1", 2, new B()};
        foo(new C(), "method_C", argsForC);
    }
}

// 测试类定义
class A {
    public void method_A(String arg1, String arg2) {
        System.out.println("A.method_A called: " + arg1 + ", " + arg2);
    }
}
class B {
    public void method_B(String arg1) {
        System.out.println("B.method_B called: " + arg1);
    }
}
class C {
    public void method_C(String arg1, int arg2, B arg3) {
        System.out.println("C.method_C called: " + arg1 + ", " + arg2 + ", " + arg3);
    }
}

补充场景说明 #

你提到的method.invoke(aObj, args[0], args[1])运行正常、method.invoke(aObj, args)报错的情况，本质是当时拿到的method对象不是对应2个参数的目标方法：

• 只要定位到参数个数、类型完全匹配的Method对象，传入长度一致的Object[]参数和逐个传参的效果完全一致，都会正常执行。
• 对于3个参数的methodC，只要匹配到参数列表对应的Method对象，直接传入长度为3的Object[]参数即可正常调用，不需要手动展开参数。

特殊场景注意 #

如果目标方法本身是可变参数方法（例如public void method_D(String... args)），调用时需要将可变参数部分封装为单个数组元素传入，避免数组被invoke的可变参数逻辑自动展开，示例：

// 假设目标方法是method_D(String... args)，要传入2个字符串参数
Method methodD = obj.getClass().getDeclaredMethod("method_D", String[].class);
// 正确写法：把参数数组包装成外层Object数组的第一个元素
methodD.invoke(obj, new Object[]{new String[]{"a", "b"}});

内容的提问来源于stack exchange，提问作者Eduardo Arias