jdk 基础接口类

Type:是java语言中所有类型的父类接口;

ParameterizedType:参数化类型接口;

rawType:返回承接参数的类或接口对象
getActualTypeArguments:返回参数化类型中的参数数组;
getOwnerType:返回当前类型所属的上级类型,如:O<T>.I<S>,则返回O<T>;当前已是顶级对象时,则返回null;

====
List<String>
    rawType: List;
    getActualTypeArguments:types[0] == String && types.length == 1;
    getOwnerType:null

Map<String, Integer>
    rawType: Map;
    getActualTypeArguments:types[0] == String && types[1] == Integer && types.length == 2;
    getOwnerType:null

GenericArrayType:泛型数组类型接口

这个类型容易迷惑;jdk介绍:
{@code GenericArrayType} represents an array type 
whose component type is either a parameterized type or a type variable.
数组中的元素是参数化类型或者是变量类型;
即:int[]、Integer[]、String[]都是Class类型,而并非是GenericArrayType类型;

====
List<String>[] method1();
<T> T[] method2;
以上两种方法的返回值都属于GenericArrayType类型;

List<String>[]:
    getGenericComponentType:List<String>属于ParameterizedType类型

<T> T[]:
    getGenericComponentType:T属于TypeVariable类型

 TypeVariable:变量类型接口

public interface Level0Mapper<L, M, N> {}

L、M、N都属于变量

 GenericDeclaration:泛型定义接口

该接口在类图中有两处出现;
1.Class类的实现接口,如interface Level0Mapper<L, M, N>{}接口中
  的L、M、N就是就是Level0Mapper.class所定义的泛型;
  getTypeParameters():
      TypeVariables.length day ==3 && TypeVariables[0] == L 
      && TypeVariables[1] == M && TypeVariables[2] == N;

2.TypeVariable接口中的方法getGenericDeclaration,返回值是定义该泛型变量的类名,
  这其实与Method.getDeclaringClass、Field.getDeclaringClass()含义类似,
  都是返回定义该泛型、方法、属性的类名;

Class:应用运行中的所有类和接口的类实例

该类属于java开发者最熟知的类了,所有的对象进行装载后都是Class类的二进制文件;
Class有类似于GenericArrayType接口中的方法,如:getComponentType,
    int[]、String[]属于Class类型,同时也是引用类型,
    int[]:
        getComponentType:int.class
        isArray:true

    String[]:
        getComponentType:String.class
        isArray:true

    List:
        getComponentType:null
        isArray:false

同时实现GenericDeclaration接口,可获取在该Class中定义的泛型元素

WIldcardType:通配符类型

List<? extends Integer & Comparator, ? super Age> method();
该方法返回值的类型是ParameterizedType类型
rawType:List
getActualTypeArguments:args[0]是WildcardType类型
    getUpperBounds:bounds[0] == Integer 父类类型
    getLowerBounds: bounds[0] == Age     子类类型

以上只是针对每个接口类型做了阐述,或许有很多描述不够准确,欢迎拍砖指正;

现在写一个比较简单的测试类,来体现部分类型接口的使用场景

public interface Level0Mapper<L, M, N> {
    List<N> selectList(L param1, M param2);
}

public interface Level1Mapper<E, F> extends Level0Mapper<Date, Long, String> {
}

@Test
void test() {
    Class<?> clazz = Level1Mapper.class;
    Method method = clazz.getMethod("selectList", Object.class, Object.class);

    ParameterizedType returnType = (ParameterizedType) method.getGenericReturnType();
    assertEquals(List.class, returnType.getRawType());
    String returnVar = ((TypeVariable) returnType.getActualTypeArguments()[0]).getName();

    Type[] paramTypes = method.getGenericParameterTypes();
    String paramVarOne = ((TypeVariable) paramTypes[0]).getName();
    String paramVarTwo = ((TypeVariable) paramTypes[1]).getName();

    ParameterizedType parentInter = (ParameterizedType) Level1Mapper.class.getGenericInterfaces()[0];
    Type[] args = parentInter.getActualTypeArguments();
    Class<?> superClass = (Class<?>) parentInter.getRawType();
    TypeVariable[] vars = superClass.getTypeParameters();

    Map<String, Type> paramMap = new HashMap<>();
    for (int i=0; i< args.length; i++) {
      paramMap.put(vars[i].getName(), args[i]);
    }

    assertEquals(String.class, paramMap.get(returnVar)); // 返回类型是String类型
    assertEquals(Date.class, paramMap.get(paramVarOne)); // 第一个入参是Date类型
    assertEquals(Long.class, paramMap.get(paramVarTwo)); // 第二个入参是Long类型
}

上面的例子比较容易理解,后续会将框架中的运用加以补充!!!