Java反射类型转换方法

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

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调用，但由于invoke方法的通配符返回类型，它目前正在用Class<capture of ?>, capture of ?调用。

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

我的问题是:为什么编译器不能推断出它们具有相同的底层类型U，给出显式强制转换?

编辑(2021年3月9日):

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

我添加了以下函数

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的运行时类型擦除，它们看起来完全相同。

Edit (12 Mar 2021):

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

类型变量是编译器想象的产物:它们不会在编译(擦除*)后存活。最好将它们看作是连接的。．只在一个地方使用的类型变量是完全无用的;一旦它们出现在两个地方，现在就有用了:它让您将类型的多个用法链接在一起，说明出现的次数是相同的。例如，对于java.util.List，可以将.add(Obj thingToAdd)的参数类型与.get(int idx)的返回类型绑定在一起。

在这里，您希望将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");在顶部)，但是否值得这样做是一个公开的争论在java生态系统的私有方法。通常结论是不这样做，或者使用assert关键字。

注意:这有一些可怕的空/可选处理。万一要解决的方法找不到你…什么都不做?这就是npe更好的原因:至少粗心的编码会导致异常，而不是徒劳无功。

首先调用是:

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) {....}

相关内容

最新更新

热门标签：