Java中TypeReference用法说明

TypeReference用途

在使用FastJson时，对于泛型的反序列化很多场景下都会使用到TypeReference，例如：

void testTypeReference() {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(9);
    list.add(4);
    list.add(8);
    JSONObject jsonObj = new JSONObject();
    jsonObj.put("a", list);
    System.out.println(jsonObj);

    List<String> list2 = jsonObj.getObject("a", new TypeReference<List<Integer>>(){});
    System.out.println(list2);
}

输出

{"a":[1,9,4,8]}
[1, 9, 4, 8]

TypeReference源码

使用TypeReference可以明确的指定反序列化的类型，具体实现逻辑参考TypeReference的构造函数　

protected 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;
}

其中核心的方法是：getActualTypeArguments，它可以得到父类的反省类型

ParameterizedType是一个记录类型泛型的接口，继承自Type，一共三方法:

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

TypeReference例证

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();
    }
}

输出

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

getSuperclass:class java.util.AbstractMap
getGenericSuperclass:java.util.AbstractMap<K, V>
K
V

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