Java 反射铸造方法 ReturnType

Question

为了提供一些背景知识，我正在创建一个小型依赖注入器并遇到将方法调用转换回其返回类型的问题。 一个最小的例子是：

public class MinimalExample {
    public static <T> void invokeMethod(Class<T> aClass) throws ReflectiveOperationException {
        Optional<Method> myOptMethod = resolveMethod(aClass);
        if (myOptMethod.isPresent()) {
            Method myMethod = myOptMethod.get();
            Object myInstance = myMethod.invoke(myMethod);
            doSomething(myMethod.getReturnType(), myMethod.getReturnType().cast(myInstance));
        }
    }

    private static <T> Optional<Method> resolveMethod(Class<T> aClass) {
        return Stream.of(aClass.getMethods())
                .filter(aMethod -> Modifier.isStatic(aMethod.getModifiers()))
                .filter(aMethod -> aMethod.getParameterCount() == 0)
                .findAny();
    }

    private static <U> void doSomething(Class<U> aClass, U anInstance) {
        // E.g. Map aClass to anInstance.
    }
}

这里的问题是doSomething需要用Class<U>, U调用，但它目前是用Class<capture of?>, capture of?调用的。 由于invoke方法的通配符返回类型。

我可以将doSomething更改为doSomething(Class<?> aClass, Object anInstance)但是我失去了类型安全性，这不一定是调用该方法的唯一地方。

我的问题是：考虑到显式转换，为什么编译器不能推断出它们具有相同的底层类型U ？

---

编辑（2021 年 3 月 9 日）：

我冒昧地对字节码进行了反编译，以了解为什么rzwitserloot 的辅助方法确实解决了类型问题。 由于类型擦除，它们似乎是相同的调用。 我猜编译器不够聪明，无法在强制转换后推断它们是相同的捕获类型，需要类型绑定来提供帮助。

我添加了以下功能

private static <U> void doSomethingWithTypeBinding(Class<U> aClass, Object anObject) {
    doSomething(aClass, aClass.cast(anObject));
}

private static void doSomethingUnsafe(Class<?> aClass, Object anInstance) {}

我现在分别从第 15 行和第 16 行调用

doSomethingWithTypeBinding(myMethod.getReturnType(), myInstance);
doSomethingUnsafe(myMethod.getReturnType(), myMethod.getReturnType().cast(myInstance));

产生以下字节码：

L5
    LINENUMBER 15 L5
    ALOAD 2
    INVOKEVIRTUAL java/lang/reflect/Method.getReturnType ()Ljava/lang/Class;
    ALOAD 3
    INVOKESTATIC depinjection/handspun/services/MinimalExample.doSomethingWithTypeBinding (Ljava/lang/Class;Ljava/lang/Object;)V
L6
    LINENUMBER 16 L6
    ALOAD 2
    INVOKEVIRTUAL java/lang/reflect/Method.getReturnType ()Ljava/lang/Class;
    ALOAD 2
    INVOKEVIRTUAL java/lang/reflect/Method.getReturnType ()Ljava/lang/Class;
    ALOAD 3
    INVOKEVIRTUAL java/lang/Class.cast (Ljava/lang/Object;)Ljava/lang/Object;
    INVOKESTATIC depinjection/handspun/services/MinimalExample.doSomethingUnsafe (Ljava/lang/Class;Ljava/lang/Object;)V

// access flags 0xA
// signature <U:Ljava/lang/Object;>(Ljava/lang/Class<TU;>;TU;)V
// declaration: void doSomething<U>(java.lang.Class<U>, U)
private static doSomething(Ljava/lang/Class;Ljava/lang/Object;)V
    L0
        LINENUMBER 30 L0
        RETURN
    L1
        LOCALVARIABLE aClass Ljava/lang/Class; L0 L1 0
        // signature Ljava/lang/Class<TU;>;
        // declaration: aClass extends java.lang.Class<U>
        LOCALVARIABLE anInstance Ljava/lang/Object; L0 L1 1
        // signature TU;
        // declaration: anInstance extends U
        MAXSTACK = 0
        MAXLOCALS = 2

// access flags 0xA
// signature <U:Ljava/lang/Object;>(Ljava/lang/Class<TU;>;Ljava/lang/Object;)V
// declaration: void doSomethingWithTypeBinding<U>(java.lang.Class<U>, java.lang.Object)
private static doSomethingWithTypeBinding(Ljava/lang/Class;Ljava/lang/Object;)V
    L0
        LINENUMBER 33 L0
        ALOAD 0
        ALOAD 0
        ALOAD 1
        INVOKEVIRTUAL java/lang/Class.cast (Ljava/lang/Object;)Ljava/lang/Object;
        INVOKESTATIC depinjection/handspun/services/MinimalExample.doSomething (Ljava/lang/Class;Ljava/lang/Object;)V
    L1
        LINENUMBER 34 L1
        RETURN
    L2
        LOCALVARIABLE aClass Ljava/lang/Class; L0 L2 0
        // signature Ljava/lang/Class<TU;>;
        // declaration: aClass extends java.lang.Class<U>
        LOCALVARIABLE anObject Ljava/lang/Object; L0 L2 1
        MAXSTACK = 3
        MAXLOCALS = 2

// access flags 0xA
// signature (Ljava/lang/Class<*>;Ljava/lang/Object;)V
// declaration: void doSomethingUnsafe(java.lang.Class<?>, java.lang.Object)
private static doSomethingUnsafe(Ljava/lang/Class;Ljava/lang/Object;)V
    L0
        LINENUMBER 37 L0
        RETURN
    L1
        LOCALVARIABLE aClass Ljava/lang/Class; L0 L1 0
        // signature Ljava/lang/Class<*>;
        // declaration: aClass extends java.lang.Class<?>
        LOCALVARIABLE anInstance Ljava/lang/Object; L0 L1 1
        MAXSTACK = 0
        MAXLOCALS = 2

由于运行时类型擦除，我们可以看到INVOKEVIRTUAL直接转换为INVOKESTATIC看起来相同。

---

编辑（2021 年 3 月 12 日）：

@Holger 在评论中指出， Method#getReturnType返回一个Class<?> 。 因为它是通配符，所以从编译器的角度来看，该方法不能保证后续方法调用返回具有相同捕获类型的 Class。

Answer 1

类型变量是编译器想象的虚构：它们无法在编译后存活（擦除*）。 最好将它们视为连接事物。 永远只在一个地方使用的类型变量是完全没用的； 一旦它们出现在两个地方，现在这很有用：它可以让您将类型的多种用法联系在一起，表示出现是相同的。 例如，对于 java.util.List ，您可以将.add(Obj thingToAdd)的参数类型和.get(int idx)的返回类型java.util.List在一起。

在这里，您希望将myMethod.getReturnType的Class<X>与myInstance变量链接在一起。 正如您所意识到的，这是不可能的，因为编译器不知道它们最终会成为同一类型。 但是，通过调用Class<X>的cast()方法，我们可以解决这部分问题。

但是您仍然需要一些类型变量作为将事物联系在一起的工具，而您没有。 ? 类似于一次性使用型变量； Class<?> cls和 myMethod.getReturnType().cast(myInstance)` 是“不同的”？s：是的，你的眼球可以看出它将是相同的类型，但 java 不能。 你需要一个类型变量。 你当然可以介绍一个：

private static <X> helper(Class<X> x, Object myInstance) {
    doSomething(x, x.cast(myInstance));
}

将此方法添加到您的代码中并调用此方法，而不是调用doSomething 。 我们在此处创建的<X>用于将结果联系在一起。

*) 当然，它们保留在公共签名中，但在其他任何地方，在运行时 - 它们都会被删除。

您可以在此处使用另一种选择： doSomething方法是private ，因此您可以完全控制它。 因此，您可以只将演员表移动到其中，这可以解决所有问题，或者您可以这样编写：

/** precondition: o must be an instance of c */
private static void doSomething(Class<?> c, Object o) {
}

由于它是一种私有方法，因此可以引入先决条件。 您可以完全控制调用此方法的所有代码。 如果你真的想要，你可以添加一个运行时检查（ if (.c;isInstanceof(o)) throw new IllegalArgumentException("o not instance of c");在顶部），但是否值得做的是一个 open在 java 生态系统中讨论私有方法。 通常的判断是不这样做，或者使用assert关键字。

注意：这有一些残酷的空/可选处理。 万一没有找到要解决的方法..只是默默地什么都不做？ 这就是 NPE 更好的原因：至少粗心的编码会导致异常，而不是徒劳无功。

Answer 2

首先调用是：

Object myInstance = myMethod.invoke(null);

myMethod是static （正如您已经在resolveMethod中找到的那样），因此您需要传递一个null ，否则您将需要一个实例，而您没有该实例。

然后修复你的例子，是相当微不足道的：

Method myMethod = myOptMethod.get();
Object myInstance = myMethod.invoke(null);

Class<?> cls = myMethod.getReturnType();
Object obj = myMethod.getReturnType().cast(myInstance);

doSomething(cls, obj);

该方法将定义更改为：

 private static <U> void doSomething(Class<? extends U> aClass, U anInstance) {....}