如何使用反射调用 java 中的泛型方法？

Question

正如标题所说，我正在尝试使用反射调用通用的 var-args 方法。

我尝试调用的方法是add ，它是SomeClass<T>的一部分。 具体实例是SomeClass<SomeInterface> ，因此add需要一个或多个SomeInterface对象。 由于 generics 是编译时的东西，我确实使用clazz.getMethod("add", Object[].class)获得了方法句柄，但我无法将参数正确传递给该方法句柄。

public class Example1 {

    public static void main(String[] args) throws Exception {
        SomeInterface si = new SomeInterface() {};
        Object obj = new SomeClass<SomeInterface>(){};
        
        // Knowing the type of obj
        ((SomeClass<SomeInterface>)obj).add(si);
        
        // Dont know the type of obj, but knowing the method name/signature
        Class<?> clazz = obj.getClass();
        Method method = clazz.getMethod("add", Object[].class);
        // concrete arguments fail
        try { method.invoke(obj, si); } catch (Exception ex) { System.err.println("failed2" + ex); }
        try { method.invoke(obj, new Object[]{si}); } catch (Exception ex) { System.err.println("failed3" + ex); }
        try { method.invoke(obj, new SomeInterface[]{si}); } catch (Exception ex) { System.err.println("failed4" + ex); }
        try { method.invoke(obj, (Object)si); } catch (Exception ex) { System.err.println("failed5" + ex); }
        // null works
        try { method.invoke(obj, (Object)null); } catch (Exception ex) { System.err.println("failed6" + ex); }
        try { method.invoke(obj, (SomeInterface)null); } catch (Exception ex) { System.err.println("failed7" + ex); }
    }
}

abstract class SomeClass<T> implements SomeInterface {
    public void add(T... args) { System.out.println("successful");}    
}

interface SomeInterface {    
}

Answer 1

问题不在于目标方法是通用的； 您已经正确识别了方法查找的擦除类型。 问题是该方法是可变参数方法。

您必须传递一个数组作为方法的第一个参数，但invoke方法也是一个可变参数方法。 为了向后兼容，将数组（引用类型）传递给可变参数方法被视为数组的所有元素都传递给了该方法。 （在较低的层次上，它是相反的；当参数已经是一个数组时，它不会被放入一个新数组中。）

换句话说，两者之间没有区别

method.invoke(obj, new Object[]{si});

和

method.invoke(obj, si);

当您将数组转换为Object时，它将按预期被视为第一个参数：

public class Example1 {
    public static void main(String[] args) throws Throwable {
        SomeInterface si = new SomeInterface() {};
        Object obj = new SomeClass<SomeInterface>(){};
        
        // Knowing the type of obj
        ((SomeClass<SomeInterface>)obj).add(si);

        // Dont know the type of obj, but knowing the method name/signature
        Class<?> clazz = obj.getClass();
        Method method = clazz.getMethod("add", Object[].class);

        method.invoke(obj, (Object)new Object[] { si });

        // correct varargs handling works out-of-the-box with java.lang.invoke

        MethodHandle mh = MethodHandles.lookup().findVirtual(clazz, "add",
                              MethodType.methodType(void.class, Object[].class));

        mh.invoke(obj, si);
    }
}

作为附录，我包含了一个java.lang.invoke package 的示例，它没有这个问题，因为MethodHandle的invoke方法不是可变参数方法而是签名多态，这意味着它接收传递的 arguments，没有任何拳击。 句柄还知道它引用了可变参数方法并将执行数组创建。