简介：TypeParameterResolver是一个工具类，提供一系列的静态方法，去解析类中的字段、方法返回值、方法参数的类型。
在正式介绍TypeParameterResolver之前，先介绍一个JDK提供的接口Type，因为TypeParameterResolver的实现会涉及到它的实现；它是所有类型的父接口，在JDK实现中，Type接口拥有四个接口和一个实现类分别代表不同的数据类型；
分别是：
- 类Class：表示原始类型。Class对象表示JVM的一个类和接口，每个java类在JVM里都是一个Class对象，在程序中可以通过"类名.class","对象.getClass","Class.forName()"获取到，数组也被映射为Class对象，所有元素类型相同且维数相同的数组共享同一个Class对象；
- 接口ParameterizedType：表示的是参数化类型，例如：List<String>、Map<Integer,String>这种带范型的类型；
- 接口TypeVariable：表示的类型变量，用来反映在JVM编译泛型前的信息，例如：List<T>中的T就是类型变量，在编译时需被转换成一个具体的类型后才能被使用。
- 接口GenericArrayType：表示的是数组类型且组成元素是ParameterizedType或TypeVariable。例如：List<String>[]或T[]
- 接口WildcardType：表示的是通配符类型，；例如 ? extends Number 和 ? super Integer 。
Type的实现和子接口源码就不贴出来了，下面会介绍一下上述四个接口的主要方法：
- 接口ParameterizedType：
- Type getRawType( )——返回参数化类型的最外层类型，例如List<String> => List;
- Type[ ] getActualTypeArguments( )——获取参数化类型的类型变量或者实际类型列表，例如Map<Integer,String>的实际类型列表Integer和String。需要注意的是该列表的元素也是Type接口，可能存在多层嵌套的情况；
- Type getOwnerType( )——返回的是类型所属的类型，例如存在A<T>类，其中定义了内部类InnerA<I>，则InnerA<I>的所属类型为A<T>，如果是顶层类型，则返回null；
- 接口TypeVariable：
- Type[ ] getBounds( )——获取类型变量的上边界，如未明确声明上边界则默认为Object，例如：class Test<K extends Person>中K的上边界就是Person；
- D getGenericDecralation( )——获取声明该类型变量的原始类型，例如class Test<K extends Person>中的原始类型就是Test；
- String getName( )——获取在源码中定义是的名字，上例为K;
- 接口GenericArrayType：Type getGenericComponentType( )——返回数组的元素类型
- 接口WildcardType：
- Type[ ] getUpperBounds( )——返回泛型变量的上界；
- Type[ ] getLowerBounds( )——返回泛型变量的下界；
下面正式介绍本篇主角TypeParameterResolver工具类：
如上图：
工具类主要有三个对外开放的方法，分别是
resolveFieldType(解析字段的类型)，resolveReturnType(解析方法返回类型)和resolveParamTypes(解析方法入参的类型)。
三个方法获取到需要解析的类型后，调用resolveType方法进行统一的处理。
resolveType方法根据入参的类型的类别，分别调用resolveTypeVar(类型变量解析)，resolveParameterizedType(参数化类型解析)和resolveGenericArrayType（泛型数组）解析。
public class TypeParameterResolver { /** * srcType：被反射时调用的类型，即被解析的方法或字段是通过那个类型反射出来的 * * declaringClass：定义被解析的方法或字段的class类型，即这个方法/字段是定义在那个class中的 * * example: * * <p> * public interface A<N>{ * public N getVal(); * } * * public interface B extends A<String>{} * </p> * 如上面代码所示，如果通过B接口获取到的getVal方法并对其返回值进行解析，则srcType表示B的类型，declaringClass表示A的类型 */ public static Type resolveFieldType(Field field, Type srcType) { // 获取字段的声明类型 Type fieldType = field.getGenericType(); // 获取字段定义所在的类的Class对象 Class<?> declaringClass = field.getDeclaringClass(); // 调用 resolveType方法进行后续处理 return resolveType(fieldType, srcType, declaringClass); } public static Type resolveReturnType(Method method, Type srcType) { //获取方法的返回类型 Type returnType = method.getGenericReturnType(); //获取方法定义的类的类型 Class<?> declaringClass = method.getDeclaringClass(); // 调用 resolveType方法进行后续处理 return resolveType(returnType, srcType, declaringClass); } public static Type[] resolveParamTypes(Method method, Type srcType) { //获取方法所有参数类型 Type[] paramTypes = method.getGenericParameterTypes(); //获取方法定义的类类型 Class<?> declaringClass = method.getDeclaringClass(); Type[] result = new Type[paramTypes.length]; for (int i = 0; i < paramTypes.length; i++) { // 调用 resolveType方法进行后续处理 result[i] = resolveType(paramTypes[i], srcType, declaringClass); } return result; } private static Type resolveType(Type type, Type srcType, Class<?> declaringClass) { if (type instanceof TypeVariable) { //解析TypeVariable类型 return resolveTypeVar((TypeVariable<?>) type, srcType, declaringClass); } else if (type instanceof ParameterizedType) { //解析ParameterizedType类型 return resolveParameterizedType((ParameterizedType) type, srcType, declaringClass); } else if (type instanceof GenericArrayType) { //解析GenericArrayType类型 return resolveGenericArrayType((GenericArrayType) type, srcType, declaringClass); } else { //如果为普通的Class类型就直接返回 return type; } } private static Type resolveGenericArrayType(GenericArrayType genericArrayType, Type srcType, Class<?> declaringClass) { //去掉一层[]后的泛型类型变量 Type componentType = genericArrayType.getGenericComponentType(); Type resolvedComponentType = null; //根据去掉一维数组后的类型变量，再根据其类型递归解析 if (componentType instanceof TypeVariable) { //如果去掉后为TypeVariable类型，则调用resolveTypeVar方法 resolvedComponentType = resolveTypeVar((TypeVariable<?>) componentType, srcType, declaringClass); } else if (componentType instanceof GenericArrayType) { //如果去掉仍为GenericArrayType类型，则递归调用resolveGenericArrayType方法 resolvedComponentType = resolveGenericArrayType((GenericArrayType) componentType, srcType, declaringClass); } else if (componentType instanceof ParameterizedType) { //如果去掉后为ParameterizedType类型，则调用resolveParameterizedType方法处理 resolvedComponentType = resolveParameterizedType((ParameterizedType) componentType, srcType, declaringClass); } if (resolvedComponentType instanceof Class) { //如果处理后的结果为基本的Class类型，则返回对应的Class的数组类型（处理N[][]）。 return Array.newInstance((Class<?>) resolvedComponentType, 0).getClass(); } else { //否则包装为自定义的GenericArrayTypeImpl类型 return new GenericArrayTypeImpl(resolvedComponentType); } } private static ParameterizedType resolveParameterizedType(ParameterizedType parameterizedType, Type srcType, Class<?> declaringClass) { //获取泛型的基本类型 Class<?> rawType = (Class<?>) parameterizedType.getRawType(); //获取泛型中的类型实参 Type[] typeArgs = parameterizedType.getActualTypeArguments(); //递归处理其类型实参 Type[] args = new Type[typeArgs.length]; //判断对应参数的类型，分别进行递归处理 for (int i = 0; i < typeArgs.length; i++) { if (typeArgs[i] instanceof TypeVariable) { //解析TypeVariable类型 args[i] = resolveTypeVar((TypeVariable<?>) typeArgs[i], srcType, declaringClass); } else if (typeArgs[i] instanceof ParameterizedType) { //解析ParameterizedType类型 args[i] = resolveParameterizedType((ParameterizedType) typeArgs[i], srcType, declaringClass); } else if (typeArgs[i] instanceof WildcardType) { //是解析WildcardType类型（其类型实参是通配符表达式） args[i] = resolveWildcardType((WildcardType) typeArgs[i], srcType, declaringClass); } else { //普通Class类型，直接返回 args[i] = typeArgs[i]; } } //返回自定以类型 return new ParameterizedTypeImpl(rawType, null, args); } /** * 在对通配符进行解析时，主要对其上下限的类型进行解析 */ private static Type resolveWildcardType(WildcardType wildcardType, Type srcType, Class<?> declaringClass) { //获取下限 Type[] lowerBounds = resolveWildcardTypeBounds(wildcardType.getLowerBounds(), srcType, declaringClass); //获取上限 Type[] upperBounds = resolveWildcardTypeBounds(wildcardType.getUpperBounds(), srcType, declaringClass); //包装成自定义的WildcardTypeImpl类型返回 return new WildcardTypeImpl(lowerBounds, upperBounds); } private static Type[] resolveWildcardTypeBounds(Type[] bounds, Type srcType, Class<?> declaringClass) { Type[] result = new Type[bounds.length]; for (int i = 0; i < bounds.length; i++) { //根据上下限不同的类型，进行解析 if (bounds[i] instanceof TypeVariable) { result[i] = resolveTypeVar((TypeVariable<?>) bounds[i], srcType, declaringClass); } else if (bounds[i] instanceof ParameterizedType) { result[i] = resolveParameterizedType((ParameterizedType) bounds[i], srcType, declaringClass); } else if (bounds[i] instanceof WildcardType) { result[i] = resolveWildcardType((WildcardType) bounds[i], srcType, declaringClass); } else { result[i] = bounds[i]; } } return result; } /** * 解析具体的类型变量指代的类型。 * 1.如果srcType的Class类型和declaringClass为同一个类，表示获取该类型变量时被反射的类型就是其定义的类型， * 则取该类型变量定义是有没有上限，如果有则使用其上限代表其类型，否则就用Object。 * * 2.如果不是，则代表declaringClass是srcType的父类或者实现的接口，则解析继承中有没有定义其代表的类型 */ private static Type resolveTypeVar(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass) { Type result = null; Class<?> clazz = null; /** * 判断srcType是否为Class/ParameterizedType类型 * 如果不是这两种类型这抛出异常 */ if (srcType instanceof Class) { clazz = (Class<?>) srcType; } else if (srcType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) srcType; clazz = (Class<?>) parameterizedType.getRawType(); } else { throw new IllegalArgumentException("The 2nd arg must be Class or ParameterizedType, but was: " + srcType.getClass()); } /** * 如果declaringClass和srcType的实际类型相等则表示无法获取其类型实参。 * 如果typeVar有上限限定则返回其上限，否则返回Object处理 */ if (clazz == declaringClass) { Type[] bounds = typeVar.getBounds(); if (bounds.length > 0) { return bounds[0]; } return Object.class; } Type superclass = clazz.getGenericSuperclass(); result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superclass); if (result != null) { return result; } /** * 如果父类的定义中没有，则处理其实现的接口。 */ Type[] superInterfaces = clazz.getGenericInterfaces(); for (Type superInterface : superInterfaces) { result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superInterface); if (result != null) { return result; } } //如果父类或者实现的接口中都没有获取到形参对应的实参，则返回Object.class return Object.class; } /** * 通过对父类/接口的扫描获取其typeVar指代的实际类型 */ private static Type scanSuperTypes(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass, Class<?> clazz, Type superclass) { Type result = null; /** * 判断处理的父类superclass是否为参数化类型，如果不是则代表declaringClass和superclass的基本Class * 类型不是同一个类。 */ if (superclass instanceof ParameterizedType) { //如果为ParameterizedType，则获取它基本类型 ParameterizedType parentAsType = (ParameterizedType) superclass; Class<?> parentAsClass = (Class<?>) parentAsType.getRawType(); if (declaringClass == parentAsClass) { //如果declaringClass和parentAsClass表示同一类型，则通过typeVar在declaringClass的泛型形参的index获取其在supperClass中定义的类型实参 Type[] typeArgs = parentAsType.getActualTypeArguments(); TypeVariable<?>[] declaredTypeVars = declaringClass.getTypeParameters(); for (int i = 0; i < declaredTypeVars.length; i++) { //循环判断当前处理的类型是否属于所属的类型描述符中的变量 if (declaredTypeVars[i] == typeVar) { /** * 如果supperClass中定义的类型形参还是类型变量则取srcType中的类型形参的定义 * 如果srcType中的类型形参还是类型变量则不处理。 */ if (typeArgs[i] instanceof TypeVariable) { //其子类中的所有泛型描述符 TypeVariable<?>[] typeParams = clazz.getTypeParameters(); for (int j = 0; j < typeParams.length; j++) { if (typeParams[j] == typeArgs[i]) { //判断是否为ParameterizedType，则去实际代表的类型 if (srcType instanceof ParameterizedType) { result = ((ParameterizedType) srcType).getActualTypeArguments()[j]; } break; } } } else { //如果不是TypeVariable，直接取对应的类型 result = typeArgs[i]; } } } } else if (declaringClass.isAssignableFrom(parentAsClass)) { //通过判断superclass是否是declaringClass的子类（由于java类可以实现多个接口），进行递归解析 result = resolveTypeVar(typeVar, parentAsType, declaringClass); } } else if (superclass instanceof Class) { //如果superclass为Class类型，通过判断superclass是否是declaringClass的子类（由于java类可以实现多个接口），进行递归解析 if (declaringClass.isAssignableFrom((Class<?>) superclass)) { result = resolveTypeVar(typeVar, superclass, declaringClass); } } return result; } private TypeParameterResolver() { super(); } static class ParameterizedTypeImpl implements ParameterizedType { private Class<?> rawType; private Type ownerType; private Type[] actualTypeArguments; public ParameterizedTypeImpl(Class<?> rawType, Type ownerType, Type[] actualTypeArguments) { super(); this.rawType = rawType; this.ownerType = ownerType; this.actualTypeArguments = actualTypeArguments; } @Override public Type[] getActualTypeArguments() { return actualTypeArguments; } @Override public Type getOwnerType() { return ownerType; } @Override public Type getRawType() { return rawType; } @Override public String toString() { return "ParameterizedTypeImpl [rawType=" + rawType + ", ownerType=" + ownerType + ", actualTypeArguments=" + Arrays.toString(actualTypeArguments) + "]"; } } static class WildcardTypeImpl implements WildcardType { private Type[] lowerBounds; private Type[] upperBounds; private WildcardTypeImpl(Type[] lowerBounds, Type[] upperBounds) { super(); this.lowerBounds = lowerBounds; this.upperBounds = upperBounds; } @Override public Type[] getLowerBounds() { return lowerBounds; } @Override public Type[] getUpperBounds() { return upperBounds; } } static class GenericArrayTypeImpl implements GenericArrayType { private Type genericComponentType; private GenericArrayTypeImpl(Type genericComponentType) { super(); this.genericComponentType = genericComponentType; } @Override public Type getGenericComponentType() { return genericComponentType; } } }