通常我们使用 Class 来描述数据类型，其实在 JDK 中有一个更通用的类型接口 Type ， Type 是 JDK 中所有类型的公共父接口， Class 也是 Type 的其中一个实现类。

 public interface Type {
    default String get TypeName () {
        return this.toString();
    }
} 

在没有 泛型 之前， JAVA 只有原始类型（ raw Type ），此时的类型都通过 Class 进行描述。

 public final class Class<T> 
        implements Serializable, GenericDeclaration, Type, AnnotatedElement 

加入泛型之后， JDK 对类型进行了扩充，在 Class 之外添加了以下四种类型。

ParameterizedType 的用法

ParameterizedType 表示参数化类型，所谓参数指的就是 <> 中的泛型。

 public interface ParameterizedType extends Type {
    // 获取 <> 内的泛型类型
    Type[] getActualTypeArguments();
    // 获取原始类型，如果泛型结构为 O<T>，返回 O
    Type getRawType();
    // 如果泛型结构为 O<T>.I<S>，返回外层的 O<T>
    Type getOwnerType();   
} 

获取父类的泛型信息

在 Class 类中有一个 get Generic Superclass() 方法，用于获取带泛型信息的父类，如果父类不带泛型，则等同于 getSuperclass() 方法。

创建一个不带泛型的父类并实现

 public class GenericService {
}

public class UserService extends GenericService {
} 
 public class GenericTest {

    public  static   void  main(String[] args) {
        Type genericSuperClass = UserService.class.getGenericSuperclass();
        Class<? super UserService> superclass = UserService.class.getSuperclass();
        System.out.println(genericSuperClass);
        System.out.println(superclass);
        System.out.println(genericSuperClass == superclass);
    }

} 

输出如下

 class test.GenericService
class test.GenericService
true 

可以看到 getGenericSuperclass 与 getSuperclass 返回的都是 Class ，而且是同一个 Class 。

接下来使用泛型，再次验证，这里需要两个类 UserRepository 与 User ，自行创建即可。

 public class GenericService<T, M> {
}

public class UserService extends GenericService<UserRepository, User> {
} 

再次运行，可以看到两者返回的对象已经不一样了， getGenericSuperclass 方法返回的是带了泛型信息的 ParameterizedType 。

 test.GenericService<test.UserRepository, test.User>
class test.GenericService
false 

通过 ParameterizedType 可以进一步获取到泛型

 public class GenericTest {

    public static void main(String[] args) {
        Type genericSuperClass = UserService.class.getGenericSuperclass();
        ParameterizedType parameterizedType = (ParameterizedType) genericSuperClass;
        // 获取原始类型 Class
        displayType(parameterizedType.getRawType());
        // 获取泛型
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        for (Type argument : actualTypeArguments) {
            displayType(argument);
        }
    }

    public static void displayType(Type type) {
        System.out.println(type.getTypeName() + " --- " + type.getClass().getSimpleName());
    }

} 

输出结果

 test.GenericService --- Class
test.UserRepository --- Class
test.User --- Class 

获取接口的泛型信息

在 Class 类中还提供了一个 getGenericInterfaces() 方法，用于获取带泛型信息的接口。

创建两个接口，一个不带泛型，一个带泛型

 public interface IA {
}

public interface IB<T, P extends  Serializable > {
} 

创建一个实现类

 public class Impl implements IA, IB<UserRepository, User> {
} 

获取接口的泛型

 public class GenericTest {

    public static void main(String[] args) {
        Type[] genericInterfaces = Impl.class.getGenericInterfaces();
        for (Type type : genericInterfaces) {
            if (type  instanceof  ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) type;
                displayType(parameterizedType);
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                for (Type argument : actualTypeArguments) {
                    displayType(argument);
                }
            } else {
                displayType(type);
            }
            System.out.println("-------------------------------");
        }
    }

    public static void displayType(Type type) {
        System.out.println(type.getTypeName() + " --- " + type.getClass().getSimpleName());
    }

} 

输出结果

 test.IA --- Class
-------------------------------
test.IB<test.UserRepository, test.User> --- ParameterizedTypeImpl
test.UserRepository --- Class
test.User --- Class
------------------------------- 

提供一个获取父类及接口泛型的工具类

 public class ReflectUtils {

    /**
     * 获取父类指定位置的泛型类型
     */    public static Class<?> getSuperClassGenericType(Class<?> clazz, int index) {
        Type genType = clazz.getGenericSuperclass();
        if (!(genType instanceof ParameterizedType)) {
            log.warn(String.format("Warn: %s's superclass not ParameterizedType", clazz.getSimpleName()));
            return Object.class;
        }
        return indexOfGenericType(clazz, (ParameterizedType) genType, index);
    }

    /**
     * 获取指定接口指定位置的泛型类型
     */    public static Class<?> getInterfaceGenericType(Class<?> clazz, Class<?> target, int index) {
        for (Type genericInterface : clazz.getGenericInterfaces()) {
            if (genericInterface instanceof ParameterizedType) {
                if (((ParameterizedType) genericInterface).getRawType() == target) {
                    return indexOfGenericType(clazz, (ParameterizedType) genericInterface, index);
                }
            } else if (genericInterface == target) {
                log.warn(String.format("Warn: %s's interface not ParameterizedType", clazz.getSimpleName()));
                return Object.class;
            }
        }
        return Object.class;
    }

    public static Class<?> indexOfGenericType(Class<?> clazz, ParameterizedType type, int index) {
        Type[]  params  = type.getActualTypeArguments();
        if (index >= params.length || index <) {
            log.warn(String.format("Warn: Index: %s, Size of %s's Parameterized Type: %s .", index,
                    clazz.getSimpleName(), params.length));
            return Object.class;
        }
        if (!(params[index] instanceof Class)) {
            log.warn(String.format("Warn: %s not set the actual class on superclass generic parameter",
                    clazz.getSimpleName()));
            return Object.class;
        }
        return (Class<?>) params[index];
    }
} 

获取字段的泛型类型

Field 类中提供了一个 getGenericType() 方法，用于获取带泛型信息的字段类型，如果不存在泛型信息，则该方法与 getType() 等效。

 public class GenericTest {

     private  List<String> list;
    private List unknownList;
    private Map<String, Long> map;
    private Map unknownMap;
    private Map.Entry<String, Long> entry;

    public static void main(String[] args) {
        Field[] fields = GenericTest.class.getDeclaredFields();
        for (Field f : fields) {
            System.out.println(f.getName() + " is ParameterizedType: " + (f.getGenericType() instanceof ParameterizedType));
        }
    }
} 

输出如下，可以看到，有没有泛型，不是看类声明有没有泛型，而是看变量声明时有没有带泛型。比如 unknownList 没有声明泛型，那么 getGenericType() 方法返回的就是 Class ，而不是 ParameterizedType 。

 list is ParameterizedType: true
unknownList is ParameterizedType: false
map is ParameterizedType: true
unknownMap is ParameterizedType: false
entry is ParameterizedType: true 

获取泛型变量的泛型信息

 public class GenericTest {

    private List<String> list;
    private List unknownList;
    private Map<String, Long> map;
    private Map unknownMap;
    private Map.Entry<String, Long> entry;

    public static void main(String[] args) {
        Field[] fields = GenericTest.class.getDeclaredFields();
        for (Field f : fields) {
            if (f.getGenericType() instanceof ParameterizedType) {
                System.out.print(f.getName() + "<");
                ParameterizedType genericType = (ParameterizedType) f.getGenericType();
                Type[] typeArguments = genericType.getActualTypeArguments();
                int i =;
                for (Type argument : typeArguments) {
                    if (i++ >) {
                        System.out.print(",");
                    }
                    System.out.print(argument.getTypeName());
                }
                System.out.println(">");
            }
        }
    }
} 

输出如下

 list<java.lang.String>
map<java.lang.String,java.lang.Long>
entry<java.lang.String, java .lang.Long> 

这里也可以看一下 getOwnerType() 方法的用法

 public class GenericTest {

    private List<String> list;
    private List unknownList;
    private Map<String, Long> map;
    private Map unknownMap;
    private Map.Entry<String, Long> entry;

    public static void main(String[] args) {
        Field[] fields = GenericTest.class.getDeclaredFields();
        for (Field f : fields) {
            if (f.getGenericType() instanceof ParameterizedType) {
                ParameterizedType genericType = (ParameterizedType) f.getGenericType();
                System.out.println(f.getName() + " ownerType is " +
                        (genericType.getOwnerType() == null ? "null" : genericType.getOwnerType().getTypeName()));
            }
        }
    }
} 

输出如下，可以看到，当泛型结构为 O<T>.I<S> 类型时，调用 getOwnerType() 会返回外层的 O<T> ，否则返回空。

 list ownerType is null
map ownerType is null
entry ownerType is java.util.Map

获取方法的泛型信息

 public class GenericTest {

    public static void main(String[] args) {
        Method[] methods = GenericTest.class.getDeclaredMethods();
        for (Method method : methods) {
            if (method.getName().equals("test")) {
                Type[] genericParameterTypes = method.getGenericParameterTypes();
                for (Type genericParameterType : genericParameterTypes) {
                    if (genericParameterType instanceof ParameterizedType) {
                        System.out.println(genericParameterType.getTypeName());
                    }
                }
            }
        }
    }

    public <T> T test(List<String> l, List<ArrayList<String>> l2, List<T> l3,
                      List<? extends Number> l, List<ArrayList<String>[]> l5, Map< Boolean ,  Integer > l6) {
        return null;
    }
} 

输出如下

 java.util.List<java.lang.String>
java.util.List<java.util.ArrayList<java.lang.String>>
java.util.List<T>
java.util.List<? extends java.lang.Number>
java.util.List<java.util.ArrayList<java.lang.String>[]>
java.util.Map<java.lang.Boolean, java.lang.Integer> 

GenericArrayType 的用法

GenericArrayType 表示泛型数组

 public interface GenericArrayType extends Type {
    
    Type getGenericComponentType();
    
} 

创建一个泛型类，包含一个泛型数组

 public class Holder<T> {

    private T[] arrayData;

    public void test(List<String>[] listArray, T[] values) {}

} 
 public class GenericTest {

    public static void main(String[] args) {
        Field[] fields = Holder.class.getDeclaredFields();
        for (Field field : fields) {
            if (field.getGenericType() instanceof GenericArrayType) {
                GenericArrayType genericType = (GenericArrayType) field.getGenericType();
                System.out.println(field.getName() + " is " + genericType.getTypeName() +
                        " and componentType is " + genericType.getGenericComponentType().getTypeName());
            }
        }
    }
} 

输出如下

 arrayData is T[] and componentType is T 

TypeVariable 的用法

TypeVariable 表示泛型变量，只要泛型不是具体的类型，比如 <T> 、 <E extends T> 都归类为泛型变量。

 public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement {
    // 获取变量名
    String getName();
    // 获取原始类型
    D getGenericDeclaration();
    // 获取泛型的继承关系
    Type[] getBounds();
    AnnotatedType[] getAnnotatedBounds();
} 

获取方法的返回参数

 public class GenericTest {
    public static void main(String[] args) {
        Method[] methods = GenericTest.class.getDeclaredMethods();
        Method method = Arrays.stream(methods)
                .filter(v -> v.getName().equals("testTypeVariable"))
                .findAny().get();

        Type type = method.getGenericReturnType();
        displayType(type);
        TypeVariable typeVariable = (TypeVariable) type;
        System.out.println(typeVariable.getGenericDeclaration());
        displayType(typeVariable.getBounds()[]);
    }

    public static void displayType(Type type) {
        System.out.println(type.getTypeName() + " --- " + type.getClass().getSimpleName());
    }

    public <T extends User> T testTypeVariable() {
        return null;
    }
} 

输出如下

 T --- TypeVariableImpl
public test.User test.Test.testTypeVariable()
test.User --- Class 

WildcardType 的用法

WildcardType 表示通配符，即 <?> 这种，接口包含两个方法

• getUpperBounds：通配符格式如 <? extends P> 这种，说明泛型类型继承自 P ， getUpperBounds 方法可以获取到 P 的类型
• getLowerBounds：通配符格式如 <? super C> 这种，说明泛型类型是 C 的超类， getLowerBounds 方法可以获取到 C 的类型

 public interface WildcardType extends Type {
    // 向上继承
    Type[] getUpperBounds();
    // 向下继承
    Type[] getLowerBounds();
} 

获取方法的参数，获取参数中定义的通配符信息

 public class GenericTest {

    public static void main(String[] args) {
        Method[] methods = GenericTest.class.getDeclaredMethods();
        Method method = Arrays.stream(methods)
                .filter(v -> v.getName().equals("testWildcardType"))
                .findAny().get();
        Type[] types = method.getGenericParameterTypes();
        int index =;
        for (Type type : types) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type typeArgument = parameterizedType.getActualTypeArguments()[];
            System.out.println("参数" + ++index + "泛型类型：" + typeArgument.getClass().getSimpleName());

            if (typeArgument instanceof WildcardType) {
                WildcardType wildcardType = (WildcardType) typeArgument;
                for (Type upperType : wildcardType.getUpperBounds()) {
                    System.out.println("  upperType：" + upperType.getTypeName());
                }
                for (Type lowerType : wildcardType.getLowerBounds()) {
                    System.out.println("  lowerType：" + lowerType.getTypeName());
                }
            }
        }
    }

    public <T> void testWildcardType(List<T> l, List<?> l2, List<? extends T> l3, List<? super Integer> l4) {
    }
} 

输出如下

 参数泛型类型：TypeVariableImpl
参数泛型类型：WildcardTypeImpl
  upperType：java.lang.Object
参数泛型类型：WildcardTypeImpl
  upperType：T
参数泛型类型：WildcardTypeImpl
  upperType：java.lang.Object
  lowerType：java.lang.Integer