protected修饰的构造方法在不同包中的使用

今天在转换json串的时候，看到了一种写法

MessageVO<String> messageVo = JSON.parseObject(msgContent, new TypeReference<MessageVO<String>>() {});

在最后边加了一对 ’ {} ’ ,刚开始对这个很迷惑，但是看了TypeReference的源码之后明白了

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

    protected TypeReference(Type... actualTypeArguments) {
        Class<?> thisClass = this.getClass();
        Type superClass = thisClass.getGenericSuperclass();
        ParameterizedType argType = (ParameterizedType)((ParameterizedType)superClass).getActualTypeArguments()[0];
        Type rawType = argType.getRawType();
        Type[] argTypes = argType.getActualTypeArguments();
        int actualIndex = 0;

        for(int i = 0; i < argTypes.length; ++i) {
            if (argTypes[i] instanceof TypeVariable && actualIndex < actualTypeArguments.length) {
                argTypes[i] = actualTypeArguments[actualIndex++];
            }

            if (argTypes[i] instanceof GenericArrayType) {
                argTypes[i] = TypeUtils.checkPrimitiveArray((GenericArrayType)argTypes[i]);
            }

            if (argTypes[i] instanceof ParameterizedType) {
                argTypes[i] = this.handlerParameterizedType((ParameterizedType)argTypes[i], actualTypeArguments, actualIndex);
            }
        }

        Type key = new ParameterizedTypeImpl(argTypes, thisClass, rawType);
        Type cachedType = (Type)classTypeCache.get(key);
        if (cachedType == null) {
            classTypeCache.putIfAbsent(key, key);
            cachedType = (Type)classTypeCache.get(key);
        }

        this.type = cachedType;
    }

我们可以看到他的构造方法使用protect方法修饰，也就是只能在当钱包中才能访问，别的包就不可以了，但是我们可以使用创建一个子类的方法去使用TypeReference的构造方法。

import com.alibaba.fastjson.TypeReference;

public class TypeTestChild<T> extends TypeReference<T> {
}

那么当我们写代码时，就可以使用子类的构造方法去访问父类的构造方法；

Map<String, Object> objectMapTest = JSON.parseObject(responseStr, new TypeTestChild<Map<String, Object>>());

这也就是我们之前看到的

MessageVO<String> messageVo = JSON.parseObject(msgContent, new TypeReference<MessageVO<String>>() {});```