java反射 - 获取泛型的class

基本代码原理

获取泛型，主要就是看 Type 是不是继承自 ParameterizedType，核心代码如下。

class Test{
    public Type[] eg(Type type){
        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            return parameterizedType.getActualTypeArguments();
        }
        return null;
    }
}

工具类

package cn.seaboot.commons.reflect;

import cn.seaboot.commons.core.CommonUtils;
import cn.seaboot.commons.lang.Warning;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * 主要用于对象解析
 *
 * @author Mr.css
 * @version 2019/8/22 17:15
 */
public class ObjectUtils {

    /**
     * 获取参数的泛型
     *
     * @param parameter 参数
     * @return Type
     */
    public static Type[] getGeneric(Parameter parameter) {
        Type type = parameter.getParameterizedType();
        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            return parameterizedType.getActualTypeArguments();
        }
        return null;
    }

    /**
     * 获取参数的泛型
     *
     * @param parameter 参数
     * @return Type
     */
    public static Type getFirstGeneric(Parameter parameter) {
        return getFirstGeneric(getGeneric(parameter));
    }

    /**
     * 获取字段的泛型
     *
     * @param field 对象字段
     * @return Type
     */
    public static Type[] getGeneric(Field field) {
        Type type = field.getGenericType();
        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            return parameterizedType.getActualTypeArguments();
        }
        return null;
    }

    /**
     * 获取字段的泛型
     *
     * @param field 对象字段
     * @return Type
     */
    public static Type getFirstGeneric(Field field) {
        return getFirstGeneric(getGeneric(field));
    }

    /**
     * 获取某个接口的泛型，
     * 例如：A类继承自List，List用到的泛型数Integer，业务中需要获取List采用的泛型。
     * 此时：instance填A.class, targetClass填写List.class
     *
     * @param instance    对象实例/接口
     * @param targetClass 目标接口，因为Java允许多继承，需要声明，要获取哪个接口的泛型
     * @return Type
     */
    public static Type[] getGeneric(Class<?> instance, Class<?> targetClass) {
        Type[] superclass = instance.getGenericInterfaces();
        for (Type type : superclass) {
            if (type instanceof ParameterizedType) {
                ParameterizedType parameterized = (ParameterizedType) type;
                if (parameterized.getRawType().equals(targetClass)) {
                    return parameterized.getActualTypeArguments();
                }
            }
        }
        return null;
    }

    /**
     * 获取某个接口的泛型，
     * 例如：A类继承自List，List用到的泛型数Integer，业务中需要获取List采用的泛型。
     * 此时：instance填A.class, targetClass填写List.class
     *
     * @param instance    对象实例/接口
     * @param targetClass 目标接口，因为Java允许多继承，需要声明，要获取哪个接口的泛型
     * @return Type
     */
    public static Type getFirstGeneric(Class<?> instance, Class<?> targetClass) {
        return getFirstGeneric(getGeneric(instance, targetClass));
    }

    /**
     * 获取返回值泛型
     *
     * @param method -
     * @return type[]
     */
    public static Type[] getReturnGeneric(Method method) {
        Type type = method.getGenericReturnType();
        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            return parameterizedType.getActualTypeArguments();
        }
        return null;
    }

    /**
     * 获取返回值泛型
     *
     * @param method -
     * @return type[]
     */
    public static Type getFirstReturnGeneric(Method method) {
        return getFirstGeneric(getReturnGeneric(method));
    }

    /**
     * 多数场合下，并不需要返回全部的泛型类型，
     * 在明确只有1个泛型的情况下，数组会增加非常多的空值判断
     *
     * @return 第一个泛型
     */
    public static Type getFirstGeneric(Type[] types) {
        if (CommonUtils.isNotEmpty(types)) {
            return types[0];
        } else {
            return null;
        }
    }
}