JAVA获取泛型类型信息
根据使用泛型位置的不同可以分为：
- 声明侧泛型
- 使用侧泛型
一、声明侧泛型
声明侧的泛型信息被记录在Class文件的Constant pool中以Signature的形式保存。
获取泛型类型相关方法
JDK的Class、Field、Method类提供了一系列的获取泛型类型的相关方法。
1.、Class类的泛型方法
Type getGenericSuperclass()：获取父类的Type
- 当父类有泛型返回的实际
Type(接口)是ParameterizedType(接口)的实现类ParameterizedTypeImpl - 当父类无泛型返回的实际
Type(接口)是Class类
Type[] getGenericInterfaces()：获取所有实现接口的Type集合
- 当父类有泛型返回的实际
Type是ParameterizedType接口的实现类ParameterizedTypeImpl类 - 当父类无泛型返回的实际
Type是Class类
2.、Field类的泛型方法
Type getGenericType()：获取字段的Type- 当字段有泛型返回的实际
Type是ParameterizedType接口的实现类ParameterizedTypeImpl类 - 当字段无泛型返回的实际
Type是Class类
- 当字段有泛型返回的实际
3、Method类的泛型方法
Type getGenericReturnType()：获取方法返回值的Type
- 当返回值有泛型返回的实际
Type是ParameterizedType接口的实现类ParameterizedTypeImpl类 - 当返回值无泛型返回的实际Type是Class类
Type[] getGenericParameterTypes()：获取方法参数的Type集合
-
当方法参数有泛型返回的实际
Type是ParameterizedType接口的实现类ParameterizedTypeImpl类 -
当方法参数无泛型返回的实际
Type是Class类
Type[] getGenericExceptionTypes()：获取方法声明的异常的Type集合
- 当方法参数有泛型返回的实际
Type是ParameterizedType接口的实现类ParameterizedTypeImpl类 - 当方法参数无泛型返回的实际
Type是Class类
4、ParameterizedType类
ParameterizedType是Type的子接口，表示参数化类型，用于获取泛型的参数类型。
ParameterizedType的主要方有：
Type[] getActualTypeArguments()：获取类的泛型参数的Type集合Type getRawType()：获取声明此类型的类或接口的生类型(不含泛型参数的)ClassType getOwnerType()：当前类或接口是内部类，则该方法返回的是外部类的Class（所属主类的Class）
获取声明侧的泛型类型信息
- 带有泛型参数的类
- 带有泛型参数的接口
- 带有泛型参数的成员变量
- 带有泛型参数的方法
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class MyTest extends Father<List<String>, ArrayList<String>> implements AInterface<Integer>, BInterface<Long> {
private List<Integer> list;
private Map<Integer, String> map;
public List<String> aa() {
return null;
}
public void bb(List<Long> list) {}
public static void main(String[] args) throws Exception {
System.out.println("泛型类声明的泛型类型");
ParameterizedType father = (ParameterizedType) MyTest.class.getGenericSuperclass();
System.out.println(father.getTypeName() + "\t====>\t" + father.getActualTypeArguments()[0].getTypeName());
Type[] types = MyTest.class.getGenericInterfaces();
for (Type t : types) {
ParameterizedType interfacee = (ParameterizedType) t;
System.out.println(interfacee.getTypeName() + "\t====>\t" + interfacee.getActualTypeArguments()[0].getTypeName());
}
System.out.println("\n成员变量中的泛型类型");
ParameterizedType field = (ParameterizedType) MyTest.class.getDeclaredField("list").getGenericType();
System.out.println(field.getTypeName() + "\t====>\t" + field.getActualTypeArguments()[0].getTypeName());
ParameterizedType field2 = (ParameterizedType) MyTest.class.getDeclaredField("map").getGenericType();
System.out.println(field2.getTypeName() + "\t====>\t" + field2.getActualTypeArguments()[0].getTypeName() + " || " + field2.getActualTypeArguments()[1].getTypeName());
System.out.println("\n方法参数中的泛型类型");
ParameterizedType var = (ParameterizedType) MyTest.class.getMethod("aa").getGenericReturnType();
System.out.println(var.getTypeName() + "\t====>\t" + var.getActualTypeArguments()[0].getTypeName());
System.out.println("\n方法返回值中的泛型类型");
Type[] returnVars = MyTest.class.getMethod("bb", List.class).getGenericParameterTypes();
for (Type t : returnVars) {
ParameterizedType returnVar = (ParameterizedType) t;
System.out.println(returnVar.getTypeName() + "\t====>\t" + returnVar.getActualTypeArguments()[0].getTypeName());
}
}
}
class Father<T, B extends T> {}
interface AInterface<U> {}
interface BInterface<C> {}
执行后输出：
泛型类声明的泛型类型
org.ailun.Father<java.util.List<java.lang.String>, java.util.ArrayList<java.lang.String>> ====> java.util.List<java.lang.String>
org.ailun.AInterface<java.lang.Integer> ====> java.lang.Integer
org.ailun.BInterface<java.lang.Long> ====> java.lang.Long
成员变量中的泛型类型
java.util.List<java.lang.Integer> ====> java.lang.Integer
java.util.Map<java.lang.Integer, java.lang.String> ====> java.lang.Integer || java.lang.String
方法参数中的泛型类型
java.util.List<java.lang.String> ====> java.lang.String
方法返回值中的泛型类型
java.util.List<java.lang.Long> ====> java.lang.Long
二、使用侧泛型
使用侧的泛型信息并没有保存
- 方法体中带有泛型参数的局部变量
- 方法调用时传入的变量
获取使用侧的泛型类型信息
上面讲的相关类的获取泛型类型相关方法都只是针对声明侧的泛型。
因为声明侧的泛型被记录在Class文件的Constant pool中以Signature的形式保存。所以Java提供了相关方法能获取到这些信息。
那使用侧的泛型信息怎么获取呢？由于使用侧的泛型信息在编译期的时候就被泛型擦除了，所以运行时是没办法直接获取到这些泛型信息的。
实际上其实还是有办法的。使用侧需要获取泛型信息的地方主要是：方法调用时传入的泛型变量，通常需要在方法中获取变量的泛型类型。比如在JSON解析（反序列化）的场景，它又是怎么实现的呢？
匿名内部类获取使用侧的泛型类型
Gson中的泛型抽象类TypeToken<T>，FastJson中的泛型类TypeReference<T>等就是用的该方案。
匿名内部类是什么？其本质是一个继承/实现了某个类(接口,普通类,抽象类)的子类匿名对象。
匿名内部类实现获取使用侧的泛型类型的原理：
-
定义泛型类，泛型类中有一个
Type类型的字段，用于保存泛型类型的Type -
通过匿名内部类的方式创建该泛型类的子类实例（指定了具体的泛型类型），在创建子类实例的构造方法中，已经通过子类的
Class的getGenericSuperclass()获取到了泛型类型信息并复制给了Type类型的字段中。 -
随后任何地方，只要得到了该子类实例，就可以通过实例得到泛型类型的
Type，这就得到了使用侧的泛型类信息。
简单示例：
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Date;
public class T {
public static <T> T get(TypeReference<T> typeReference) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Type type = typeReference.getType();
Class clazz = (Class) type;
return (T) clazz.getDeclaredConstructor().newInstance();
}
/**
* 测试获取泛型类入口
*/
public static void main(String[] args) throws IllegalAccessException, InstantiationException {
String str = get(new TypeReference<String>() {
});
Date date = get(new TypeReference<Date>() {
});
}
}
abstract class TypeReference<T> {
private final Type type;
public TypeReference() {
Type superClass = getClass().getGenericSuperclass();
if (!(superClass instanceof ParameterizedType)) {
throw new IllegalArgumentException("无泛型类型信息");
}
type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
}
public Type getType() {
return type;
}
}
