Mybatis技术内幕（2.3.7）：反射模块-TypeParameterResolver
为什么要单独拿一篇文章来讲呢？因为里面涉及到的java-Type接口的内容之前没有接触和了解过。我相信在座的很多小伙伴也一定不知道其中的奥秘哦~
你知道Class对象还有一个父接口吗？
以下内容均摘录自 徐郡明 《Mybatis技术内幕》
先简单介绍一下Type接口的基础知识。Type是所有类型的父接口，它有四个子接口和一个实现类，如下图：
下面来看这些子接口和子类所代表的类型
- 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;
}
}
}
复制代码
正文到此结束
热门推荐
相关文章
近期评论
-
文章和留言都翻到11页了 没有OOM
-
-
朋友，翻页到11页，及以后，会出现OOM，无法访问
-
-
搞个gitee的项目
-
-
版本号是多少，你可以下载哪个代码仓库，jdk选1.8 直接跑就行
-
-
-
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
