Java中如何提取嵌套在List内部的List的泛型类型参数

问题背景 #

需要提取嵌套容器类型的泛型参数，例如从List<List<String>>类型的字段中解析出完整的泛型层级。现有单层泛型解析方案只能识别最外层的泛型参数，无法适配嵌套场景。
原有单层解析代码如下：

for (Field field : aClass.getDeclaredFields()) {
    //检查字段类型是否可携带泛型参数，例如List<String>
    if(List.class.isAssignableFrom(field.getType()) || Map.class.isAssignableFrom(field.getType())) {
        //提取泛型参数，需先将类型强转为ParameterizedType，再转成Class以便捷获取简称
        List<Class<?>> typeParameters = Stream.of(((ParameterizedType) field.getGenericType()).getActualTypeArguments())
                .map(type -> (Class<?>) type)
                .collect(Collectors.toList());

        //针对List<String> strings;这类字段，代码将输出：strings: List<String>
        System.out.println(field.getName() + ": " +
                        field.getType().getSimpleName() + "<" +
                        typeParameters.stream().map(Class::getSimpleName).collect(Collectors.joining(", ")) +
                        "> ");

    }
}

实现思路 #

原有代码的核心问题是直接将所有泛型实参强转为Class类型，仅当泛型实参为普通类时生效。如果实参本身是带泛型的ParameterizedType（例如List<String>），就会触发类型转换异常。
可以通过递归解析的方式处理嵌套泛型：每次拿到泛型实参时先判断类型，如果是参数化类型就继续解析其内部的泛型参数，直到遇到普通类为止。

完整实现代码 #

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class GenericParser {
    // 递归解析泛型类型，返回完整的类型描述
    private static String parseGenericType(Type type) {
        // 普通类类型，直接返回类名简称
        if (type instanceof Class<?>) {
            return ((Class<?>) type).getSimpleName();
        }
        // 参数化类型（带泛型的容器类型）
        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            // 解析原始类型简称
            String rawTypeName = ((Class<?>) parameterizedType.getRawType()).getSimpleName();
            // 递归解析所有泛型实参
            String typeArgs = Stream.of(parameterizedType.getActualTypeArguments())
                    .map(GenericParser::parseGenericType)
                    .collect(Collectors.joining(", "));
            return rawTypeName + "<" + typeArgs + ">";
        }
        // 通配符、泛型变量等其他类型可按需扩展处理逻辑，此处默认返回全类名
        return type.getTypeName();
    }

    public static void parseFieldsGenericType(Class<?> targetClass) {
        for (Field field : targetClass.getDeclaredFields()) {
            Class<?> fieldType = field.getType();
            // 只处理List、Map类型的字段，可按需扩展其他容器类型
            if (List.class.isAssignableFrom(fieldType) || Map.class.isAssignableFrom(fieldType)) {
                String fullTypeDesc = parseGenericType(field.getGenericType());
                System.out.println(field.getName() + ": " + fullTypeDesc);
            }
        }
    }

    // 测试用例
    public static void main(String[] args) {
        // 测试类示例
        class TestClass {
            List<List<String>> strings;
            Map<String, List<Integer>> intMap;
            List<Long> longList;
        }
        parseFieldsGenericType(TestClass.class);
    }
}

运行结果 #

测试用例执行后输出如下：

strings: List<List<String>>
intMap: Map<String, List<Integer>>
longList: List<Long>

注意事项 #

• 该方案仅能解析编译期固定写在类、字段、方法签名上的泛型信息，运行时创建的泛型对象会被类型擦除，无法通过对象实例获取泛型参数
• 如果需要处理通配符（如List<? extends Number>）、泛型变量（如List<T>）等场景，只需要在parseGenericType方法中新增对应类型的判断分支即可

内容的提问来源于stack exchange，提问作者Patryk