动态类型检查匹配类型参数

Question

我希望实现一个具有以下签名的方法：

<T> void function(Class<T> clazz, Consumer<T> consumer)

这个函数接受Object obj（在别处提供），使用clazz.cast(obj) 将其转换为T，然后用它调用consumer。 （基本上就是consumer的守卫。）

这工作或多或少都很好，我可以写

Consumer<String> c = ...;
function(String.class, c);

很遗憾，以下代码不起作用：

Consumer<List<String>> c = ...;
function(List.class, c);

这是因为 List.class 的类型为 Class<List>，而不是类 Class<List<String>>。 我可以将c 的类型更改为Consumer<List>，但这与我在其他地方的代码不兼容（而且原始类型也不好）。

是否有某种方法可以 (a) 以类型检查的方式调用 function，或 (b) 以使该模式起作用的方式更改 function 的类型签名？

注意事项：

• 我希望尽可能多地保留编译和运行时类型的安全性。因此，function(Class<?> clazz, Consumer<T> consumer) 是不可接受的，因为用户很容易提供错误的clazz。并且调用为function((Class<List<String>>)List.class, c) 也是不可接受的，因为我可能会不小心将其转换为function((Class<Integer>)List.class, c) 和 这个错误的演员阵容甚至不会在运行时被发现。如果有一个函数允许将Class<C<T>> 转换为Class<C<U>> 但不能转换为Class<D>，那会很酷，但如果没有高阶类型，我看不到这一点。

• 我知道类型转换将无法在运行时检查我们有 List<String> 而不是 List<Integer>。没关系。 （嗯，不是，但我认为这是最好的 我们可以期待 JVM 语言。）

• 尽管如此，我更喜欢使function 的调用变得简单（可能使function 更复杂）的解决方案，因为function 在我的库中定义并由该库的用户使用。

• 出于好奇，我遇到此问题的实际代码是here，Instance 是function。

Answer 1

我认为不可能达到您所期望的类型安全程度。

让我们区分编译时间和运行时间。

编译时间

编译时，编译器会检查clazz的类型是否匹配consumer的类型参数T。但这不适用于本身具有泛型类型参数的类型 T，例如List<String>，因为 Java 中没有 List<String>.class 语法。所以，在这里你能做的最好的就是将List.class 转换为Class<List<String>>。

在您的function 中操作的对象obj 在方法的签名中不可见，因此在编译时没有机会检查其类型是否与consumer 匹配。

没有什么能阻止您调用function(String.class, stringConsumer) 并拥有Integer 对象。编译器不可能检测到这个错误。

运行时间

在运行时，没有泛型信息。该概念称为“类型擦除”。所以，在编译时显示为List<String>，在运行时只是List。

在编译时，obj 在 function 调用中不可见，您将类型检查移至运行时，使用 Class.cast() 方法。

如果在编译时您的obj 是List<String>、List<Integer> 或List<Whatever>，则在运行时它只是一个没有参数的原始List，并且您要检查的类也是只是原始的List.class，没有任何类型参数。 cast() 方法将接受所有这些不同的列表。

因此，在运行时，无法拒绝 List<Integer> 进入期望 List<String> 的消费者。稍后当消费者访问列表元素时，您可能会收到ClassCastException。

总结

如果你想防止参数化类型的不匹配，你只能在编译时这样做，并且为了实现这一点，你必须将对象和使用者置于相同的语法上下文中，这可能意味着一个大的重构。

在运行时，您只能防止原始类型不匹配。如果你想这样做，它会迫使你在参数化类型的情况下使用一些丑陋的语法（将类对象转换为参数化类类型），以满足编译器的要求。

就我个人而言，我会放弃守卫的想法。

• 它在编译时没有帮助（它只检查您是否能够将匹配 consumer 的 clazz 传递给 function，而不是实际对象是否匹配）。

• 它可以在运行时检查一些错误情况。但在像List<String> 这样的情况下，它仍然无法保护您免于稍后收到消费者抛出的ClassCastException。没有你的保护也会发生这种情况，只是在更多的情况下。

Answer 2

仅使用Class<T> 参数是不可能做你想做的事的。你需要一个super type token。

如链接文章中所述，您可以通过以下方式实现此类功能：

public abstract class TypeToken<T> {
 
    private final Type type;
 
    public TypeToken() {
        Type superclass = getClass().getGenericSuperclass();
        type = ((ParameterizedType) superclass).getActualTypeArguments()[0];
    }
 
    public Type getType() {
        return type;
    }
}

在 Java 中，您无法获取有关实例的泛型类型变量的信息，但是您可以获取有关超类型的泛型类型变量的一些信息。请注意，TypeToken 类是抽象的。这就是您应该在示例中使用它的方式：

<T> void function(TypeToken<T> token, Consumer<T> consumer)

Consumer<List<String>> c = ...;

function(new TypeToken<List<String>>() { }, c);

这意味着您将TypeToken 的子类传递给您的函数。

最后，在function 中，您可以提取Class 实例并按如下方式强制转换对象：

Class<T> clazz;
if (type instanceof ParameterizedType)
  clazz = (Class<T>) ((ParameterizedType) type).getRawType();
else if (typeU instanceof Class)
  clazz = (Class<T>) type;
else
  throw new RuntimeException("Error handling omitted");
T t = clazz.cast(obj);