如何检查一个ParameterizedType是否表示另一个ParameterizedType的子类型？

Question

以下是代码片段，对于POJO类的每个字段，是否有一种方法可以检查其类型是否为整数列表？实际问题在于类型参数，因为通过instanceof或isAssignableFrom很容易检查它是否为列表。

目前我已经发现了main中的代码行，但它不适用于具有更复杂类层次结构的类型。

public class Test {

    public static void main(String[] args) throws NoSuchFieldException {
        // to check if field f1 is an integer list
        Field field = Pojo.class.getField("f1");
        if (List.class.isAssignableFrom(field.getType())) {
            Type type = field.getGenericType();
            if (type instanceof ParameterizedType) {
                ParameterizedType pt = (ParameterizedType) type;
                if (pt.getActualTypeArguments()[0].equals(Integer.class)) {
                    System.out.println("Yes, it's an integer list");
                }
            }
        }

    }

    public static class Pojo {
        public List<Integer> f1;
        public ArrayList<Integer> f2;
        public C1 f3;
        public C2<Integer> f4;
        public C3<Integer> f5; // notice, this is not an integer list, it's a string list
        public C4<Integer> f6;
        public C5<String, Integer> f7;
    }

    public static class C1 implements List<Integer> {...}

    public static class C2<T> implements List<T> {...}

    public static class C3<T> implements List<String> {...}

    public static class C4<T> implements List<Integer> {...}

    public static class C5<T1, T2> implements List<T2> {...}
}

- gfytd

---

这个回答解决了你的问题吗？Java，有没有一种方法可以知道一个方法的返回类型是否为List<Integer>？ - tgdavies

@tgdavies 你好，感谢您的评论，但那并没有回答我的问题，因为我需要跟踪类型参数。 - gfytd

Answer 1

您说得对，由于擦除的存在，这不是一个容易解决的问题。但我认为它并非无法解决。

基本原则应该是一直跟随类型变量并将其替换为实际参数类型，直到List<E>。

考虑这两个类：

class B<T> extends AbstractList<T>{}
class A<E> extends B<E>{}

在声明B时使用的类型变量名称是T，而在从中扩展A时使用E。因此，我们不能依赖于声明的名称。

• 我们必须遵循子类中的类型变量名称，在父类或接口中用实际值替换变量。
• 这必须从Field开始，直到我们碰到List<E>。（我不确定当List通过多个路径出现在继承关系中时会发生什么。因此，下面没有处理该情况。）
• 当我们最终替换List中的E时，我们可以得出它是否为List<Integer>。

以下是执行此操作的代码。它有相当多的行数，但适用于您添加的情况（以及我自己添加的一些情况）。实现中可能存在缺陷，但此方法应该有效。

public class ParameterizedTypeHierarchy{
    /* When a conclusion is reached - negative or positive - about a field, one of these exceptions is thrown to
     * quickly return to the main(). */
    private static class NotListOfIntegerException extends RuntimeException{
        private Type elementType;

        public NotListOfIntegerException( Type elementType ){
            this.elementType = elementType;
        }
    }
    private static class IsAListOfIntegerException extends RuntimeException{}

    public static void main( String[] args ) throws NoSuchFieldException{
        List<String> fields = Arrays.asList( "f0", "f1", "f2", "c1", "c2", "c3", "c4", 
                                            "c5", "c5Neg1", "c6", "c6Neg1", "c7", "c7Neg1", "c7Neg2" );

        for( String f : fields ){
            // to check if field f1 is an integer list
            Field field = Pojo.class.getField( f );

            try{
                check( field );
            }
            catch( IsAListOfIntegerException e ){
                System.out.println( f + " (" + field.getType().getSimpleName() + ") is a List<Integer>" );
            }
            catch( NotListOfIntegerException e ){
                if( e.elementType == null ) System.out.println( f + " (" + field.getType().getSimpleName() + ") is NOT a List." );
                else System.out.println( f + " (" + field.getType().getSimpleName() + ") is NOT a List<Integer>. It is List<" + e.elementType.getTypeName() + ">." );
            }
            catch( Exception e ){
                e.printStackTrace();
            }
        }
    }

    private static boolean check( Field f ){
        Type type = f.getGenericType();
        if( type instanceof ParameterizedType ){
            /* Parameterized type field. */
            if( isList( (ParameterizedType) type, null, null ) ) return true;
        }
        else if( type instanceof Class ){
            /* Field's type takes no parameters. */
            return fromClass( (Class<?>) type );
        }

        return false;
    }

    private static boolean fromClass( Class<?> type ){
        /* For class there are ways in which a List could be one of its parents: interface implementations
         * or the super class indirectly being a child of List. */
        Type[] intfs = type.getGenericInterfaces();
        if( intfs != null && intfs.length > 0 ){
            for( Type intf : intfs ){
                if( intf instanceof ParameterizedType && isList( (ParameterizedType) intf, type, null ) ) return true;
            }
        }

        Type st = type.getGenericSuperclass();
        
        /* If there is no super class or the super is Object, we can conclude in the negative. */
        if( st == null || Object.class == st ) throw new NotListOfIntegerException( null );

        if( st instanceof ParameterizedType ){
            if( isList( (ParameterizedType) st, type, null ) ) return true;
        }

        return false;
    }

    private static boolean isList( ParameterizedType pt, Class<?> extendingEntity, Type[] types ){
        /* This parameterized type needs to be a list. Else return. */
        Type raw = pt.getRawType();
        if( raw instanceof Class && !List.class.isAssignableFrom( (Class<?>) raw ) ) return false;

        Type[] listParamTypes = pt.getActualTypeArguments();
        
        /* If this is directly List.class, then we can decide here itself. */
        if( raw == List.class ) return listParamTypes[ 0 ] == Integer.class;

        /* This is a parameterized class that implements List. However, the extending class's parameter(s) need not be for 
         * List. Hence, we have get the RIGHT parameters for the parameterized type and check against them. */
        Type[] replaced = replaceTypeVars( pt, extendingEntity, types );
        Class<?> c = (Class<?>) raw;
        return classExtList( c, replaced );
    }

    private static Type[] replaceTypeVars( ParameterizedType pt, Class<?> impl, Type[] types ){
        Map<String, Type> repl = replacements( impl, types );

        Type raw = pt.getRawType();

        Type[] rawTypeParams = null;
        if( raw instanceof Class<?> ){
            Class<?> c = (Class<?>) raw;
            Type[] actual = pt.getActualTypeArguments();
            if( actual == null || actual.length == 0 ) return null;

            rawTypeParams = new Type[ actual.length ];
            for( int i = 0; i < actual.length; i++ ){
                Type tv = actual[ i ];

                Type val = null;
                if( !( tv instanceof TypeVariable ) ){
                    rawTypeParams[ i ] = actual[ i ];
                }
                else{
                    if( ( val = repl.get( ( (TypeVariable<?>) tv ).getName() ) ) == null )
                        rawTypeParams[ i ] = tv;
                    else
                        rawTypeParams[ i ] = val;
                }
            }
        }

        return rawTypeParams;
    }

    /* Replaces the type variables declared on a class with the actual parameters passed. */
    private static Map<String, Type> replacements( Class<?> c, Type[] types ){
        if( c == null ) return Collections.emptyMap();

        TypeVariable<?>[] tps = c.getTypeParameters();
        if( tps == null || tps.length == 0 ) return Collections.emptyMap();

        Map<String, Type> map = new HashMap<>();
        for( int i = 0; i < tps.length; i++ ){
            /* Skip TypeVariable instances. We want only replaced ones. */
            if( types[ i ] instanceof TypeVariable ) continue;

            TypeVariable<?> tv = tps[ i ];
            map.put( tv.getName(), types[ i ] );
        }

        return map;
    }

    private static boolean classExtList( Class<?> c, Type[] types ){
        TypeVariable<?>[] params = c.getTypeParameters();

        Type[] intfs = c.getGenericInterfaces();
        for( Type intf : intfs ){
            /* If this interface is List and is taking Integer as param, great. */
            if( intf instanceof ParameterizedType ){
                ParameterizedType pt = (ParameterizedType) intf;
                if( pt.getRawType() == List.class ){
                    /* If the type argument is Integer.class, we are done. */
                    if( pt.getActualTypeArguments()[ 0 ] == Integer.class ) throw new IsAListOfIntegerException();

                    /* Type argument is the type variable itself. We have to check which type variable 
                     * was passed to List. */
                    for( int i = 0; i < params.length; i++ ){
                        if( params[ i ].getName().equals( pt.getActualTypeArguments()[ 0 ].getTypeName() ) ){
                            if( types[ i ] == Integer.class ) throw new IsAListOfIntegerException();
                            throw new NotListOfIntegerException( types[ i ] );
                        }
                    }
                }
            }
        }

        Type st = c.getGenericSuperclass();
        if( st instanceof ParameterizedType ) return isList( (ParameterizedType) st, c, types );

        return false;
    }

    public static class Pojo {
        public Object f0;
        public List<Integer> f1;
        public ArrayList<Integer> f2;
        public C1 c1;
        public C2<Integer> c2;
        public C3<Integer> c3; // notice, this is not an integer list, it's a string list
        public C4<Integer> c4;
        public C5<String, Integer> c5;
        public C5<String, String> c5Neg1;
        public C6<String, Integer> c6;
        public C6<String, String> c6Neg1;
        public C7<String, Integer> c7;
        public C7<String, String> c7Neg1;
        public C7<String, ?> c7Neg2;
    }
    
    private static interface A<E>{}

    private static class B<T> extends AbstractList<T> {
        @Override
        public T get( int index ){ return null; }

        @Override
        public int size(){ return 0; }
    }
    
    public static class C1 extends B<Integer> {}

    public static class C2<T> extends B<T> {}

    public static class C3<T> extends B<String> {}

    public static class C4<T> extends B<Integer> {}

    public static class C5<T1, T2> extends B<T2> {}
    
    public static class C6<T1, T2> implements List<T2> {...}

    public static class C7<T1, T2> implements List<T2>, A<T1>{...}
}

- Sree Kumar

---

非常感谢，Kumar，类型变量替换的想法很棒。 - gfytd

Answer 2

谢谢Kumar，扭曲类型变量似乎是一个不错的选择，我对Kumar的代码进行了一些重构，这样我就可以得到实际的类型参数，如果有人需要的话，我在这里留下来。

// example, getTypeArg(field.getGenericType(), null, List.class, 0),
// or, getTypeArg(field.getGenericType(), null, Map.class, 1),
public static Type getTypeArg(Type type, Map<TypeVariable<?>, Type> typeVar2RealType,
                              Class<?> targetClazz, int targetTypeArgIndex) {
    if (targetClazz == null) {
        throw new RuntimeException("Missing target class");
    }
    if (targetTypeArgIndex < 0) {
        throw new RuntimeException("Invalid target type argument index");
    }
    if (type == null || type.equals(Object.class)) {
        return null;
    }
    Class<?> raw;
    Map<TypeVariable<?>, Type> map = null;
    if (type instanceof ParameterizedType) {
        ParameterizedType pt = (ParameterizedType) type;
        raw = (Class<?>) pt.getRawType();
        if (!targetClazz.isAssignableFrom(raw)) {
            return null;
        }
        map = new HashMap<>();
        for (int i = 0; i < pt.getActualTypeArguments().length; i++) {
            TypeVariable<?> var = raw.getTypeParameters()[i];
            Type typeArg = pt.getActualTypeArguments()[i];
            Type real = typeArg;
            if (typeArg instanceof TypeVariable) {
                TypeVariable<?> tv = (TypeVariable<?>) typeArg;
                if (typeVar2RealType != null && typeVar2RealType.containsKey(tv)) {
                    real = typeVar2RealType.get(tv);
                }
            }
            if (raw.equals(targetClazz) && i == targetTypeArgIndex) {
                return real;
            }
            map.put(var, real);
        }
    } else if (type instanceof Class) {
        raw = (Class<?>) type;
        if (!targetClazz.isAssignableFrom(raw)) {
            return null;
        }
    } else {
        return null; // ?
    }
    //
    for (Type parent : getGenericParents(raw)) {
        Type ret = getTypeArg(parent, map, targetClazz, targetTypeArgIndex);
        if (ret != null) {
            return ret;
        }
    }
    return null;
}

public static List<Type> getGenericParents(Class<?> clazz) {
    List<Type> parents = new ArrayList<>();
    if (clazz.getGenericInterfaces().length > 0) {
        parents = new ArrayList<>(Arrays.asList(clazz.getGenericInterfaces()));
    }
    if (clazz.getGenericSuperclass() != null) {
        parents.add(clazz.getGenericSuperclass());
    }
    return parents;
}

- gfytd