在工作中，我们时常需要使用泛型，最主要目的其实还是在于对公共逻辑的提取，以最大限度减少重复代码带来的复杂性和难以维护性。在一文读懂java泛型机制中对泛型做了基本概念的介绍，以及基础的使用。今天这篇文章主要是通过反射的方式获取泛型信息。
1. 反射
在java类型编译后的类信息都存放在Class对象中，在Class中包含了字段Field, 方法Method等定义原始信息，例如：
public class ClassTest {
public static void main(String[] args) {
Class<String> clazz = String.class;
System.out.println(clazz.getName());
String[] arr = {};
Class<? extends String[]> arrClazz = arr.getClass();
System.out.println(arrClazz.getName());
}
}
执行以上代码，可以得到以下输出结果：
java.lang.String [Ljava.lang.String;
Class对象本身也是泛型类型，我们看到获取到的Class对象带有泛型标识，同样通过泛型限制了Class中存储的部分数据类型。获取class对象有两种方式:
- 根据类型调用.class可以获取到当前类型的Class对象
- 根据实例对象调用.getClass()方法，获取Class对象
当我们获取到了Class对象之后，就可以通过Class对象操作Field， Method等信息，并获取字段Field的值和执行Method方法，这里就不做演示，有兴趣可以搜集下反射相关资料。
2. 反射泛型
在一文读懂java泛型机制 一文中，谈到泛型包含了泛型类，泛型方法，泛型接口三种类型，因此我们就这三种类型泛型分别展开讨论，看如何通过泛型的方式获取实际的类型。
在反射中，最顶层的类型为Type, Type下又分为不同的实现类型，具体的结构体系如下：
每个类型的使用，会在后面的讲解中涉及到并讲解，因此每个类型的单独使用就不做介绍。
2.1 泛型类
定义一个泛型类型，代码如下：
public class GenericType<T>{
private T value;
public GenericType(T value) {
this.value = value;
}
public GenericType() {}
public T getValue() {
return this.value;
}
public void setValue(T t) {
this.value = t;
}
}
我们对以上类型做测试，通过反射的方式查看获取到的泛型内容:
public class GenericTypeTest {
public static void main(String[] args) throws NoSuchFieldException {
Class<GenericType> genericTypeClass = GenericType.class;
System.out.println(genericTypeClass);
Type type = genericTypeClass.getGenericSuperclass();
System.out.println(type); // Object
GenericType<Integer> genericType = new GenericType<>();
Class<? extends GenericType> aClass = genericType.getClass();
type = aClass.getGenericSuperclass();
System.out.println(type); // Object
}
}
对应输出结果如下：
class java.lang.Object class java.lang.Object
在上面的测试中，我们使用了getGenericSuperclass()获取泛型的超类，GenericType本身并没有集成或者实现其他类型，因此我们获取到的始终都是Object类型，这个时候我们就不能通过这种方式获取泛型信息，而是要使用getTypeParameters()方法获取类型上的泛型信息，测试代码如下:
// 获取参数化类型
TypeVariable<? extends Class<? extends GenericType>>[] typeParameters = aClass.getTypeParameters();
for (int i = 0; i < typeParameters.length; i++) {
TypeVariable<? extends Class<? extends GenericType>> typeParameter = typeParameters[i];
System.out.println("typeName: " + typeParameter.getTypeName());
System.out.println("name: " + typeParameter.getName());
System.out.println("bounds: " + typeParameter.getBounds());
System.out.println("genericDeclaration: " + typeParameter.getGenericDeclaration());
System.out.println("annotatedBounds: " + typeParameter.getAnnotatedBounds());
}
执行以上代码，我们得到如下输出结果：
typeName: T name: T bounds: [Ljava.lang.reflect.Type;@1b6d3586 genericDeclaration: class com.java.demo.generic.GenericType annotatedBounds: [Ljava.lang.reflect.AnnotatedType;@74a14482
因此这里我们遇到了第一个TypeVariable类型的实现，这个类型中记录了泛型定义的原始信息，包括泛型的边界、泛型标识符、泛型声明的类型等。
这里对TypeVariable类型中的主要方法做一个晓得总结:
- getTypeName()获取泛型标识的名称
- getName()等同于getTypeName()方法
- getBounds()获取泛型边界信息，如果没有明确声明上边界，默认为Object. 因为下边界最终也是Object
- getGenericDeclaration()获取泛型声明类型
- getAnnotatedBounds()该方法从1.8版本时候加入，用于获取注解类型的上界，如果没有明确声明上边界，默认为长度为0的数组
这里也许会有个疑问，在第二GenericType使用的时候，明确的声明了泛型类型为Type, 为什么最终还是获取不到Integer的泛型参数类型？
这主要是因为泛型擦除，当我们实际在使用的时候指定泛型，在类型上使用泛型其实并不是一个新的类型，而是通过checkcast指令判断对应的值是否与泛型类型保持一致，因此以上的示例中通过泛型获取到的信息始终是Object类型的主要原因
继续探讨泛型类，我们为GenericType增加一个实现类，并明确指定泛型类型， 具体代码如下：
public class SubGenericType extends GenericType<Integer> {
}
对SubGenericType进行测试，测试代码如下：
public class SubGenericTypeTest {
public static void main(String[] args) throws NoSuchFieldException {
Class<SubGenericType> typeClass = SubGenericType.class;
Type type = typeClass.getGenericSuperclass();
System.out.println("isParameterizeType:" + (type instanceof ParameterizedType));
System.out.println("type:" + type);
if (type instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) type;
System.out.println("rawType: " + parameterizedType.getRawType());
Type[] actualParameters = parameterizedType.getActualTypeArguments();
for (int i = 0; i < actualParameters.length; i++) {
Type actualType = actualParameters[i];
System.out.println("generic actualType:" + actualType);
}
System.out.println("getRawType:" + parameterizedType.getRawType());
System.out.println("getOwnerType:" + parameterizedType.getOwnerType());
Field value = ((Class<GenericType>) parameterizedType.getRawType()).getDeclaredField("value");
System.out.println("Field.getType:" + value.getType());
System.out.println("Field.getGenericType:" + value.getGenericType().getClass());
}
SubGenericType subGenericType = new SubGenericType();
subGenericType.setValue(23); // setValue(Integer)
Integer value = subGenericType.getValue(); // Integer
System.out.println("value:" + value);
}
}
以上代码执行结果输出如下：
isParameterizeType:true type:com.java.demo.generic.GenericType<java.lang.Integer> rawType: class com.java.demo.generic.GenericType generic actualType:class java.lang.Integer getRawType:class com.java.demo.generic.GenericType getOwnerType:null Field.getType:class java.lang.Object Field.getGenericType:class sun.reflect.generics.reflectiveObjects.TypeVariableImpl value:23
我们通过类继承并指定泛型具体类型，通过getGenericSuperClass()方法获取到了ParameterizeType的类型，ParameterizeType的方法介绍如下：
- getRawType()用于获取泛型定义的原始这类型，这里就是GenericType. 从ParameterizeType源码上来看，这里返回的一定是一个Class对象
- getOwnerType()从源码来看，getOwnerType()实际上等同于Class.getDeclaringClass(), 这里返回的是null
- getAcutalArguments()用于获取ParameterizeType中泛型的实际类型，在上面的例子中，我们获取到的是Integer类型
通过上面两个例子，我们基本上可以看到ParameterizeType和TypeVariable之间的一个区别：
- 当泛型被真正指定为具体的类型的时候，返回的是ParameterizeType类型，这个时候可以通过该类型获取到真正的泛型类型
- 当我们需要获取泛型定义、泛型边界信息时，则使用TypeVariable, 其中包含了详细的泛型信息
细心的小伙伴留意到了上面示例的最后几行代码，我们在定义的时候，实际上是没有重写父类GenericType中的方法，但是我们实际使用的时候，却能够直接调用setValue(Integer)这样的方法，我们反编译SubGenericeType类查看：
在反编译.class文件发现，也没有生成对应的桥接方法或者setValue(Integer)方法，那为什么可以直接调用setValue(Integer)方法呢?
我们反编译测试类的SubGenericTypeTest.class文件，对应的反编译信息如下：
我们从反编译中可以看出：
- setValue()的时候，最终还是调用的SubGenericType#setValue(Object)方法，这个方法在调用的时候并不会报错，因为Integer本身就是Object的子类，这个本身是没有问题的。
- getValue()也是使用的SubGenericeType#getValue(Object)方法，只是使用了checkcast类型转换的指令，以达到泛型类型验证的目的。
也许又有小伙伴有疑问，既然调用setValue(Object)方法，我可以设置setValue(“123”), 这个层面主要从编译器控制，保证传入的数据类型必须为Integer, 因此会导致编译错误。
2.2 泛型接口
泛型接口其实和泛型类型相似，他们定义和使用的方式很多也是相同的。我们定义以下泛型接口：
public interface GenericInterface<T> {
T getVal();
void setVal(T val);
}
并定义以下两个实现类:
public class GenericInterfaceImpl implements GenericInterface<Integer> {
private Integer val;
@Override
public Integer getVal() {
return null;
}
@Override
public void setVal(Integer val) {
}
public static void main(String[] args) {
GenericInterface<String> genericInterface = new GenericInterfaceImpl2<>();
}
}
class GenericInterfaceImpl2<T> implements GenericInterface<T> {
private T val;
@Override
public T getVal() {
return null;
}
@Override
public void setVal(T val) {
this.val = val;
}
}
以上两个实现类，和我们泛型类的定义相似，GenericInterfaceImpl2这个本身也是一个泛型，并且将泛型传递给了GenericInterface接口，而GenericInterfaceImpl给出了实际的泛型Integer. 这里我们就不着重讲，直接对他们进行测试，并获取泛型的实际类型。
则对应的测试类如下：
public class GenericInterfaceTest {
public static void main(String[] args) {
Class<GenericInterface> genericInterfaceClass = GenericInterface.class;
System.out.println("GenericInterface genericSuperClass: " + genericInterfaceClass.getGenericSuperclass()); // null
TypeVariable<Class<GenericInterface>>[] typeParameters = genericInterfaceClass.getTypeParameters();
for (int i = 0; i < typeParameters.length; i++) {
TypeVariable<Class<GenericInterface>> typeParameter = typeParameters[i];
System.out.println("GenericInterface TypeVariable:" + typeParameter.getName()); // T
}
Class<GenericInterfaceImpl2> impl2Class = GenericInterfaceImpl2.class;
Type[] genericSuperclass = impl2Class.getGenericInterfaces();
for (Type superclass : genericSuperclass) {
System.out.println("GenericInterfaceImpl2 type: " + superclass.getClass()); // ParameterizeType
if (superclass instanceof ParameterizedType) {
ParameterizedType type = (ParameterizedType) superclass;
Type[] actualTypeArguments = type.getActualTypeArguments();
Arrays.stream(actualTypeArguments)
.forEach(argument -> {
System.out.println("GenericInterfaceImpl2 actual type: " + argument.getTypeName());
System.out.println("GenericInterfaceImpl2 actual type class: " + argument.getClass());
});
}
}
Class<GenericInterfaceImpl> genericInterfaceClass1 = GenericInterfaceImpl.class;
genericSuperclass = genericInterfaceClass1.getGenericInterfaces();
for (Type superclass : genericSuperclass) {
System.out.println("GenericInterfaceImpl type: " + superclass.getClass()); // ParameterizeType
if (superclass instanceof ParameterizedType) {
ParameterizedType type = (ParameterizedType) superclass;
Type[] actualTypeArguments = type.getActualTypeArguments();
Arrays.stream(actualTypeArguments)
.forEach(argument -> {
System.out.println("GenericInterfaceImpl actual type: " + argument.getTypeName());
System.out.println("GenericInterfaceImpl actual type class: " + argument.getClass());
});
}
}
}
}
则对应的输出结果如下:
GenericInterface genericSuperClass: null GenericInterface TypeVariable:T GenericInterfaceImpl2 type: class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl GenericInterfaceImpl2 actual type: T GenericInterfaceImpl2 actual type class: class sun.reflect.generics.reflectiveObjects.TypeVariableImpl GenericInterfaceImpl type: class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl GenericInterfaceImpl actual type: java.lang.Integer GenericInterfaceImpl actual type class: class java.lang.Class
这里其实和泛型类展现保持一致，因此这里就不做过多的阐述。在上面接口定义中，我们定义了两个泛型方法，在GenericInterfaceImpl 中，因为明确指定了泛型的类型，因此在实现方法的时候，会将参数以及返回值替换成为具体的类型，这种方式本身是重写接口中的方法，并且会生成桥接方法，我们可以验证一下：
Method method = genericInterfaceClass1.getMethod("setVal", Object.class);
System.out.println("isBridge: " + method.isBridge());
则对应输出结果如下：
isBridge: true
2.3 泛型方法
泛型方法主要包含了两种：
- 泛型信息记录在对应方法上
- 泛型类中的实例泛型方法
还是以上面泛型接口中的两个类作为实例，查看实例中的泛型方法。实例方法中的泛型方法，泛型定义会随着实力的不同实现而有所不同。首先我们提取公共的方法，用于对方法的泛型化参数进行提取和处理：
/**
* 输出泛型方法
*
* @param clazz 类型
* @param method 方法
* @param params 形参
*/
public static final void printGenericMethod(Class<?> clazz, String method, Class... params) {
try {
System.out.println("-----------------" + clazz.getName() + "#" + method + "--------------------------");
Method targetMethod = clazz.getMethod(method, params);
// 获取泛型参数
System.out.println("method parameter start ++++++++++++++++++++++++");
Type[] genericParameterTypes = targetMethod.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
System.out.println("type name: " + genericParameterType.getTypeName());
System.out.println("type class:" + genericParameterType.getClass().getName());
if (genericParameterType instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) genericParameterType;
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
if (actualTypeArgument instanceof WildcardType) {
WildcardType wildcardType = (WildcardType) actualTypeArgument;
Type[] lowerBounds = wildcardType.getLowerBounds();
if (Objects.nonNull(lowerBounds)) {
for (Type lowerBound : lowerBounds) {
System.out.println("wildcard type lower bound: " + lowerBound.getTypeName());
}
}
Type[] upperBounds = wildcardType.getUpperBounds();
if (Objects.nonNull(upperBounds)) {
for (Type upperBound : upperBounds) {
System.out.println("wildcard type upper bound: " + upperBound.getTypeName());
}
}
} else {
System.out.println("ParameterizedType actual type: " + actualTypeArgument.getTypeName());
}
}
} else if (genericParameterType instanceof TypeVariable) {
TypeVariable typeVariable = (TypeVariable) genericParameterType;
Type[] bounds = typeVariable.getBounds();
if (Objects.nonNull(bounds)) {
for (Type bound : bounds) {
System.out.println("TypeVariable bounds:" + bound.getTypeName());
}
}
} else {
System.out.println("other type:" + genericParameterType.getClass().getName());
}
}
System.out.println("method parameter end ++++++++++++++++++++++++");
System.out.println("Method return type start+++++++++++++++++++");
Type genericReturnType = targetMethod.getGenericReturnType();
if (genericReturnType instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) genericReturnType;
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
if (actualTypeArgument instanceof WildcardType) {
WildcardType wildcardType = (WildcardType) actualTypeArgument;
Type[] lowerBounds = wildcardType.getLowerBounds();
if (Objects.nonNull(lowerBounds)) {
for (Type lowerBound : lowerBounds) {
System.out.println("wildcard return type lower bound: " + lowerBound.getTypeName());
}
}
Type[] upperBounds = wildcardType.getUpperBounds();
if (Objects.nonNull(upperBounds)) {
for (Type upperBound : upperBounds) {
System.out.println("wildcard return type upper bound: " + upperBound.getTypeName());
}
}
} else {
System.out.println("ParameterizedType return actual type: " + actualTypeArgument.getTypeName());
}
}
} else if (genericReturnType instanceof TypeVariable) {
TypeVariable typeVariable = (TypeVariable) genericReturnType;
Type[] bounds = typeVariable.getBounds();
if (Objects.nonNull(bounds)) {
for (Type bound : bounds) {
System.out.println("TypeVariable return bounds:" + bound.getTypeName());
}
}
} else {
System.out.println("other type:" + genericReturnType.getClass().getName());
}
System.out.println("Method return type end+++++++++++++++++++");
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
}
这样就能够方便我们对泛型化方法进行处理，测试代码如下：
public static void main(String[] args) throws NoSuchMethodException {
Class<GenericInterface> genericInterfaceClass = GenericInterface.class;
// 获取setVal方法
printGenericMethod(genericInterfaceClass, "getVal");
printGenericMethod(genericInterfaceClass, "setVal", Object.class);
System.out.println("==========================================================");
Class<GenericInterfaceImpl2> impl2Class = GenericInterfaceImpl2.class;
// 获取setVal方法
printGenericMethod(impl2Class, "getVal");
printGenericMethod(impl2Class, "setVal", Object.class);
System.out.println("==========================================================");
Class<GenericInterfaceImpl> genericInterfaceClass1 = GenericInterfaceImpl.class;
// 获取setVal方法
printGenericMethod(genericInterfaceClass1, "getVal");
printGenericMethod(genericInterfaceClass1, "setVal", Integer.class);
}
输出结果如下：
-----------------com.java.demo.generic.GenericInterface#getVal-------------------------- method parameter start ++++++++++++++++++++++++ method parameter end ++++++++++++++++++++++++ Method return type start+++++++++++++++++++ TypeVariable return bounds:java.lang.Object Method return type end+++++++++++++++++++ -----------------com.java.demo.generic.GenericInterface#setVal-------------------------- method parameter start ++++++++++++++++++++++++ type name: T type class:sun.reflect.generics.reflectiveObjects.TypeVariableImpl TypeVariable bounds:java.lang.Object method parameter end ++++++++++++++++++++++++ Method return type start+++++++++++++++++++ other type:java.lang.Class Method return type end+++++++++++++++++++ ========================================================== -----------------com.java.demo.generic.GenericInterfaceImpl2#getVal-------------------------- method parameter start ++++++++++++++++++++++++ method parameter end ++++++++++++++++++++++++ Method return type start+++++++++++++++++++ TypeVariable return bounds:java.lang.Object Method return type end+++++++++++++++++++ -----------------com.java.demo.generic.GenericInterfaceImpl2#setVal-------------------------- method parameter start ++++++++++++++++++++++++ type name: T type class:sun.reflect.generics.reflectiveObjects.TypeVariableImpl TypeVariable bounds:java.lang.Object method parameter end ++++++++++++++++++++++++ Method return type start+++++++++++++++++++ other type:java.lang.Class Method return type end+++++++++++++++++++ ========================================================== -----------------com.java.demo.generic.GenericInterfaceImpl#getVal-------------------------- method parameter start ++++++++++++++++++++++++ method parameter end ++++++++++++++++++++++++ Method return type start+++++++++++++++++++ other type:java.lang.Class Method return type end+++++++++++++++++++ -----------------com.java.demo.generic.GenericInterfaceImpl#setVal-------------------------- method parameter start ++++++++++++++++++++++++ type name: java.lang.Integer type class:java.lang.Class other type:java.lang.Class method parameter end ++++++++++++++++++++++++ Method return type start+++++++++++++++++++ other type:java.lang.Class Method return type end+++++++++++++++++++
对于方法的解析，基本原则也是和泛型类保持一致，明确有参数返回的时候，返回的是ParameterizedType类型，返回的是一个泛型标识的时候，则采用的是TypeVariable对象。这两个类的使用在泛型类中已经介绍的很清楚了，这里就不介绍了。
接下来我们主要看下WildcardType类型的使用，我们在GenericInterfaceImpl2中定义如下方法：
public Class<? extends Integer> transfer(Class<? super Integer> clazz) {
return null;
}
这个方法本身没有实质性的意义，只是为了说明WildcardType的使用，
我们还是通过上面的方法，测试获取到的泛型信息：
printGenericMethod(impl2Class, "transfer", Class.class);
对应的输出结果如下：
-----------------com.java.demo.generic.GenericInterfaceImpl2#transfer-------------------------- method parameter start ++++++++++++++++++++++++ type name: java.lang.Class<? super java.lang.Integer> type class:sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl wildcard type lower bound: java.lang.Integer wildcard type upper bound: java.lang.Object method parameter end ++++++++++++++++++++++++ Method return type start+++++++++++++++++++ wildcard return type upper bound: java.lang.Integer Method return type end+++++++++++++++++++
首先输出的是泛型化参数，泛型化参数定义我们使用的是<? super Integer>, 那么能够传入Integer, Number, Object的对象，当我们在解析上边界的时候，实际上解析成了两个：
- 下边界为Integer
- 上边界为Object
这个和我们分析上边界时，保持是一致的。
在解析返回泛型化参数的时候，返回结果定义为上边界，因此能够传入Integer以及Integer子类（这里不太恰当，Integer本身定义为final, 不会产生子类, 所以这里只能返回Integer）。所以在解析为上边界的时候，组中被解析为Integer.
2.4 GenericArrayType
另外一个泛型类型为GenericArrayType, 这里主要描述的是泛型的数组类型，下面我们通过测试代码测试一下：
public class GenericArrayTypeTest {
public static void main(String[] args) {
Class<GenericArrayTypeTest> clazz = GenericArrayTypeTest.class;
Method[] methods = clazz.getMethods();
for (Method method : methods) {
if ("method".equals(method.getName())) {
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
if (genericParameterType instanceof GenericArrayType) {
System.out.println("GenericArrayType ----> " + genericParameterType + "; genericComponentType ----> " + ((GenericArrayType) genericParameterType).getGenericComponentType());
} else {
System.out.println("Not GenericArrayType ----> " + genericParameterType);
}
}
}
}
}
public static <T> void method(String[] strings, List<String> ls, List<String>[] lsa, T[] ts, List<T>[] tla, T[][] tts) {
}
}
通过上面的测试可以得到一下结论：
- 该类只是针对泛型数组，集合类型并不能解析为GenericArrayType
- 对于二位数组，最终解析的类型为T[]
Not GenericArrayType ----> class [Ljava.lang.String; Not GenericArrayType ----> java.util.List<java.lang.String> GenericArrayType ----> java.util.List<java.lang.String>[]; genericComponentType ----> java.util.List<java.lang.String> GenericArrayType ----> T[]; genericComponentType ----> T GenericArrayType ----> java.util.List<T>[]; genericComponentType ----> java.util.List<T> GenericArrayType ----> T[][]; genericComponentType ----> T[]
参考文章
https://www.cnblogs.com/throwable/p/12315988.html
以上就是关于泛型的反射解析全部内容，如果有任何问题，欢迎留言区评论。
