java typeresolver 作用 java type类型

Type是Java 编程语言中所有类型的公共高级接口，也就是说Java中所有的类型都实现了这个接口,其意义表示Java所有类型，这里所谓的类型是从Java整个语言角度来看的，比如原始类型、参数化类型（泛型）、类型变量及其数组等，可以理解为，Class（类）是Java对现实对象的抽象，而Type是对Java语言对象的抽象。

Type体系中类型的包括：原始类型(Class)、参数化类型(ParameterizedType)、数组类型(GenericArrayType)、类型变量(TypeVariable)、基本类型(Class);

原始类型，不仅仅包含我们平常所指的类，还包括枚举、数组、注解等；

参数化类型，就是我们平常所用到的泛型List、Map<E,M>；

数组类型，带有泛型的数组，即T[] ；

基本类型，也Java的基本类型，即int,float,double等

Type

Type本身只是一个简单的接口,只有一个default方法,基本上只是一个抽象的概念.

package java.lang.reflect;

/**
 * Type is the common superinterface for all types in the Java
 * programming language. These include raw types, parameterized types,
 * array types, type variables and primitive types.
 *
 * @since 1.5
 */
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();
    }
}

Type的子类

Type的直接子接口
1.ParameterizedType： 表示一种参数化的类型，比如Collection(集合)，即普通的泛型。
2.TypeVariable：是各种类型变量的公共父接口，就是泛型里面的里的T、E。
3.GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型，比如List<>[]，T[]这种。
4.WildcardType：代表一种通配符类型表达式，类似? super T这样的通配符表达式。(这个不讲)

Type的直接子类
　　Type的直接子类只有一个，也就是Class，代表着类型中的原始类型以及基本类型。

ParameterizedType

参数化类型，即泛型，类似List、Map<String, Integer>等带有类型参数的类型

ParameterizedType接口源码

public interface ParameterizedType extends Type {
 	//返回<>中的实际类型,如XX<Integer>
    Type[] getActualTypeArguments();
	//返回<>前的实际类型,如List<XX>
    Type getRawType();
	//返回泛型的所有者即内部类的“父类”,如果没有则返回null
	//如Map.Entry<T,M>,就会返回Map,因为Map是Map.Entry<T,M>的所有者
    Type getOwnerType();
}

getActualTypeArguments

public List<T> list = null;
    public Map<String, Integer> map = null;
    public static void main(String[] args) throws Exception 		  {
	//通过反射获取list属性
	Field field = Type01.class.getDeclaredField("list");
	//获取该属性的泛型类型
	Type listType = field.getGenericType();
	/*
	*类型为:sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl,从中可以大概知道,泛型是getActualTypeArguments实现类
	*/
	System.out.println(listType.getClass().getName());
	//通过反射获取属性map
	Field map = Type01.class.getDeclaredField("map");
	//获取泛型的类型
	Type typeMap = map.getGenericType();
	System.out.println(typeMap);//java.util.Map<java.lang.String, java.lang.Integer>
	//将Type类型强转为其子类ParameterizedType
	ParameterizedType pMap = (ParameterizedType) typeMap;
	//获取泛型中的参数类型,即map<String, Integer>中的String,Integer,实际上返回的是TypeVariable类型
	Type[] types = pMap.getActualTypeArguments();
	System.out.println(types[0]);//class java.lang.String
	System.out.println(types[1]);//class java.lang.Integer	
}

注意的是: 无论<>中有几层<>嵌套，这个方法仅仅脱去最外层的<>，之后剩下的内容就作为这个方法的返回值,如List<Map<M,E>>,就会返回Map<M,E>.

getRawType

获取声明泛型的类或者接口，也就是泛型中<>前面的那个值

//通过反射获取属性map
 Field map = Type01.class.getDeclaredField("map");
//获取泛型的类型
Type typeMap = map.getGenericType();
//将Type类型强转为其子类ParameterizedType
ParameterizedType pMap = (ParameterizedType) typeMap;
//获取泛型<>前的类型
Type rawType = pMap.getRawType();
System.out.println(rawType);//interface java.util.Map

GenericArrayType

泛型数组，表示上面两种的数组类型，即形如：A[]，T[][]类型。

GenericArrayType接口源码

public interface GenericArrayType extends Type {
	//返回泛型数组的元素类型,如List<T>[] 返回 List<T>
    Type getGenericComponentType();
}

getGenericComponentType

public List<T>[] lists = null;
public List<String>[] stringLists = null;

 public static void main(String[] args) throws Exception {
	Field lists = Type01.class.getDeclaredField("stringLists");
	Type listType = lists.getGenericType();
	//泛型的类型 sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl
	System.out.println(listType.getClass().getName());
	GenericArrayType genericArrayType = (GenericArrayType) listType;
	//泛型数组中元素的类型 java.util.List<java.lang.String>
	Type type = genericArrayType.getGenericComponentType();
	System.out.println(type); 
}

TypeVariable

TypeVariable，类型变量，描述类型，表示泛指任意或相关一类类型，也可以说狭义上的泛型（泛指某一类类型），一般用大写字母作为变量，比如K、V、E等。在这需要强调的是，TypeVariable代表着泛型中的变量，而ParameterizedType则代表整个泛型

TypeVariable接口源码

public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement {
//获得泛型的上限，若未明确声明上边界则默认为Object
    Type[] getBounds();
//获得泛型的上限，若未明确声明上边界则默认为Object
    D getGenericDeclaration();
//获得类型变量在源码中定义的名称
    String getName();

}

public List<T> list = null;
public static void main(String[] args) throws Exception {

	//TypeVariable
	//通过反射获取list属性
	Field field = Type01.class.getDeclaredField("list");
	//获取该属性的泛型类型
	Type listType = field.getGenericType();
	ParameterizedType parameterizedTypeList = (ParameterizedType) listType;
	//获取泛型中变量的实际类型
	Type[] types = parameterizedTypeList.getActualTypeArguments();
	//sun.reflect.generics.reflectiveObjects.TypeVariableImpl
	System.out.println(types[0].getClass().getName());

    }

---------------------------------------未完待续-----------------------------------------------