Java泛型进阶 - 如何取出泛型类型参数

迷南。 2022-04-23 14:54 180阅读 0赞

在JDK5引入了`泛型`特性之后，她迅速地成为Java编程中不可或缺的元素。然而，就跟泛型乍一看似乎非常容易一样，许多开发者也非常容易就迷失在这项特性里。  
多数Java开发者都会注意到`Java编译器`的`类型擦除`实现方式，`Type Erasure`会导致关于某个Class的所有泛型信息都会在源代码编译时消失掉。在一个Java应用中，可以认为所有的泛型实现类，都共享同一个基础类(注意与`继承`区分开来)。这是为了兼容JDK5之前的所有JDK版本，就是人们经常说的`向后兼容性`。

## 向后兼容性 ##

> 译者注：原文较为琐碎，大致意思是。在JVM整个内存空间中，只会存在一个 `ArrayList.class`。 
> 为了能够区分 `ArrayList<String>`和 `ArrayList<Integer>`，现在假想的实现方式是在 `Class文件信息表(函数表+字段表)`里添加额外的泛型信息。这个时候JVM的内存空间中就会存在 `(假设)ArrayList&String.class`和 `(假设)ArrayList&Integer.class`文件。顺着这种情况延续下去的话，就必须要修改JDK5之前所有版本的JVM对 `Class文件`的识别逻辑，因为它破坏了 `JVM内部一个Class只对应唯一一个.class`这条规则。这也是人们常说的: 破坏了 `向后兼容性`。
> 
> 注：参考Python3舍弃掉Python2的例子，也是放弃了对2的兼容，Python3才能发展并构造更多的新特性。

## 那应该怎么做？ ##

既然Java开发团队选择了兼容JDK5之前的版本，那就不能在`JVM`里做手脚了。但`Java编译器`的代码似乎还是可以修改的。于是，`Java编译器`在`编译时`就会把泛型信息都擦除，所以以下的比较在JVM`运行时`会永远为真。

assert new ArrayList<String>().getClass() == new ArrayList<Integer>().getClass();

对`JVM运行时`来说，上述代码等同于

assert new ArrayList.class == ArrayList.class

到目前为止，上述内容都是大家所熟知的事情。然而，与普遍印象相反的是，某些情况下在`运行时`获取到泛型类型信息也是可行的。举个栗子:

class MyGenericClass<T> { }
 class MyStringSubClass extends MyGenericClass<String> { }

`MyStringSubClass`相当于对`MyGenericClass<T>`做了类型参数赋值`T = String`。于是，`Java编译器`可以把这部分**泛型信息(父类MyGenericClass的泛型参数是String)**，存储在它的**子类MyStringSubClass**的字节码区域中。 
而且因为这部分泛型信息在被编译后，仅仅被存储在被老版JVM所忽略的字节码区域中，所以这种方式并没有破坏`向后兼容性`。与此同时，因为**T已经被赋值为String**，所有的MyStringSubClass类的对象实例仍然共享同一个`MyStringSubClass.class`。

## 如何获取这块泛型信息？ ##

应该如何获取到被存储在byte code区域的这块泛型信息呢？

1. Java API提供了`Class.getGenericSuperClass()`方法，来取出一个`Type类型的实例`。
2. **如果直接父类的实际类型就是泛型类型的话**，那取出的`Type类型实例`就可以被显示地转换为`ParameterizeType`。
 
 > (Type只是一个标记型接口，它里面仅包含一个方法： `getTypeName()`。所以取出的实例的实际类型会是 `ParameterizedTypeImpl`，但不应直接暴露实际类型，应一直暴露 `Type接口`)。
3. 感谢`ParameterizedType`接口，现在我们可以直接调用`ParameterizeType.getActualTypeArguments()`取出又一个`Type类型实例数组`。
4. 父类所有的泛型类型参数都会被包含在这个数组里，并且以被声明的顺序放在数组对应的下标中。
5. 当数组中的类型参数为非泛型类型时，我们就可以简单地把它显示转换为`Class<?>`。
 
 > 为了保持文章的简洁性，我们跳过了 `GenericArrayType`的情况。

![clipboard.png][]

现在我们可以使用以上知识编写一个工具类了:

public static Class<?> findSuperClassParameterType(Object instance, Class<?> clazzOfInterest, int parameterIndex) {
 Class<?> subClass = instance.getClass();
 while (subClass.getSuperclass() != clazzOfInterest) {
 subClass = subClass.getSuperclass();
 if (subClass == null) throw new IllegalArgumentException();
 }
 ParameterizedType pt = (ParameterizedType) (subClass.getGenericSuperclass());
 return (Class<?>) pt.getActualTypeArguments()[parameterIndex];
 }
 
 public static void testCase1() {
 Class<?> genericType = findDirectSuperClassParameterType(new MyStringSubClass());
 System.out.println(genericType);
 assert genericType == String.class;
 }

然而，请注意到

findSuperClassParamerterType(new MyGenericClass<String>(), MyGenericClass.class, 0)

这样调用会抛出`IllegalArgumentException`异常。之前说过：`泛型信息`只有在子类的帮助下才能被取出。然而，`MyGenericClass<String>`只是一个拥有泛型参数的类，并不是`MyGenericClass.class`的子类。**没有显式的子类，就没有地方存储`String类型参数`**。因此上述调用不可避免地会被`Java编译器`进行`类型擦除`。如果你已预见到你的项目中会出现这种情况，也想要避免它，一种良好的编程实践是将`MyGenericClass`声明为`abstract`。

然而，我们还没有解决问题，毕竟我们目前为止还有许多坑没有填。

## 链式泛型 ##

class MyGenericClass<T> {}
 class MyGenericSubClass extends MyGenericClass {}
 class MyStringSubSubClass extends MyGenericSubClass<String> {}

如下调用，仍然会抛出异常。

findSuperClassParameterType(new MyStringSubClass(), MyGenericClass.class, 0);

![clipboard.png][clipboard.png 1]

这又是为什么呢？到目前为止我们都在设想：`MyGenericClass`的类型参数`T`的相关信息会存储在它的`直接子类`中。那么上述的类继承关系就有以下逻辑：

1. `MyStringSubClass.class`中存储了`MyGenericSubClass --> U = String`。
2. `MyGenericSubClass.class`中仅存储了`MyGenericClass<T> --> T = U`

但`U`并不是一个`Class类型`，而是`TypeVariable类型`的类型变量，如果我们想要解析这种继承关系，就必须解析它们之间所有的依赖关系。代码如下：

public static Class<?> findSubClassParameterType(Object instance, Class<?> classOfInterest, int parameterIndex) {
 Map<Type, Type> typeMap = new HashMap<>();
 Class<?> instanceClass = instance.getClass();
 while (instanceClass.getSuperclass() != classOfInterest) {
 extractTypeArguments(typeMap, instanceClass);
 instanceClass = instanceClass.getSuperclass();
 if (instanceClass == null) throw new IllegalArgumentException();
 }
 // System.out.println(typeMap);
 ParameterizedType pt = (ParameterizedType) instanceClass.getGenericSuperclass();
 Type actualType = pt.getActualTypeArguments()[parameterIndex];
 if (typeMap.containsKey(actualType)) {
 actualType = typeMap.get(actualType);
 }
 if (actualType instanceof Class) {
 return (Class<?>) actualType;
 } else {
 throw new IllegalArgumentException();
 }
 }
 
 private static void extractTypeArguments(Map<Type, Type> typeMap, Class<?> clazz) {
 Type genericSuperclass = clazz.getGenericSuperclass();
 if (!(genericSuperclass instanceof ParameterizedType)) {
 return ;
 }
 ParameterizedType pt = (ParameterizedType) genericSuperclass;
 Type[] typeParameters = ((Class<?>) pt.getRawType()).getTypeParameters();
 Type[] actualTypeArguments = pt.getActualTypeArguments();
 for (int i = 0; i < typeParameters.length; i++) {
 if (typeMap.containsKey(actualTypeArguments[i])) {
 actualTypeArguments[i] = typeMap.get(actualTypeArguments[i]);
 }
 typeMap.put(typeParameters[i], actualTypeArguments[i]);
 }
 }

代码中通过一个map可以解析所有`链式泛型类型`的定义。不过仍然不够完美，毕竟`MyClass<A, B> extends MyOtherClass<B, A>`也是一种完全合法的子类定义。

## 嵌套类 ##

好了好了，仍然没有结束：

class MyGenericOuterClass {
 public class MyGenericInnerClass { }
 }
 class MyStringOuterSubClass extends MyGenericOuterClass<String> { }
 
 MyStringOuterSubClass.MyGenericInnerClass inner = new MyStringOuterSubClass().new MyGenericInnerClass();

下面这样调用仍然会失败。

findSuperClassParameterType(inner, MyGenericInnerClass.class, 0);

这种失败几乎是可预见的，我们正试图在`MyGenericInnerClass的对象实例`里面寻找`MyGenericInnerClass`的泛型信息。就像之前所说，因为`MyGenericInnerClass`并没有子类，所以从`MyGenericInnerClass.class`中寻找泛型信息是不可能的，毕竟`MyGenericInnerClass.class`里面根本就不存在`泛型信息`。不过在这个例子中，我们检查的是`MyStringOuterSubClass`中的`非static内部类: MyGenericInnerClass`的对象实例。那么，`MyStringOuterSubClass`是知道`它的父类MyGennericOuterClass --> U = String`。当使用反射取出`MyGenericInnerClass`中的类型参数时，就必须把这点纳入考量。

现在这件事就变得相当棘手了。  
\-> 为了取出`MyGenericOuterClass`的泛型信息  
\-> 就必须先得到`MyGenericOuterClass.class`

这依然可以通过反射取得，`Java编译器`会在内部类`MyGenericInnerClass`中生成一个`synthetic-field: this$0`，这个字段可以通过`Class.getDeclaredField("this$0")`获取到。

> javap -p -v MyGenericOuterClass$MyGenericInnerClass.class
    ...
    ...
      final cn.local.test.MyGenericOuterClass this$0;
        descriptor: Lcn/local/test/MyGenericOuterClass;
        flags: ACC_FINAL, ACC_SYNTHETIC
    ...

既然已经有办法可以获取到`MyGenericOuterClass.class`了，那接下来我们似乎可以直接复用之前的扫描逻辑了。

> 这里需要注意, `MyGenericOuterClass的U 并不等同于 <MyGenericInnerClass的U`。 
> 我们可以做以下推理， `MyGenericInnerClass`是可以声明为 `static`的，这就意味着 `static`情况下， `MyGenericInnerClass`拥有它自己独享的 `泛型type命名空间`。所以，Java API中所有的 `TypeVariable接口实现类`，都拥有一个属性叫 `genericDeclaration`。 
> ![clipboard.png][clipboard.png 2] 
> ![clipboard.png][clipboard.png 3] 
> 如果两个 `泛型变量`被分别定义在不同的类中，那么这两个 `TypeVariable类型`变量，从 `genericDeclaration`的定义上来说就是不相等的。

获取嵌套类的泛型的代码如下：

private static Class<?> browseNestedTypes(Object instance, TypeVariable<?> actualType) {
 Class<?> instanceClass = instance.getClass();
 List<Class<?>> nestedOuterTypes = new LinkedList<Class<?>>();
 for (
 Class<?> enclosingClass = instanceClass.getEnclosingClass();
 enclosingClass != null;
 enclosingClass = enclosingClass.getEnclosingClass() ) {
 
 try {
 Field this$0 = instanceClass.getDeclaredField("this$0");
 Object outerInstance = this$0.get(instance);
 Class<?> outerClass = outerInstance.getClass();
 nestedOuterTypes.add(outerClass);
 Map<Type, Type> outerTypeMap = new HashMap<>();
 extractTypeArguments(outerTypeMap, outerClass);
 for (Map.Entry<Type, Type> entry : outerTypeMap.entrySet()) {
 if (!(entry.getKey() instanceof TypeVariable)) {
 continue;
 }
 TypeVariable<?> foundType = (TypeVariable<?>) entry.getKey();
 if (foundType.getName().equals(actualType.getName())
 && isInnerClass(foundType.getGenericDeclaration(), actualType.getGenericDeclaration())) {
 if (entry.getValue() instanceof Class) {
 return (Class<?>) entry.getValue();
 }
 actualType = (TypeVariable<?>) entry.getValue();
 }
 }
 } catch (NoSuchFieldException e) {
 /* however, this should never happen. */
 } catch (IllegalAccessException e) {
 /* this might happen */
 }
 }
 throw new IllegalArgumentException();
 }
 
 private static boolean isInnerClass(GenericDeclaration outerDeclaration, GenericDeclaration innerDeclaration) {
 if (!(outerDeclaration instanceof Class) || !(innerDeclaration instanceof Class)) {
 throw new IllegalArgumentException();
 }
 Class<?> outerClass = (Class<?>) outerDeclaration;
 Class<?> innerClass = (Class<?>) innerDeclaration;
 while ((innerClass = innerClass.getEnclosingClass()) != null) {
 if (innerClass == outerClass) {
 return true;
 }
 }
 return false;
 }
 
 private static void extractTypeArguments(Map<Type, Type> typeMap, Class<?> clazz) {
 Type genericSuperclass = clazz.getGenericSuperclass();
 if (!(genericSuperclass instanceof ParameterizedType)) {
 return;
 }
 ParameterizedType pt = (ParameterizedType) genericSuperclass;
 Type[] typeParameters = ((Class<?>) pt.getRawType()).getTypeParameters();
 Type[] actualTypeArguments = pt.getActualTypeArguments();
 for (int i = 0; i < typeParameters.length; i++) {
 if (typeMap.containsKey(actualTypeArguments[i])) {
 actualTypeArguments[i] = typeMap.get(actualTypeArguments[i]);
 }
 typeMap.put(typeParameters[i], actualTypeArguments[i]);
 }
 }

[clipboard.png]: /images/20220307/fe5f7e5da8244845970d22c0f12b7cd8.png
[clipboard.png 1]: /images/20220307/aa25a3fd123047df9bfceccf5664df47.png
[clipboard.png 2]: /images/20220307/75aadb47a95549168c419b4fd02d6758.png
[clipboard.png 3]: /images/20220307/77e5b3e594c34d2aaa7d4d3a7664c627.png