Question

当我阅读JavaFX源代码时，在com.sun.javafx.fxml.BeanAdapter中使用静态方法getGenericListItemType(Type)：

确定列表项的类型。

但是，通过简单的测试用例，我发现此实现可能存在缺陷：

abstract class A<T> implements List<String> {}

abstract class B extends A<Integer> {}

abstract class C<S, T> implements List<T> {}

abstract class D extends C<String, Integer> {}

// in a function scope
BeanAdapter.getGenericListItemType(B.class) // expects String, gets Integer
BeanAdapter.getGenericListItemType(A.class) // works correctly

BeanAdapter.getGenericListItemType(D.class) // expects Integer, gets String

事实证明，这种有缺陷的实现只能使用List<T> ← A<T> ← B<T> ← ... (parameterized) ... ← Y ← Z

模式处理理想条件

但是，当我尝试实现该功能时，我发现它相当复杂。我想知道是否有可能获得实型参数。如果可能，您能否提供一些提示或摘要？

Answer 1

是的，这是可能的。

您可以创建一个Map<TypeVariable<?>, Class<?>>并从给定的根类开始遍历类型图，以填写为每个类型变量提供的具体类型。例如：

public static Map<TypeVariable<?>, Class<?>> findTypeParameterValues(Class<?> cls) {
    Map<TypeVariable<?>, Class<?>> parameterMap = new HashMap<>();
    findTypeParameterValues(parameterMap, cls);     
    return parameterMap;
}

private static void findTypeParameterValues(Map<TypeVariable<?>, Class<?>> map, Class<?> cur) {
    // create list of parameterized super types
    List<ParameterizedType> pTypes = genericSuperTypes(cur)
        .filter(ParameterizedType.class::isInstance)
        .map(ParameterizedType.class::cast)
        .collect(Collectors.toList());

    for(ParameterizedType pType : pTypes) {     
        Type[] tArgs = pType.getActualTypeArguments(); // provided type arguments
        Class<?> rawType = (Class<?>) pType.getRawType(); // (always a Class<?>)
        TypeVariable<?>[] tParams = rawType.getTypeParameters(); // type parameters

        for(int i = 0; i < tArgs.length; i++) { // iterate over both
            Type tArg = tArgs[i]; // match type argument...
            TypeVariable<?> tParam = tParams[i]; // with type parameter
            Class<?> arg; // the value for the parameter
            if(tArg instanceof Class<?>) {
                 // concrete argument
                arg = (Class<?>) tArg;
            } else if(tArg instanceof TypeVariable<?>) {
                 // concrete argument provided previously, or null
                arg = map.get((TypeVariable<?>) tArg);
            } else {
                throw new UnsupportedOperationException("Unsupported type argument type: " + tArg);
            }
            map.put(tParam, arg); // put found value in map
        }
    }

    superClasses(cur).forEach(pt -> findTypeParameterValues(map, pt));
}

private static Stream<Class<?>> superClasses(Class<?> cls) {        
    Stream.Builder<Class<?>> ret = Stream.builder();
    ret.add(cls.getSuperclass());
    Arrays.stream(cls.getInterfaces()).forEach(ret::add);
    return ret.build().filter(Objects::nonNull);
}

private static Stream<Type> genericSuperTypes(Class<?> cls) {
    Stream.Builder<Type> ret = Stream.builder();
    ret.add(cls.getGenericSuperclass());
    Arrays.stream(cls.getGenericInterfaces()).forEach(ret::add);
    return ret.build().filter(Objects::nonNull);
}

然后将结果用于您的特定情况，您可以从地图中获取List类型变量的具体值：

public static void main(String[] args) throws Throwable {
    System.out.println(getGenericListItemType(B.class)); // class java.lang.String
    System.out.println(getGenericListItemType(A.class)); // class java.lang.String
    System.out.println(getGenericListItemType(D.class)); // class java.lang.Integer
}

private static final TypeVariable<?> listE = List.class.getTypeParameters()[0];

public static Class<?> getGenericListItemType(Class<?> cls) {  
    // method defined in 'Reflection' helper class      
    return Reflection.findTypeParameterValues(cls).get(listE);
}

请注意，如果没有特定类型变量的具体定义，则映射将包含null作为该类型变量的值。

如何获取List子类的REAL类型参数？

1 个答案: