fastJson序列化与反序列化

本人刚入坑Java岗小菜鸟一枚。 昨天写需求时出现一个复杂的json数据需要转换成Java对象。json就那么回事嘛，有什么了不起的，一顿操作猛如虎啊。结果一排排红色的日志格外的刺眼的映入了眼帘。抱歉啊我不该对你不存在敬畏之心。
fastjson:

我：

Java:

我：。。。

一般的序列化与反序列话比较简单不在叙述。
作者本次序列化出现问题的原因是对泛型的理解不够。

坐好我要开始装逼了。
Java泛型是jdk1.5引入的一个新特性。泛型的本质是参数化类型，也就是说操作的数据类型被指定为一个参数。

Java泛型

泛型类

public class Pair < T , U >{
  private T first ;
  private U second ;
  ...
}

泛型方法

    public static <E extends BoundingType> void sort(E e){
    ...
    }

注意：
1. 为 类型变量 需要特别注意他的位置。
2.extends BoundingType 给E添加限制条件，E应该是绑定类的BoundingType子类
3.E和BoundingType可以是接口也可以是类。
4.一个类型变量或通配符可以有多个限定。例如：<E extends Comparable & Serializable>
约束与局限性
不能用基本类型实例化类型参数。例如： Pair < double >
运行时类型查询只适用于原始类型。例如：if ( a instanceof Pair < String > ) // Error；if ( stringPair . getClassO = = employeePair . getClassO ) / / they are equal
不能创建参数化类型的数组。Pair < String > [ ] table = new Pair < String > [ 10 ] ; // Error
不能实例化类型变置。例如：new T ( ) ；
Varargs 警告 使用 @ SafeVarargs 标注来消除创建泛型数组的有关限制
不能构造泛型数组 ：T[] a = new T [ 2 ] ;/ / Error
泛型类的静态上下文中类型变量无效:及不能在静态域或方法中引用类型变量；

public class Singleton < T >{
  private static T singlelnstance ; // Error
  public static T getSinglelnstanceO{ // Error
    if ( singleinstance = = null ) construct new instance of T
    return singlelnstance ;
  }
}

不能抛出也不能捕获泛型类对象：例如catch ( T e ) / / Error can ’ t catch type variable
可以消除对受查异常的检查：Java 异常处理的一个基本原则是 ， 必须为所有受查异常提供一个处理器 。可以利用
泛型消除这个限制 。

@ SuppressWamings ( " unchecked " )
public static < T extends Throwable 〉 void throwAs ( Throwable e ) throws T
{
  throw CO e ;
}

假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？（问题来源菜鸟教程）

    /**
     * 排序方法
     * @param list 列表
     * @param <E>  泛型定义为<E extends Comparable<E>>
     */
    public static <E extends Comparable<E>> void sort(E[] list){

        if (list == null || list.length == 0){
            return;
        }

        /**
         * 任意对象
         */
        E obj;

        /**
         * 列表下标
         */
        int index;

        //外层循环 从下表1开始
        for(int i = 0; i < list.length - 1; i++){

            //找到数组中最小的值
            obj = list[i];
            index = i;
            for(int j = i + 1; j < list.length; j++){
                /**
                 * 如果obj与参数相等返回 0。
                 * 如果obj小于参数返回 -1。
                 * 如果obj大于参数返回 1。
                 */
                if (obj.compareTo(list[j]) > 0){
                    obj = list[j];
                    index = j;
                }
            }

            if (index != i){
                list[index] = list[i];
                list[i] = obj;
            }
        }
    }

回顾了上面的泛型我们差不多可以进入正题了。序列化与反虚化，这里用的是fastJson工具。一般情况下的时候很简单。
这里将会使用到一个类TypeReference，他就是这次的主角。开头有这么一句话格外的刺耳。Represents a generic type {@code T}. Java doesn’t yet provide a way to represent generic types, so this class does.
翻译过来意思就是：表示一个泛型类型 {@code T}。 Java 还没有提供表示泛型类型的方法，所以这个类提供了。强制客户端创建此类的子类，即使在运行时也可以检索类型信息。
这里贴上该类的部分源码:

/**
 * 表示一个泛型类型 {@code T}。 Java 还没有提供表示泛型类型的方法，所以这个类提供了。
 * 强制客户端创建此类的子类，即使在运行时也可以检索类型信息。
 * 例如，要为 {@code List<String>} 创建一个类型文字，您可以创建一个空的匿名内部类：TypeReference<List<String>> list = new TypeReference<List<String>> () {};
 * 此语法不能用于创建具有通配符参数的类型文字，例如 {@code Class<?>} 或 {@code List<?扩展 CharSequence>}。
 *
 */
public class TypeReference<T> {
    static ConcurrentMap<Type, Type> classTypeCache
            = new ConcurrentHashMap<Type, Type>(16, 0.75f, 1);

    protected final Type type;

    /**
     * 构造一个新的类型文字。从类型参数派生表示的类。
     * 客户端创建一个空的匿名子类。这样做会将类型参数嵌入到匿名类的类型层次结构中，因此我们可以在运行时重构它，尽管会被擦除。
     */
    public TypeReference(){
        Type superClass = getClass().getGenericSuperclass();

        Type type = ((ParameterizedType) superClass).getActualTypeArguments()[0];

        Type cachedType = classTypeCache.get(type);
        if (cachedType == null) {
            classTypeCache.putIfAbsent(type, type);
            cachedType = classTypeCache.get(type);
        }

        this.type = cachedType;
    }
    
    ...
    
 }

说明：
参考：Java核心技术第十卷