fastjson TypeReference 揭秘

原文链接：https://muyig.github.io/blog/2020/01/10/TypeReference/

String userString = "[{\"userId\":\"111\",\"userName\":\"Tom\"},{\"userId\":\"222\",\"userName\":\"Jerry\"}]";
List<UserInfo> input = new ArrayList<>();
List<UserInfo> userInfoList = JSON.parseObject(userString, input.getClass());

java.lang.ClassCastException: com.alibaba.fastjson.JSONObject cannot be cast to com.vdian.dagon.core.user.UserInfo

List<UserInfo> userInfoList = JSON.parseObject(userString, new TypeReference<List<UserInfo>>() {});

@SuppressWarnings("unchecked")
public static <T> T parseObject(String text, TypeReference<T> type, Feature... features) {
    return (T) parseObject(text, type.type, ParserConfig.global, DEFAULT_PARSER_FEATURE, features);
}

new Runnable() {
    @Override
    public void run() {
        // ...
    }
};

new AbstractList<String>() {
    @Override
    public int size() {
        return 0;
    }

    @Override
    public String get(int index) {
        return null;
    }
};

new ArrayList<String>() {
    // 因为父类非抽象，因此不需要实现任何方法（当然如果想重写也是可以的）
};

public class TypeReference<T> {
    protected final Type type;

    /**
     * Constructs a new type literal. Derives represented class from type
     * parameter.
     *
     * <p>Clients create an empty anonymous subclass. Doing so embeds the type
     * parameter in the anonymous class's type hierarchy so we can reconstitute it
     * at runtime despite erasure.
     */
    protected TypeReference(){
        // 1. 获取当前类的父类的类型定义，由于我们采用了创建匿名子类的方式，所以这里拿到的就是 TypeReference的类型定义。
        Type superClass = getClass().getGenericSuperclass();
        // 2.强转为ParameterizedType，获取到泛型参数数组。
        Type type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
        // 省略缓存逻辑
        this.type = cachedType;
    }
    
    // 其他方法
}

public class ReflectionTest {

    static class SubArrayList1<E> extends ArrayList<E> {

    }

    static class SubArrayList2 extends ArrayList<String> {

    }

    private static void printSuperclass(Class<?> c) {
        Type superclass = c.getGenericSuperclass();
        ParameterizedType parameterizedType = (ParameterizedType) superclass;
        System.out.println("superclass:" + parameterizedType.getTypeName());
    }

    public static void main(String[] args) {
        SubArrayList1<String> subArrayList1 = new SubArrayList1<>();
        printSuperclass(subArrayList1.getClass());
        SubArrayList2 subArrayList2 = new SubArrayList2();
        printSuperclass(subArrayList2.getClass());
        printSuperclass(new ArrayList<String>() {}.getClass());
    }

}

superclass:java.util.ArrayList<E>
superclass:java.util.ArrayList<java.lang.String>
superclass:java.util.ArrayList<java.lang.String>

ReflectionTest.class :
没找到

ReflectionTest\$1.class :
Signature: #13                          // Ljava/util/ArrayList<Ljava/lang/String;>;

ReflectionTest\$SubArrayList1.class :
Signature: #16                          // <E:Ljava/lang/Object;>Ljava/util/ArrayList<TE;>;

ReflectionTest\$SubArrayList2.class :
Signature: #14                          // Ljava/util/ArrayList<Ljava/lang/String;>;

public class ReflectionTest {

    class TestInterface implements Callable<String>, Comparable<Integer> {

        @Override
        public String call() {
            return null;
        }

        @Override
        public int compareTo(Integer o) {
            return 0;
        }

    }

    private static void printInterfaces(Class<?> c) {
        Type[] types = c.getGenericInterfaces();
        for (Type type : types) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            System.out.println(parameterizedType.getTypeName());
        }
    }

    public static void main(String[] args) {
        printInterfaces(TestInterface.class);
    }

}

java.util.concurrent.Callable<java.lang.String>
java.lang.Comparable<java.lang.Integer>

ReflectionTest\$TestInterface.class : 
Signature: #32                          // Ljava/lang/Object;Ljava/util/concurrent/Callable<Ljava/lang/String;>;Ljava/lang/Comparable<Ljava/lang/Integer;>;

public class BaseGeneric<T> {

    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public BaseGeneric(T data) {
        this.data = data;
    }

    public BaseGeneric() {

    }

    public static void main(String[] args) {
        new BaseGeneric<String>() {};
    }

}

BaseGeneric.class
Signature: #31                          // <T:Ljava/lang/Object;>Ljava/lang/Object;

BaseGeneric$1.class
Signature: #13                          // Lcom/sunshinevvv/thinkinginjava/generics/BaseGeneric<Ljava/lang/String;>;