mybatis基础支持层-反射模块：TypeParameterResolver

一、Type

• 首先了解一些基础类型的含义，Type有哪些实现类和子接口：Class,ParameterizedType,GenericArrayType,TypeVariable,WildcardType

public interface Type {
    /**
     * Returns a string describing this type, including information
     * about any type parameters.
     *
     * @implSpec The default implementation calls {@code toString}.
     *
     * @return a string describing this type
     * @since 1.8
     */
    default String getTypeName() {
        return toString();
    }
}

• Class表示JVM中的一个类或者接口，可以通过.class/getClass()/Class.forName/ClassLoader等方式获取一个类或者接口的Class

• ParameterizedType 表示参数化类型，例子：List,Map<Integer,String>,Service

public interface ParameterizedType extends Type {
    /**
     获取参数化类型的实际类型列表  Map<String,Integer>就是String Integer
     */
    Type[] getActualTypeArguments();

    /**
      参数化类型中的原始类型，例子：List<String> -->List
     */
    Type getRawType();

    /**
    返回类型所属的类型
     */
    Type getOwnerType();
}

• TypeVariable 标识的是类型变量，反应在JVM编译泛型前的信息

public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement {
    /**
     获取类型的上边界，默认Object List<T extends User> -->Use是上边界
    */
    Type[] getBounds();

    /**
      获取声明该类型的原始类型，class Test<T extends User> -->Test
     */
    D getGenericDeclaration();

    /**
     湖片区源码中定义的名字 T
     */
    String getName();

    /**
     * Returns an array of AnnotatedType objects that represent the use of
     * types to denote the upper bounds of the type parameter represented by
     * this TypeVariable. The order of the objects in the array corresponds to
     * the order of the bounds in the declaration of the type parameter.
     *
     * Returns an array of length 0 if the type parameter declares no bounds.
     *
     * @return an array of objects representing the upper bounds of the type variable
     * @since 1.8
     */
     AnnotatedType[] getAnnotatedBounds();
}

二、TypeParameterResolver

• 接下来还是切入TypeParameterResolver

1.addGetMethod

   private void addGetMethod(String name, Method method) {
    if (isValidPropertyName(name)) {
        //记录方法，绑定回调方法
      getMethods.put(name, new MethodInvoker(method));
      Type returnType = TypeParameterResolver.resolveReturnType(method, type);
      //记录返回值类型
      getTypes.put(name, typeToClass(returnType));
    }
  }

• 以上方法的流程大约如下，除了resolveReturnType的流程，还有resolveFieldType resolveParamTypes,包含返回值类型，属性类型，参数类型的解析，最终就是调用resolveType 进行类型的解析

  1. resolveReturnType --> 2. resolveType -->(
     3.1 resolveTypeVar --> 4scanSuperTypes
     3.2 resolveParameterizedType -->(
          ...,
         4 resolveWildcardType -->5 resolveWildcardTypeBounds
          )
     3.3 resolveGenericArrayType ->(...)
      )

2.resolveType

 private static Type resolveType(Type type, Type srcType, Class<?> declaringClass) {
    if (type instanceof TypeVariable) {
      return resolveTypeVar((TypeVariable<?>) type, srcType, declaringClass);
    } else if (type instanceof ParameterizedType) {
      return resolveParameterizedType((ParameterizedType) type, srcType, declaringClass);
    } else if (type instanceof GenericArrayType) {
      return resolveGenericArrayType((GenericArrayType) type, srcType, declaringClass);
    } else {
      return type;
    }
  }

3.resolveParameterizedType

• 内部有递归调用方法，直到所有参数都是基础类型，不含有任何包装对象，如果无匹配的上界，默认为Object

  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);

4.resolveTypeVar

• 经过处理，类型都会是TypeVariable类型，resolveTypeVar方法来看一下

private static Type resolveTypeVar(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass) {
    Type result;
    Class<?> clazz;
    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;
  }

5.scanSuperTypes

• scanSuperTypes的任务是递归整个继承结构并完成类型变量的解析

 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;
  }

• 以上scanSuperTypes方法会比较复杂一些，先找到待解析的参数，再在层层解析的映射中查找类型的映射，直到定位基础类中的一种，最终构造返回类型
• resolveGenericArrayType是专门用于解析数组元素类型的
• 还有一块是通配符表达式，WildcardType，主要在于确定上界和下界

static class WildcardTypeImpl implements WildcardType {
    private Type[] lowerBounds;

    private Type[] upperBounds;

    WildcardTypeImpl(Type[] lowerBounds, Type[] upperBounds) {
      super();
      this.lowerBounds = lowerBounds;
      this.upperBounds = upperBounds;
    }
    ...
}    

• 欢迎关注相关列表
• 也无言’s Blog
• 文章 Github地址