转载

Mybatis技术内幕（2.3.7）：反射模块-TypeParameterResolver

为什么要单独拿一篇文章来讲呢？因为里面涉及到的java-Type接口的内容之前没有接触和了解过。我相信在座的很多小伙伴也一定不知道其中的奥秘哦~

你知道Class对象还有一个父接口吗？

以下内容均摘录自 徐郡明《Mybatis技术内幕》

先简单介绍一下Type接口的基础知识。Type是所有类型的父接口，它有四个子接口和一个实现类，如下图：

Mybatis技术内幕（2.3.7）：反射模块-TypeParameterResolver

下面来看这些子接口和子类所代表的类型

Class 比较常见，它表示的是原始类型。Class类的对象表示JVM中的一个类或者接口，每个java类在JVM里都表现为一个Class对象。在程序中可以通过“类型.class”、“对象.getClas()”或是“Class.forName("类名")”等方法获取Class对象。数组也被映射为Class对象，所有元素相同且维数相同的数组都共享同一个Class对象。
ParameterizedType 表示的是参数化类型，例如List<String>、Map<Integer，String>、Service<User>这种带有泛型的类型。ParameterizedType接口中常用的方法有三个，分别是：
- Type getRawType()——返回参数化类型中的原始类型。例如List<String>的原始类型为List
- Type[] getActualTypeArguments()——获取参数化类型的类型变量或是实际类型列表。例如Map<Integer，String>的实际泛型列表Integer和String。需要注意的是，该列表的类型都是Type，也就是说，可能存在多层嵌套的情况。
- Type getOwnerType()——返回的是类型所属的类型，例如存在A<T>类，其中定义了内部类InnerA<T>,则Inner<A>所属的类型A<T>，如果是顶层类型则返回null。这种关系比较常见的示例是Map<K,V>接口与Map.Entry<K,V>接口，Map<K,V>接口是Map.Entry<K,V>接口的所有者
TypeVariable 表示的是类型变量，它用来反映在JVM编译该泛型前的信息。例如List<T>中T就是类型变量，它在编译是需被转换为一个具体的类型后才能正常使用。
- Type[] getBounds()——获取类型变量的上边界，如果未明确声明上边界则默认为Object。例如class Test<K extends Person>中K的上界就是Person。
- D getGenericDeclaration()——获取声明该类型变量的原始类型，例如class Test<K extends Person>中的原始类型是Test。
- String getName()——获取在源码中定义时的名字，上例中为K。
GenericArrayType 表示的是数组类型且组成的元素是ParameterizedType或TypeVariable。例如List<String>[]或T[]。该接口只有Type getGenericComponentType()一个方法，它返回数组的组成元素。
WildcardType 表示通配符泛型，例如? extends Number和? super Integer。
- Type[] getUpperBounds()破折号泛型变量的上界。
- Type[] getLowerBounds()破折号泛型变量的下界。

1.0 TypeParameterResolver

org.apache.ibatis.reflection.TypeParameterResolver 是一个主要用来负责解析字段类型、方法返回值类型和方法参数列表中各个参数的类型的一个工具类。代码如下：

/**
 * 暴露了三个公用静态方法，分别用于解析Field类型、Method返回类型、方法参数类型
 * @author Iwao AVE!
 */
public class TypeParameterResolver {

	/**
	 * 解析属性类型
	 * @return The field type as {@link Type}. If it has type parameters in the
	 *         declaration,<br>
	 *         they will be resolved to the actual runtime {@link Type}s.
	 */
	public static Type resolveFieldType(Field field, Type srcType) {
		// 属性类型
		Type fieldType = field.getGenericType();
		// 定义的类
		Class<?> declaringClass = field.getDeclaringClass();
		// 解析类型
		return resolveType(fieldType, srcType, declaringClass);
	}

	/**
	 * 解析方法返回值类型
	 * @return The return type of the method as {@link Type}. If it has type
	 *         parameters in the declaration,<br>
	 *         they will be resolved to the actual runtime {@link Type}s.
	 */
	public static Type resolveReturnType(Method method, Type srcType) {
		// 返回值类型
		Type returnType = method.getGenericReturnType();
		// 定义的类
		Class<?> declaringClass = method.getDeclaringClass();
		// 解析类型
		return resolveType(returnType, srcType, declaringClass);
	}

	/**
	 * 解析方法参数类型
	 * @return The parameter types of the method as an array of {@link Type}s. If
	 *         they have type parameters in the declaration,<br>
	 *         they will be resolved to the actual runtime {@link Type}s.
	 */
	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++) {
			// 解析类型
			result[i] = resolveType(paramTypes[i], srcType, declaringClass);
		}
		return result;
	}

	/**
	 * 解析类型
	 * @param type           类型
	 * @param srcType        来源类型
	 * @param declaringClass 定义的类
	 * @return 解析后的类型
	 */
	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 {
			return type;// Class类型直接返回
		}
	}

	private static Type resolveGenericArrayType(GenericArrayType genericArrayType, Type srcType,
			Class<?> declaringClass) {
		Type componentType = genericArrayType.getGenericComponentType();
		Type resolvedComponentType = null;
		if (componentType instanceof TypeVariable) {
			resolvedComponentType = resolveTypeVar((TypeVariable<?>) componentType, srcType, declaringClass);
		} else if (componentType instanceof GenericArrayType) {
			resolvedComponentType = resolveGenericArrayType((GenericArrayType) componentType, srcType, declaringClass);
		} else if (componentType instanceof ParameterizedType) {
			resolvedComponentType = resolveParameterizedType((ParameterizedType) componentType, srcType,
					declaringClass);
		}
		if (resolvedComponentType instanceof Class) {
			return Array.newInstance((Class<?>) resolvedComponentType, 0).getClass();
		} else {
			return new GenericArrayTypeImpl(resolvedComponentType);
		}
	}

	/**
	 * 解析 ParameterizedType 类型
	 * @param parameterizedType ParameterizedType 类型
	 * @param srcType           来源类型
	 * @param declaringClass    定义的类
	 * @return 解析后的类型
	 */
	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) {
				args[i] = resolveTypeVar((TypeVariable<?>) typeArgs[i], srcType, declaringClass);
			} else if (typeArgs[i] instanceof ParameterizedType) {
				args[i] = resolveParameterizedType((ParameterizedType) typeArgs[i], srcType, declaringClass);
			} else if (typeArgs[i] instanceof WildcardType) {
				args[i] = resolveWildcardType((WildcardType) typeArgs[i], srcType, declaringClass);
			} else {
				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);
		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;
	}

	/**
	 * 解析TypeVariable类型
	 * @param typeVar
	 * @param srcType
	 * @param declaringClass
	 * @return
	 */
	private static Type resolveTypeVar(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass) {
		Type result = null;
		Class<?> clazz = null;
		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());
		}

		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;
			}
		}
		return Object.class;
	}

	private static Type scanSuperTypes(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass, Class<?> clazz,
			Type superclass) {
		if (superclass instanceof ParameterizedType) {
			ParameterizedType parentAsType = (ParameterizedType) superclass;
			Class<?> parentAsClass = (Class<?>) parentAsType.getRawType();
			TypeVariable<?>[] parentTypeVars = parentAsClass.getTypeParameters();
			if (srcType instanceof ParameterizedType) {
				parentAsType = translateParentTypeVars((ParameterizedType) srcType, clazz, parentAsType);
			}
			if (declaringClass == parentAsClass) {
				for (int i = 0; i < parentTypeVars.length; i++) {
					if (typeVar == parentTypeVars[i]) {
						return parentAsType.getActualTypeArguments()[i];
					}
				}
			}
			if (declaringClass.isAssignableFrom(parentAsClass)) {
				return resolveTypeVar(typeVar, parentAsType, declaringClass);
			}
		} else if (superclass instanceof Class && declaringClass.isAssignableFrom((Class<?>) superclass)) {
			return resolveTypeVar(typeVar, superclass, declaringClass);
		}
		return null;
	}

	private static ParameterizedType translateParentTypeVars(ParameterizedType srcType, Class<?> srcClass,
			ParameterizedType parentType) {
		Type[] parentTypeArgs = parentType.getActualTypeArguments();
		Type[] srcTypeArgs = srcType.getActualTypeArguments();
		TypeVariable<?>[] srcTypeVars = srcClass.getTypeParameters();
		Type[] newParentArgs = new Type[parentTypeArgs.length];
		boolean noChange = true;
		for (int i = 0; i < parentTypeArgs.length; i++) {
			if (parentTypeArgs[i] instanceof TypeVariable) {
				for (int j = 0; j < srcTypeVars.length; j++) {
					if (srcTypeVars[j] == parentTypeArgs[i]) {
						noChange = false;
						newParentArgs[i] = srcTypeArgs[j];
					}
				}
			} else {
				newParentArgs[i] = parentTypeArgs[i];
			}
		}
		return noChange ? parentType
				: new ParameterizedTypeImpl((Class<?>) parentType.getRawType(), null, newParentArgs);
	}

	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;

		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;

		GenericArrayTypeImpl(Type genericComponentType) {
			super();
			this.genericComponentType = genericComponentType;
		}

		@Override
		public Type getGenericComponentType() {
			return genericComponentType;
		}
	}
}
复制代码

原文 https://juejin.im/post/5c8a7057e51d45194c7c2df1

正文到此结束