当反射遇上泛型该如何处理

由于后面讲到的反序列化器在反序列化List的时候需要确定泛型的type，所以这边先讲一下针对类型擦除的泛型，我们要如何获取其type

JAVA反射机制提供了运行时动态编程的可能

• 在运行阶段能够随意的获取：
• 任意一个类的所有属性、函数与注解等信息；
• 任意一个对象，都能够调用它的任意属性与函数。
• 这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
  众所周知Java有个Object 类，是所有Java 类的继承根源，其内声明了数个应该在所有Java 类中被改写的方法：hashCode()、equals()、clone()、
  toString()、getClass()等。其中getClass()返回一个Class 对象。
  Class是反射的起源。

public class Bean {
    private int i;
    public List list;

    public Bean() {

    }

    public void setI(int i) {
        this.i = i;
    }

    public int getI() {
        return i;
    }
}

有类如上。执行下面代码：

Class beanClass = Bean.class;
        //获得类以及父类中所有声明为public的属性
        System.out.println("所有public属性:");
        for (Field field : beanClass.getFields()) {
            System.out.println(field.getName());
        }
        //获得类(不包括父类)中所有的属性
        System.out.println("所有属性:");
        for (Field field : beanClass.getDeclaredFields()) {
            System.out.println(field.getName());
        }
        //获得类以及父类中所有声明为public的函数
        System.out.println("所有public函数:");
        for (Method method : beanClass.getMethods()) {
            String methodName = method.getName();
            System.out.println(methodName);
        }

         //获得类(不包括父类)中所有的函数
        System.out.println("所有函数:");
        for (Method method : beanClass.getDeclaredMethods()) {
            String methodName = method.getName();
            System.out.println(methodName);
        }

很显然，getDeclaredXX :会获得Class中的所有内容,getXX: 获得当前类以及父类的内容，但是不包括非public
类中的属性对应反射中的Field，而函数则为Method。但是获取构造方法，则需要通过Constructor:

Constructor[] constructors = beanClass.getConstructors();

操作属性、调用函数的方法则需要编写:

Method method = XX;
//在obj对象上调用函数
method.invoke(obj,...);

 Field field = XX;
//获得obj中的属性
field.get(obj);
//设置obj中的属性
field.set(obj,value);

//调用构造函数
Constructor[] constructor = XX;
constructor.newInstance(...);

对于非public的Field/Method进行操作,需要先进行：setAccessible(true)
查看Bean的定义，其中包括了List list成员，如何需要通过这个Field获得对应的泛型类型(即String)?
Java 泛型在运行的时候是会进行类型擦除，泛型信息只存在于代码编译阶段。即对于List和List在运行阶段都是List.class,泛型信息被擦除了。

List l1 = new ArrayList();
List l2 = new ArrayList();
assert(l1.getClass() == l2.getClass()); //结果为真

所以这时候没法通过Class type = Field.getType获得需要的Class。好在Java为我们提供了 Type 接口，使用它我们可以得到这些信息。
Type是一个接口，它的实现类有Class,子接口有 ParameterizedType, WildcardType等。

ParameterizedType （参数化类型）

Type[] getActualTypeArguments(): 返回类型的参数的实际类型数组
如Map的类型(Type)是属于参数化类型(ParameterizedType),
则可以获得:

Type key = getActualTypeArguments()[0];
Type value = getActualTypeArguments()[1];

其中Key即为String，Value则是Integer。

WildcardType (通配符的类型)

JAVA泛型通配符的使用规则:"PECS"

在泛型中可以通过通配符来声明一个泛型类型，即使用?。同时可以指明?的上下边界。带上边界的通配符：
List list；带下边界的通配符:List list。

getUpperBounds：获得上边界

对于List list上边界为Number，而List list上边界则为:Object。

如果希望获得某个类中List集合的泛型类型,则可以：

//指定获得Bean中list属性
Field list = Bean.class.getField("list");
// 属性对应的Class如果是List或其子类
if (List.class.isAssignableFrom(list.getType())) {
    //获得 Type
    Type genericType = list.getGenericType();
    //ParameterizedType
    if (genericType instanceof ParameterizedType) {
        //获得泛型类型
        Type type = ((ParameterizedType) genericType).getActualTypeArguments()[0];
        //WildcardType  如果使用了通配符
        if (type instanceof WildcardType) {
            WildcardType wildcardType = (WildcardType) type;
            Type[] upperBounds = wildcardType.getUpperBounds();
            if (upperBounds.length == 1) {
                Type actualTypeArgument = upperBounds[0];
                System.out.println("获得泛型上边界类型:" + actualTypeArgument);
            }
        } else {
            System.out.println("获得泛型类型:" + type);
        }
    } 
}

如果遇见一个泛型类

public class TypeReference {
    protected TypeReference() {
        //获取当前对象的直接超类的 Type
        Type superClass = getClass().getGenericSuperclass();
        Type oriType = ((ParameterizedType) superClass).getActualTypeArguments()[0];
    }
}
new TypeReference