如何判断Java方法返回或字段类型是否为List<Integer>并获取泛型参数

核心逻辑 #

判断需要分两个维度，两个条件同时满足才符合要求：

• 返回值的原始类型实现或继承了java.util.List接口
• List接口对应的泛型参数类型严格为java.lang.Integer

实现代码 #

可以直接使用以下工具方法完成校验：

import java.lang.reflect.*;
import java.util.List;

public class GenericTypeUtils {

    public static boolean isListOfInteger(Type type) {
        // 先判断类型是否为参数化类型
        if (!(type instanceof ParameterizedType parameterizedType)) {
            // 原生List没有泛型参数，不符合要求
            return false;
        }
        Type rawType = parameterizedType.getRawType();
        if (!(rawType instanceof Class<?> clazz)) {
            return false;
        }
        // 第一步：校验原始类型是否是List的实现/子类
        if (!List.class.isAssignableFrom(clazz)) {
            return false;
        }
        // 第二步：查找List对应的泛型参数
        Type listTypeArgument = getListGenericArgument(type);
        return listTypeArgument == Integer.class;
    }

    private static Type getListGenericArgument(Type type) {
        if (type instanceof ParameterizedType parameterizedType) {
            Class<?> rawType = (Class<?>) parameterizedType.getRawType();
            // 如果当前就是List类型，直接返回第一个泛型参数
            if (rawType == List.class) {
                return parameterizedType.getActualTypeArguments()[0];
            }
            // 递归查找父类和实现接口的泛型
            // 先查父类
            Type superClass = rawType.getGenericSuperclass();
            Type result = getListGenericArgument(superClass);
            if (result != null) {
                return resolveType(result, parameterizedType);
            }
            // 再查实现接口
            for (Type iface : rawType.getGenericInterfaces()) {
                result = getListGenericArgument(iface);
                if (result != null) {
                    return resolveType(result, parameterizedType);
                }
            }
        } else if (type instanceof Class<?> clazz) {
            // 处理无泛型的父类/接口
            if (List.class.isAssignableFrom(clazz)) {
                // 原生List，泛型参数为Object
                return Object.class;
            }
            // 递归父类和接口
            Type superClass = clazz.getGenericSuperclass();
            Type result = getListGenericArgument(superClass);
            if (result != null) {
                return result;
            }
            for (Type iface : clazz.getGenericInterfaces()) {
                result = getListGenericArgument(iface);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }

    // 解析泛型变量的实际类型
    private static Type resolveType(Type type, ParameterizedType context) {
        if (type instanceof TypeVariable<?> typeVar) {
            String varName = typeVar.getName();
            TypeVariable<?>[] typeParams = ((Class<?>) context.getRawType()).getTypeParameters();
            for (int i = 0; i < typeParams.length; i++) {
                if (typeParams[i].getName().equals(varName)) {
                    return context.getActualTypeArguments()[i];
                }
            }
        }
        return type;
    }
}

使用示例 #

针对你提供的Dummy类，调用方式如下：

public class Test {
    public static void main(String[] args) throws NoSuchMethodException {
        // 校验foo方法返回值
        Method fooMethod = Dummy.class.getMethod("foo");
        Type fooReturnType = fooMethod.getGenericReturnType();
        System.out.println(GenericTypeUtils.isListOfInteger(fooReturnType)); // 输出true

        // 校验bar方法返回值
        Method barMethod = Dummy.class.getMethod("bar");
        Type barReturnType = barMethod.getGenericReturnType();
        // 如果Abc<Integer>实现了List<Integer>则输出true，否则输出false
        System.out.println(GenericTypeUtils.isListOfInteger(barReturnType));
    }
}

适配POJO字段处理场景 #

针对你需要提取POJO字段信息的需求，只需要把方法返回类型替换为字段的泛型类型即可：
Type fieldType = field.getGenericType();
之后调用isListOfInteger(fieldType)就能判断字段是否为Integer类型的List实现类。

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