前言

Type体系的引入是对泛型的一种补偿。java泛型的引入为编译器提供了更严格的代码审查，但这些泛型信息在运行时将会被擦除，这将导致程序在运行期间无法获取到属性或者类的具体声明。Type的引入使得开发者在程序运行期内获取属性或者类的具体声明成为可能。

Type是一个接口，它的实现类如下图所示:

type.png

从上图可以看出，Class类是继承了Type接口的，而Class类在反射中应用广泛，因此这很容易让我们想到Type的大多数应用应该也是在反射中。接下来看几个常见的实现接口。

ParameterizedType（参数化类型）

带有泛型参数的属性声明都属于ParameterizedType，带有泛型参数的方法返回值类型也属于ParameterizedType

public class A {
  //这几个属性都带泛型参数，因此都属于ParameterizedType
    private List<String> list;
    private Map<String, Integer> map;
    private Class<?> aClass;
    private Bean<String> bean;

  //该返回值类型属于ParameterizedType
    public List<String> getList() {
        return null;
    }
}

测试代码

##定义类
public class A {
    private List<String> list;
    private Map<String, Integer> map;
    private Class<?> aClass;
    private Bean<String> bean;

    public class Bean<T> {

    }
}
  
##测试代码  
@Test
    public void test() throws IOException {
        Class c = A.class;
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName());
            Type type = field.getGenericType();
            if (type instanceof ParameterizedType) {
                System.out.println(Arrays.toString(((ParameterizedType) type).getActualTypeArguments()));
                System.out.println(((ParameterizedType) type).getRawType());
                System.out.println(((ParameterizedType) type).getOwnerType());
            }
            System.out.println("====================================");
        }
    }
    
##输出
list
[class java.lang.String]
interface java.util.List
null
====================================
map
[class java.lang.String, class java.lang.Integer]
interface java.util.Map
null
====================================
aClass
[?]
class java.lang.Class
null
====================================
bean
[class java.lang.String]
class com.lu.test.A$Bean
class com.lu.test.A
====================================   

TypeVariable

在类或者接口声明的时候添加泛型，那么这个类的泛型就属于TypeVariable

//A类声明了2个泛型，即两个TypeVariable 
public class A<T extends String, E>

##声明类
public class A<T extends String & Serializable, E> {
}
##测试代码
  @Test
    public void test() throws IOException {
        Class c = A.class;
        Type[] types = c.getTypeParameters();
        for (Type type : types) {
            System.out.println(type.getTypeName());
            if (type instanceof TypeVariable) {
                System.out.println(((TypeVariable) type).getGenericDeclaration());
                System.out.println(Arrays.toString(((TypeVariable) type).getBounds()));
            }
            System.out.println("==========================================");
        }
    }
##输出结果
T
class com.lu.test.A
[class java.lang.String, interface java.io.Serializable]
==========================================
E
class com.lu.test.A
[class java.lang.Object]
==========================================

GenericArrayType

范型数组,组成数组的元素中有范型 则属于GenericArrayType

public class A<T> {
    T[] ts;//属于GenericArrayType
    List<String>[] lists;//属于GenericArrayType
   private String[] arr;
}

##声明类
public class A<T> {
    T[] ts;
    List<String>[] lists;
}
##测试类
 @Test
    public void test() throws IOException {
        Class c = A.class;
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            Type type = field.getGenericType();
            if (type instanceof GenericArrayType) {
                System.out.println(((GenericArrayType) type).getGenericComponentType());
            }
            System.out.println("==================================");
        }
    }
##输出结果
T
==================================
java.util.List<java.lang.String>
==================================

WildcardType 通配符的类型

形如<?> <? extends String> <? super Integer> 中的泛型(其实就是就是“？”)类型就属于WildcardType

public class A {
    List<? extends String> ts;//属于WildcardType 
    List<?> list;//属于WildcardType 
    List<? super Integer> ins;//属于WildcardType 
}

##声明类
public class A {
    List<? extends String> ts;
    List<?> list;
    List<? super Integer> ins;
}
##测试
 @Test
    public void test() throws IOException {
        Class c = A.class;
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            ParameterizedType type = (ParameterizedType) field.getGenericType();
            for (Type type1 : type.getActualTypeArguments()) {
                System.out.println("getTypeName():  " + type1.getTypeName());
                if (type1 instanceof WildcardType) {
                    System.out.println("getUpperBounds(): " + Arrays.toString(((WildcardType) type1).getUpperBounds()));
                    System.out.println("getLowerBounds(): " + Arrays.toString(((WildcardType) type1).getLowerBounds()));
                    System.out.println("===========================");
                }
            }
        }
    }



##输出结果
getTypeName():  ? extends java.lang.String
getUpperBounds(): [class java.lang.String]
getLowerBounds(): []
===========================
getTypeName():  ?
getUpperBounds(): [class java.lang.Object]
getLowerBounds(): []
===========================
getTypeName():  ? super java.lang.Integer
getUpperBounds(): [class java.lang.Object]
getLowerBounds(): [class java.lang.Integer]
===========================

注意点

上面介绍了四个比较常见的Type实现接口，它们在用法上有很大的区别。在区分的时候比较繁琐。不过大体上来说， ParameterizedType和GenericArrayType所修饰的是属性本身的类型，例如变量类型，方法返回值类型。而TypeVariable 和WildcardType 所修饰的是泛型类型，例如T，E或者？等。这一点一定要清楚。

理解Type对于很多带泛型编程的框架的深入研究很有帮助，例如Retrofit，springMvc等框架都适用了Type来解析返回值