参考：我眼中的Java-Type体系(1)
我眼中的Java-Type体系(2)
秒懂Java类型（Type）系统
Java 运行时如何获取泛型参数的类型
Java类型Type 之 ParameterizedType，GenericArrayType，TypeVariabl，WildcardType
从实现的接口获取泛型参数
定义一个泛型父类：
public interface SuperClass<P> {
String process(P p);
}
实现类1：
public class OneImpl implements SuperClass<House> {
@Override
public String process(House house) {
return null;
}
}
测试一下：
public static void main(String[] args) throws Exception {
SuperClass superClass = new OneImpl();
// 获取运行时类型
System.out.println(superClass.getClass());
// 获取实现的接口
Type[] types = superClass.getClass().getGenericInterfaces();
for (Type t : types) {
// ParameterizedType 的实现类：ParameterizedTypeImpl
System.out.println("ParameterizedTypeImpl: " + t.getClass().getName());
// 带有泛型信息
System.out.println(t);
System.out.println(t instanceof ParameterizedType);
// 获取声明这个泛型的类或接口
System.out.println(((ParameterizedType) t).getRawType());
// 获取泛型中的实际类型，可能存在多个泛型，比如 SuperClass<P, R>，所以会返回 Type[] 数组
Type[] paramGenericTypes = ((ParameterizedType) t).getActualTypeArguments();
for (Type actualType : paramGenericTypes) {
// 得到泛型的实际类型，这里也就得到了 Class 类型
System.out.println("actualTypeName: " + actualType.getClass().getName());
System.out.println(actualType);
}
}
System.out.println("------------------------------");
// 获取实现的接口
Class[] t = superClass.getClass().getInterfaces();
for (Class c : t) {
System.out.println(c);
}
}
输出：
class com.jiaobucong.common.core.generic.OneImpl
ParameterizedTypeImpl: sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
com.jiaobucong.common.core.generic.SuperClass<com.jiaobucong.common.core.generic.House>
true
interface com.jiaobucong.common.core.generic.SuperClass
actualTypeName: java.lang.Class
class com.jiaobucong.common.core.generic.House
------------------------------
interface com.jiaobucong.common.core.generic.SuperClass
实现类2，不带泛型：
public class TwoImpl implements SuperClass {
@Override
public String process(Object o) {
return null;
}
}
来看测试：
public static void main(String[] args) throws Exception {
SuperClass superClass1 = new TwoImpl();
Type[] types1 = superClass1.getClass().getGenericInterfaces();
for (Type type : types1) {
System.out.println(type);
// 实现类没有指定泛型参数，没有对应的 ParameterizedTypeImpl 实现类
System.out.println(type instanceof ParameterizedType);
}
}
输出：
interface com.jiaobucong.common.core.generic.SuperClass
false
通过 Method 方法级获取泛型参数
public class GenericArrayTest {
public static void main(String[] args) throws Exception {
Method[] methods = OneGenericClass.class.getMethods();
for (Method method : methods) {
// 获取每个方法的参数化类型
if (!"go".equals(method.getName())) {
continue;
}
Type[] parameters = method.getGenericParameterTypes();
for (Type type : parameters) {
// 不同的参数定义返回的类型也是不一样的
if (type instanceof Class) {
// 第一个参数
System.out.println("class: " + type);
} else if (type instanceof ParameterizedType) {
// 声明这个泛型的类
Class<?> clazz = (Class<?>) ((ParameterizedType) type).getRawType();
System.out.println(type + ", ParameterizedType, "
+ "holderType: " + clazz
+ ", actual parameterized classes: "
+ Arrays.toString(getActualClass(type)));
} else if(type instanceof GenericArrayType) {
// 对于数组类型得到的是 GenericArrayType
Type arrayType = ((GenericArrayType) type).getGenericComponentType();
System.out.println(type + ", GenericArrayType, actual classes: "
+ Arrays.toString(getActualClass(arrayType)));
}
}
}
}
public static Class<?>[] getActualClass(Type type) {
if (type instanceof ParameterizedType) {
Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments();
Class<?>[] actualClasses = new Class[actualTypes.length];
for (int i = 0; i < actualTypes.length; i++) {
Type actualType = actualTypes[i];
if (actualType instanceof Class) {
actualClasses[i] = (Class<?>) actualType;
}
// ArrayList<ArrayList<String>> arrayLists, 第一次获取到的类型还是 ParameterizedType 类型
if (actualType instanceof ParameterizedType) {
return getActualClass(actualType);
}
}
return actualClasses;
}
return null;
}
class OneGenericClass {
public void go(long userId, ArrayList<ArrayList<String>> arrayLists, List<Long> orderIds, Map<String, Integer> map, List<Long>[] listArr) {
System.out.println(userId);
System.out.println(orderIds);
}
}
输出：
class: long
java.util.ArrayList<java.util.ArrayList<java.lang.String>>, ParameterizedType, holderType: class java.util.ArrayList, actual parameterized classes: [class java.lang.String]
java.util.List<java.lang.Long>, ParameterizedType, holderType: interface java.util.List, actual parameterized classes: [class java.lang.Long]
java.util.Map<java.lang.String, java.lang.Integer>, ParameterizedType, holderType: interface java.util.Map, actual parameterized classes: [class java.lang.String, class java.lang.Integer]
java.util.List<java.lang.Long>[], GenericArrayType, actual classes: [class java.lang.Long]
从 Field 获取泛型参数
public class GenericTest1 {
private List<String>[] listArray;
private List<Long> list;
public static void main(String[] args) throws Exception {
test1();
System.out.println("-------------------test2");
test2();
}
public static void test1() throws Exception {
Field fieldListArray = GenericTest1.class.getDeclaredField("listArray");
Type type = fieldListArray.getGenericType();
// 这里会报错，得到的不是一个 ParameterizedType
// Type[] arrayType = ((ParameterizedType) type).getActualTypeArguments();
// 得到的是一个GenericArrayType，这个地方是一个泛型数组的类型，所以得到的是 GenericArrayType
// 得到的类型是去掉了最右边的[]，是 List<String>，得到的 arrayType 是 ParameterizedType
Type arrayType = ((GenericArrayType) type).getGenericComponentType();
System.out.println(arrayType);
System.out.println(arrayType.getClass().getName());
Type[] types = ((ParameterizedType) arrayType).getActualTypeArguments();
for (Type type1 : types) {
System.out.println(type1.getClass().getName());
// 这里获取到了 List<String>[] listArray <> 中的 String 类型
System.out.println(type1);
}
}
public static void test2() throws Exception {
Field fieldList = GenericTest1.class.getDeclaredField("list");
Type typeList = fieldList.getGenericType();
System.out.println(typeList.getClass().getName());
Type[] parameterTypes = ((ParameterizedType) typeList).getActualTypeArguments();
// 获取 List<T> 中的 T 类型
for (Type type : parameterTypes) {
System.out.println(type.getClass().getName());
System.out.println(type);
}
// 定义这个 List 的类型
System.out.println(fieldList.getType());
}
}
输出：
java.util.List<java.lang.String>
sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
java.lang.Class
class java.lang.String
-------------------test2
sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
java.lang.Class
class java.lang.Long
interface java.util.List
我们可以在类接口上、构造器上、方法上定义泛型类型，不同的泛型参数定义得到可能是 ParameterizedType、TypeVariable、Class、GenericArrayType，然后再通过得到的类型做不同的处理。