Java反射获取泛型类型：嵌套泛型场景的实现方案

你的原有代码只能处理非嵌套的简单泛型（比如Map<String, String>），因为它直接把所有Type强转为Class，但遇到嵌套泛型（比如Map<String, List<String>>）时，内层的List<String>对应的是ParameterizedType而非Class，强转会抛出ClassCastException。

要处理嵌套场景，需要递归解析Type的实际类型，根据Type的不同子类（Class、ParameterizedType）分别处理。

核心思路 #

Java的泛型类型在运行时通过Type体系表示：

• 普通类对应Class<?>
• 参数化类型（比如List<String>）对应ParameterizedType，它包含两部分信息：原始类型（List.class）和实际泛型参数（String.class）
• 嵌套泛型就是多层ParameterizedType的嵌套，因此需要递归解析每一层的类型信息

实现方案 #

1. 打印嵌套泛型的完整类型描述 #

如果只是需要查看嵌套泛型的结构，可以写一个递归方法生成可读的类型字符串：

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class GenericTypeResolver {

    // 解析单个Type，返回可读的类型字符串
    private static String resolveType(Type type) {
        if (type instanceof Class<?>) {
            return ((Class<?>) type).getSimpleName();
        } else if (type instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) type;
            Type rawType = pt.getRawType();
            StringBuilder sb = new StringBuilder(resolveType(rawType));
            sb.append("<");
            Type[] args = pt.getActualTypeArguments();
            for (int i = 0; i < args.length; i++) {
                if (i > 0) sb.append(", ");
                sb.append(resolveType(args[i]));
            }
            sb.append(">");
            return sb.toString();
        }
        // 处理其他类型（比如通配符? extends String），直接返回类型名
        return type.getTypeName();
    }

    // 解析字段的泛型参数，包括嵌套结构
    public static void printFieldGenericInfo(Field field) {
        Type genericType = field.getGenericType();
        if (!(genericType instanceof ParameterizedType)) {
            System.out.println(field.getName() + " 不是参数化类型");
            return;
        }

        ParameterizedType pt = (ParameterizedType) genericType;
        System.out.println("字段 " + field.getName() + " 的原始类型：" + resolveType(pt.getRawType()));
        Type[] actualArgs = pt.getActualTypeArguments();
        for (int i = 0; i < actualArgs.length; i++) {
            System.out.println("泛型参数" + (i + 1) + "：" + resolveType(actualArgs[i]));
            // 递归解析嵌套的泛型参数
            parseNestedType(actualArgs[i], 1);
        }
    }

    private static void parseNestedType(Type type, int depth) {
        if (!(type instanceof ParameterizedType)) return;

        ParameterizedType pt = (ParameterizedType) type;
        String indent = "  ".repeat(depth);
        System.out.println(indent + "嵌套原始类型：" + resolveType(pt.getRawType()));
        Type[] args = pt.getActualTypeArguments();
        for (int i = 0; i < args.length; i++) {
            System.out.println(indent + "嵌套参数" + (i + 1) + "：" + resolveType(args[i]));
            parseNestedType(args[i], depth + 1);
        }
    }

    // 测试示例
    public static void main(String[] args) throws NoSuchFieldException {
        class TestClass {
            private Map<String, List<List<String>>> nestedMap;
        }
        Field field = TestClass.class.getDeclaredField("nestedMap");
        printFieldGenericInfo(field);
    }
}

运行后输出：

字段 nestedMap 的原始类型：Map
泛型参数1：String
泛型参数2：List<List<String>>
  嵌套原始类型：List
  嵌套参数1：List<String>
    嵌套原始类型：List
    嵌套参数1：String

2. 结构化保存泛型信息 #

如果需要在代码中使用泛型的原始类和嵌套参数，可以自定义一个数据结构来保存：

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

public class GenericTypeResolver {

    // 保存泛型类型的结构化信息
    static class GenericTypeInfo {
        private Class<?> rawClass; // 原始类（比如List.class）
        private List<GenericTypeInfo> nestedTypes; // 嵌套的泛型参数信息

        public Class<?> getRawClass() { return rawClass; }
        public void setRawClass(Class<?> rawClass) { this.rawClass = rawClass; }
        public List<GenericTypeInfo> getNestedTypes() { return nestedTypes; }
        public void setNestedTypes(List<GenericTypeInfo> nestedTypes) { this.nestedTypes = nestedTypes; }

        @Override
        public String toString() {
            if (nestedTypes == null || nestedTypes.isEmpty()) {
                return rawClass.getSimpleName();
            }
            StringBuilder sb = new StringBuilder(rawClass.getSimpleName());
            sb.append("<");
            for (int i = 0; i < nestedTypes.size(); i++) {
                if (i > 0) sb.append(", ");
                sb.append(nestedTypes.get(i).toString());
            }
            sb.append(">");
            return sb.toString();
        }
    }

    // 解析字段的泛型参数，返回结构化信息列表
    public static List<GenericTypeInfo> getFieldGenericInfo(Field field) {
        List<GenericTypeInfo> infoList = new ArrayList<>();
        Type genericType = field.getGenericType();
        if (!(genericType instanceof ParameterizedType)) {
            return infoList;
        }

        ParameterizedType pt = (ParameterizedType) genericType;
        for (Type arg : pt.getActualTypeArguments()) {
            infoList.add(buildGenericTypeInfo(arg));
        }
        return infoList;
    }

    // 递归构建泛型信息
    private static GenericTypeInfo buildGenericTypeInfo(Type type) {
        GenericTypeInfo info = new GenericTypeInfo();
        if (type instanceof Class<?>) {
            info.setRawClass((Class<?>) type);
        } else if (type instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) type;
            info.setRawClass((Class<?>) pt.getRawType());
            List<GenericTypeInfo> nestedInfos = new ArrayList<>();
            for (Type arg : pt.getActualTypeArguments()) {
                nestedInfos.add(buildGenericTypeInfo(arg));
            }
            info.setNestedTypes(nestedInfos);
        }
        // 可扩展处理WildcardType（通配符类型）、GenericArrayType（泛型数组）等
        return info;
    }

    // 测试示例
    public static void main(String[] args) throws NoSuchFieldException {
        class TestClass {
            private Map<String, List<List<String>>> nestedMap;
        }
        Field field = TestClass.class.getDeclaredField("nestedMap");
        List<GenericTypeInfo> infoList = getFieldGenericInfo(field);
        System.out.println("泛型参数1：" + infoList.get(0));
        System.out.println("泛型参数2：" + infoList.get(1));
        // 获取嵌套的List的泛型参数
        System.out.println("第二层List的泛型参数：" + infoList.get(1).getNestedTypes().get(0));
    }
}

运行后输出：

泛型参数1：String
泛型参数2：List<List<String>>
第二层List的泛型参数：List<String>

关键注意点 #

• 泛型擦除：Java的泛型是编译期特性，运行时会擦除部分信息，但字段的泛型类型会被保留在字节码中，因此可以通过反射获取
• 处理其他Type子类：如果需要支持通配符（比如? extends Number）、泛型数组（比如List<String>[]），可以扩展代码处理WildcardType、GenericArrayType等类型

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