概述

TypeReference是一个描述复杂泛型的工具类。
很多类库都有，我们使用alibaba.fastjson来举例。

作用

在反序列化场景中获取泛型参数。
TypeReference支持泛型参数，方便一些框架实现通用的反序列化类，对复杂的类型可以很方便的反序列化。
使用Gson、Jackson或Fastjson反序列化泛型时，需要传递泛型的真实类型，所以一般都通过集成TypeReference来实现。

示例

简单示例

@Slf4j(topic = "juc")
public class TypeRefrenceStudy {
    public static void main(String[] args) {
        List<Integer> list = Lists.newArrayList(1, 3, 4, 8, 9);
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("list", list);
        log.info(jsonObject.toString());

		// 使用匿名类创建TypeReference的子类对象
        List<Integer> list2 = jsonObject.getObject("list", new TypeReference<List<Integer>>() {});
        log.info("list2 {}", list2);
    }
}

执行结果：

16:07:37.122 [main] juc - {"list":[1,3,4,8,9]}
16:07:37.141 [main] juc - list2 [1, 3, 4, 8, 9]

使用TypeReference可以明确指定反序列化的类型，能够比较方便的获取反序列化的数据。

复杂示例

例子:Response response = JSONObject.parseObject(result, new TypeReference<Response>(TaskCodeRespData.class) {});
等价于：
Response response = JSONObject.parseObject(result, new TypeReference<Response>( ) {})
如果要用泛型变量，有参数的写法就相当必要了。

单参数例子

public class Response {
public T data;
}
public static Response parseToMap(String json, Class type) {
return JSON.parseObject(json,
new TypeReference<Response>(type) {});
}

双参数例子

public static <K, V> Map<K, V> parseToMap(String json,
Class keyType,
Class valueType) {
return JSON.parseObject(json,
new TypeReference<Map<K, V>>(keyType, valueType) {
});
}

// 可以这样使用
String json = “{1:{name:“ddd”},2:{name:“zzz”}}”;
Map<Integer, Model> map = parseToMap(json, Integer.class, Model.class);
assertEquals(“ddd”, map.get(1).name);
assertEquals(“zzz”, map.get(2).name);

源码解析

无参构造器

    protected TypeReference() {
        Type superClass = this.getClass().getGenericSuperclass();
        Type type = ((ParameterizedType)superClass).getActualTypeArguments()[0];
        Type cachedType = (Type)classTypeCache.get(type);
        if (cachedType == null) {
            classTypeCache.putIfAbsent(type, type);
            cachedType = (Type)classTypeCache.get(type);
        }

        this.type = cachedType;
    }

可以看到构造函数是protect的，所以只能使用TypeReference的继承类生成对象。

ParameterizedType解析

ParameterizedType用来表示一个泛型类型（泛型类的模板中有至少一个类型参数），比如Collection。ParameterizedType继承Type，共有3个方法。

Type[] getActualTypeArguments()；// 返回类的泛型类型数组。
Type getRawType()；// 返回原始类型Type，类型本身的类型。
Type getOwnerType()；// 返回Type对象，表示此类型是其成员之一的类型。

例如 Map<String,String> 对应的ParameterizedType三个方法分别取值如下:
[class java.lang.String, class java.lang.String]
interface java.util.Map
null

测试

package JsonLearn;
 
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.Map;
 
public class TypeReferencBaseLearn {
    public static class IntMap extends HashMap<String, Integer> {}
 
    void test1() {
        IntMap intMap = new IntMap();
        System.out.println("getSuperclass:" + intMap.getClass().getSuperclass());
        System.out.println("getGenericSuperclass:" + intMap.getClass().getGenericSuperclass());
        Type type = intMap.getClass().getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            ParameterizedType p = (ParameterizedType)type;
            for (Type t : p.getActualTypeArguments()) {
                System.out.println(t);
            }
        }
    }
 
    void test2() {
        Map<String, Integer> intMap = new HashMap<>();
        System.out.println("\ngetSuperclass:" + intMap.getClass().getSuperclass());
        System.out.println("getGenericSuperclass:" + intMap.getClass().getGenericSuperclass());
        Type type = intMap.getClass().getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            ParameterizedType p = (ParameterizedType)type;
            for (Type t : p.getActualTypeArguments()) {
                System.out.println(t);
            }
        }
    }
 
    void test3() {
        Map<String, Integer> intMap = new HashMap<String, Integer>(){};
        System.out.println("\ngetSuperclass:" + intMap.getClass().getSuperclass());
        System.out.println("getGenericSuperclass:" + intMap.getClass().getGenericSuperclass());
        Type type = intMap.getClass().getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            ParameterizedType p = (ParameterizedType)type;
            for (Type t : p.getActualTypeArguments()) {
                System.out.println(t);
            }
        }
    }
 
    public static void main(String[] args) {
        TypeReferencBaseLearn obj = new TypeReferencBaseLearn();
        obj.test1();
        obj.test2();
        obj.test3();
    }
}

输出

// test1
getSuperclass:class java.util.HashMap
getGenericSuperclass:java.util.HashMap<java.lang.String, java.lang.Integer>
class java.lang.String
class java.lang.Integer

// test2 
getSuperclass:class java.util.AbstractMap
getGenericSuperclass:java.util.AbstractMap<K, V>
K
V
 
// test2
getSuperclass:class java.util.HashMap
getGenericSuperclass:java.util.HashMap<java.lang.String, java.lang.Integer>
class java.lang.String
class java.lang.Integer