由于后面讲到的反序列化器在反序列化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<String> list;
public Bean() {
}
public void setI(int i) {
this.i = i;
}
public int getI() {
return i;
}
}
有类如上。执行下面代码：
Class<Bean> 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<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
assert(l1.getClass() == l2.getClass()); //结果为真
所以这时候没法通过Class<?> type = Field.getType获得需要的Class。好在Java为我们提供了 Type 接口，使用它我们可以得到这些信息。
Type是一个接口，它的实现类有Class,子接口有 ParameterizedType, WildcardType等。
ParameterizedType （参数化类型）
Type[] getActualTypeArguments(): 返回类型的参数的实际类型数组
如Map<String,Integer>的类型(Type)是属于参数化类型(ParameterizedType),
则可以获得:
Type key = getActualTypeArguments()[0];
Type value = getActualTypeArguments()[1];
其中Key即为String，Value则是Integer。
WildcardType (通配符的类型)
JAVA泛型通配符的使用规则:"PECS"
在泛型中可以通过通配符来声明一个泛型类型，即使用?。同时可以指明?的上下边界。带上边界的通配符：
List<? extends Number> list；带下边界的通配符:List<? super Integer> list。
getUpperBounds：获得上边界
对于List<? extends Number> list上边界为Number，而List<? super Integer> 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<T> {
protected TypeReference() {
//获取当前对象的直接超类的 Type
Type superClass = getClass().getGenericSuperclass();
Type oriType = ((ParameterizedType) superClass).getActualTypeArguments()[0];
}
}
new TypeReference<Object>(){}.getType()
在运行期可以通过反射机制获取到Class对应的泛型类型。这里为什么没有“类型擦除”？
观察上面的类,如果将构造函数的作用域改为public,那么会得到一个
java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType
如果将构造函数改为public，则需要将类声明为abstract才不会出现问题。
这下子应该明显了，当new这个类的时候，实际上是创建了一个匿名内部类。TypeReference的子类，泛型参数限定为Object。
引入泛型擦除的原因是避免因为引入泛型而导致运行时创建不必要的类。Java 的泛型擦除是有范围的，除了结构化信息外的所有东西会擦除，与类及其字段和方法的类型参数相关的元数据都会被保留下来，可以通过反射获取到。
这里则是通过定义类(匿名内部类)的方式，在类信息中保留泛型信息，从而在运行时获得这些泛型信息.
