GSON源码解析

把之前做的笔记又重新整理了一下，发现简单只看了GSON的解析流程；

1、GSON的两种解析使用方式：

1）直接利用GSON中默认的反射机制来解析：

Gson gson1 = new Gson();gson1.fromJson(str, Data.class);

2）利用自定义的TypeAdapter来解析：

// Builder模式GsonBuilder gsonBuilder = new GsonBuilder();// 注册自定义的Adapter;gsonBuilder.registerTypeAdapter(Data.class, new TypeAdapter<Data>() {    // 由对象组装成json    @Override    public void write(JsonWriter out, Data value) throws IOException {    }    // 解析成对应类对象    @Override    public Data read(JsonReader in) throws IOException {        return null;    }}.nullSafe());gson = gsonBuilder.create();

两种方式的区别前者主要使用ReflectiveTypeAdapterFactory通过反射机制来getField，setField；后者自定义了一个TypeAdapter，重写了read方法，该方法会根据自己定义返回一个解析好的类对象，因此可以自己控制解析的输出；

2、首先来看GSON是怎样区别使用两种解析TypeAdapter的：

GsonBuilder#registerTypeAdapter:

private final List<TypeAdapterFactory> factories = new ArrayList<TypeAdapterFactory>();// GSONBuilder.javapublic GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {    $Gson$Preconditions.checkArgument(typeAdapter instanceof JsonSerializer<?>            || typeAdapter instanceof JsonDeserializer<?>            || typeAdapter instanceof InstanceCreator<?>            || typeAdapter instanceof TypeAdapter<?>);    if (typeAdapter instanceof InstanceCreator<?>) {        instanceCreators.put(type, (InstanceCreator) typeAdapter);    }    // 解析原生类型    if (typeAdapter instanceof JsonSerializer<?> || typeAdapter instanceof JsonDeserializer<?>) {        TypeToken<?> typeToken = TypeToken.get(type);        factories.add(TreeTypeAdapter.newFactoryWithMatchRawType(typeToken, typeAdapter));    }    // 解析自定义的类    if (typeAdapter instanceof TypeAdapter<?>) {        // 创建一个TypeAdapterFactory，添加到一个List中保存        factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter) typeAdapter));    }    return this;}

将自定义的adapter的封装成TypeAdapterFactory对象，添加到一个List -- 中保存factories；后面将会看到TypeAdapterFactory的主要作用提供一个create方法，判断Type对应的TypeAdapter对象。

GsonBuilder#create:

public Gson create() {    List<TypeAdapterFactory> factories = new ArrayList<TypeAdapterFactory>();    // 将所有的factorie添加到factories中传递给新建的Gson对象    factories.addAll(this.factories);    // 进行reverse，可以看到后添加的自定义Adapter将会放到最前面    Collections.reverse(factories);    factories.addAll(this.hierarchyFactories);    addTypeAdaptersForDate(datePattern, dateStyle, timeStyle, factories);    return new Gson(excluder, fieldNamingPolicy, instanceCreators,            serializeNulls, complexMapKeySerialization,            generateNonExecutableJson, escapeHtmlChars, prettyPrinting,            serializeSpecialFloatingPointValues, longSerializationPolicy, factories);}

Builder模式，创建一个GSON对象，可以看到这里将GsonBuilder中定义的factories添加到Gson的factories形参中；添加之前进行一次reverse，所以最后添加到TypeAdapter会反转到链表的最前面；

再来看Gson的构造函数：

3、Gson:

Gson(final Excluder excluder, final FieldNamingStrategy fieldNamingPolicy,     final Map<Type, InstanceCreator<?>> instanceCreators, boolean serializeNulls,     boolean complexMapKeySerialization, boolean generateNonExecutableGson, boolean htmlSafe,     boolean prettyPrinting, boolean serializeSpecialFloatingPointValues,     LongSerializationPolicy longSerializationPolicy,     List<TypeAdapterFactory> typeAdapterFactories) {    .......    List<TypeAdapterFactory> factories = new ArrayList<TypeAdapterFactory>();    // built-in type adapters that cannot be overridden    factories.add(TypeAdapters.JSON_ELEMENT_FACTORY);    factories.add(ObjectTypeAdapter.FACTORY);    // the excluder must precede all adapters that handle user-defined types    factories.add(excluder);    // 自定义的TypeAdapter    factories.addAll(typeAdapterFactories);    // type adapters for basic platform types    // 这里一次性添加所有系统中可能用到的所有types对应的Adapter    factories.add(TypeAdapters.STRING_FACTORY);    factories.add(TypeAdapters.INTEGER_FACTORY);    factories.add(TypeAdapters.BOOLEAN_FACTORY);    factories.add(TypeAdapters.BYTE_FACTORY);    factories.add(TypeAdapters.SHORT_FACTORY);    factories.add(TypeAdapters.newFactory(long.class, Long.class,            longAdapter(longSerializationPolicy)));    factories.add(TypeAdapters.newFactory(double.class, Double.class,            doubleAdapter(serializeSpecialFloatingPointValues)));    factories.add(TypeAdapters.newFactory(float.class, Float.class,            floatAdapter(serializeSpecialFloatingPointValues)));    .......    factories.add(TypeAdapters.ENUM_FACTORY);    factories.add(TypeAdapters.CLASS_FACTORY);    // 这里便对应着自定义类时默认使用的ReflectiveTypeAdapterFactory    factories.add(new CollectionTypeAdapterFactory(constructorConstructor));    factories.add(new MapTypeAdapterFactory(constructorConstructor, complexMapKeySerialization));    factories.add(new ReflectiveTypeAdapterFactory(            constructorConstructor, fieldNamingPolicy, excluder));    this.factories = Collections.unmodifiableList(factories);}

这里添加了用户定义的TypeAdapter（注意是放在链表的前面）；然后添加系统中可能会用到的基本类型对应的TypeAdpater（如String，Integer等）；对于用户自定义的类，则使用 ReflectiveTypeAdapterFactory ，放在链表的最后；

来看解析过程：

4、Gson.fromJson:

public <T> T fromJson(String json, Class<T> classOfT) throws JsonSyntaxException {    Object object = fromJson(json, (Type) classOfT);    // 这里进行类型转换    return Primitives.wrap(classOfT).cast(object);}public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException {    if (json == null) {        return null;    }    StringReader reader = new StringReader(json);    T target = (T) fromJson(reader, typeOfT);    return target;}public <T> T fromJson(Reader json, Type typeOfT) throws JsonIOException, JsonSyntaxException {    JsonReader jsonReader = new JsonReader(json);    T object = (T) fromJson(jsonReader, typeOfT);    assertFullConsumption(object, jsonReader);    return object;}public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {    boolean isEmpty = true;    boolean oldLenient = reader.isLenient();    reader.setLenient(true);    try {        reader.peek();        isEmpty = false;        // 根据Type类型获取对应的解析Adapter        TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(typeOfT);        TypeAdapter<T> typeAdapter = getAdapter(typeToken);                // 执行TypeAdapter的read方法进行解析；可以看到如果是自定义的TypeAdapter，则会直接返回重写read方法中的返回值        T object = typeAdapter.read(reader);        return object;    } catch (EOFException e) {  /*   * For compatibility with JSON 1.5 and earlier, we return null for empty   * documents instead of throwing.   */        if (isEmpty) {            return null;        }        throw new JsonSyntaxException(e);    } catch (IllegalStateException e) {        throw new JsonSyntaxException(e);    } catch (IOException e) {        // TODO(inder): Figure out whether it is indeed right to rethrow this as JsonSyntaxException        throw new JsonSyntaxException(e);    } finally {        reader.setLenient(oldLenient);    }}

最后来到的解析函数中可以看到，基本的解析逻辑就是，根据Type类型获取对应的解析TypeAdapter，然后调用该 TypeAdapter的read方法进行解析，得到返回值。

先来看如何获得对应TypeAdapter:

5、Gson#getAdapter:

private final ThreadLocal<Map<TypeToken<?>, FutureTypeAdapter<?>>> calls        = new ThreadLocal<Map<TypeToken<?>, FutureTypeAdapter<?>>>();public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {    TypeAdapter<?> cached = typeTokenCache.get(type);    if (cached != null) {        return (TypeAdapter<T>) cached;    }    Map<TypeToken<?>, FutureTypeAdapter<?>> threadCalls = calls.get();    boolean requiresThreadLocalCleanup = false;    if (threadCalls == null) {        // 如果当前线程不存在，则创建一个新的        threadCalls = new HashMap<TypeToken<?>, FutureTypeAdapter<?>>();        calls.set(threadCalls);        requiresThreadLocalCleanup = true;    }    // the key and value type parameters always agree    // 判断该Type类型是否已经保存    FutureTypeAdapter<T> ongoingCall = (FutureTypeAdapter<T>) threadCalls.get(type);    if (ongoingCall != null) {        return ongoingCall;    }    try {        FutureTypeAdapter<T> call = new FutureTypeAdapter<T>();        threadCalls.put(type, call);        // 遍历factories中保存的所有factory        for (TypeAdapterFactory factory : factories) {            // TypeAdapterFactory的作用是将TypeAdapter同TypeToken组合到一起；            // 当type匹配时，返回已创建对象，否则返回null;所以可以通过判断返回值是否为null，来判断类型是否匹配            // 见附二            TypeAdapter<T> candidate = factory.create(this, type);            if (candidate != null) {                // 设置Delegate                call.setDelegate(candidate);                typeTokenCache.put(type, candidate);                return candidate;            }        }        throw new IllegalArgumentException("GSON cannot handle " + type);    } finally {        threadCalls.remove(type);        if (requiresThreadLocalCleanup) {            calls.remove();        }    }}

附一、 FutureTypeAdapter

// FutureTypeAdapter是对TypeAdapter的一个封装类，其实际工作委托给内部的delegate对象进行操作static class FutureTypeAdapter<T> extends TypeAdapter<T> {    private TypeAdapter<T> delegate;    public void setDelegate(TypeAdapter<T> typeAdapter) {        if (delegate != null) {            throw new AssertionError();        }        delegate = typeAdapter;    }    @Override public T read(JsonReader in) throws IOException {        if (delegate == null) {            throw new IllegalStateException();        }        return delegate.read(in);    }    @Override public void write(JsonWriter out, T value) throws IOException {        if (delegate == null) {            throw new IllegalStateException();        }        delegate.write(out, value);    }}

附二、TypeAdapterFactory：

public static <TT> TypeAdapterFactory newFactory(        final TypeToken<TT> type, final TypeAdapter<TT> typeAdapter) {    return new TypeAdapterFactory() {        @SuppressWarnings("unchecked") // we use a runtime check to make sure the 'T's equal        public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {            return typeToken.equals(type) ? (TypeAdapter<T>) typeAdapter : null;        }    };}

自定义的TypeAdapter直接调用其read方法即可；来看ReflectiveTypeAdapterFactory的使用原理：

6、ReflectiveTypeAdapterFactory：

public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {    private final ConstructorConstructor constructorConstructor;    private final FieldNamingStrategy fieldNamingPolicy;    private final Excluder excluder;    public ReflectiveTypeAdapterFactory(ConstructorConstructor constructorConstructor,                                        FieldNamingStrategy fieldNamingPolicy, Excluder excluder) {        this.constructorConstructor = constructorConstructor;        this.fieldNamingPolicy = fieldNamingPolicy;        this.excluder = excluder;    }    // 匹配Adapter的时候，返回的Adapter    public <T> TypeAdapter<T> create(Gson gson, final TypeToken<T> type) {        Class<? super T> raw = type.getRawType();        if (!Object.class.isAssignableFrom(raw)) {            return null; // it's a primitive!        }        // 创建一个Adapter，用来对应之前的通过type查找对应的TypeAdapter操作        ObjectConstructor<T> constructor = constructorConstructor.get(type);        return new Adapter<T>(constructor, getBoundFields(gson, type, raw));    }}

截取 ReflectiveTypeAdapterFactory中的其中一部分，其中constructorConstructor用来通过反射机制构造实例；getBoundFields用来获取一个BoundFields，BoundFields将Field的name和一个自定义的BoundFields联系到一起，其实创建该Type的实例是通过BoundFields中重写的read方法来实现的。

static abstract class BoundField {    final String name;    final boolean serialized;    final boolean deserialized;    protected BoundField(String name, boolean serialized, boolean deserialized) {        this.name = name;        this.serialized = serialized;        this.deserialized = deserialized;    }    abstract void write(JsonWriter writer, Object value) throws IOException, IllegalAccessException;    abstract void read(JsonReader reader, Object value) throws IOException, IllegalAccessException;}

1）先来看constructorConstructor：

public <T> ObjectConstructor<T> get(TypeToken<T> typeToken) {    final Type type = typeToken.getType();    final Class<? super T> rawType = typeToken.getRawType();    // first try an instance creator    @SuppressWarnings("unchecked") // types must agree    final InstanceCreator<T> typeCreator = (InstanceCreator<T>) instanceCreators.get(type);    if (typeCreator != null) {        return new ObjectConstructor<T>() {            public T construct() {                return typeCreator.createInstance(type);            }        };    }    // Next try raw type match for instance creators    @SuppressWarnings("unchecked") // types must agree    final InstanceCreator<T> rawTypeCreator =            (InstanceCreator<T>) instanceCreators.get(rawType);    if (rawTypeCreator != null) {        return new ObjectConstructor<T>() {            public T construct() {                return rawTypeCreator.createInstance(type);            }        };    }    // 创建一个默认构造器，用来创建实例    ObjectConstructor<T> defaultConstructor = newDefaultConstructor(rawType);    if (defaultConstructor != null) {        return defaultConstructor;    }    ObjectConstructor<T> defaultImplementation = newDefaultImplementationConstructor(type, rawType);    if (defaultImplementation != null) {        return defaultImplementation;    }    // finally try unsafe    return newUnsafeAllocator(type, rawType);}// 获取该Class的默认构造器，通过newInstance创建一个实例对象private <T> ObjectConstructor<T> newDefaultConstructor(Class<? super T> rawType) {    try {        final Constructor<? super T> constructor = rawType.getDeclaredConstructor();        if (!constructor.isAccessible()) {            constructor.setAccessible(true);        }        return new ObjectConstructor<T>() {            @SuppressWarnings("unchecked") // T is the same raw type as is requested            public T construct() {                try {                    Object[] args = null;                    return (T) constructor.newInstance(args);                } catch (InstantiationException e) {                    ..........                }            }        };    } catch (NoSuchMethodException e) {        return null;    }}

重点看下面的 newDefaultConstructor，它提供了一个ObjectConstructor实例，该对象中有个construct方法，在解析过程中将会调用来创建一个T实例instance；由上可以，通过获取该Class的构造函数，然后调用默认构造函数的newInstance来创建一个实例。

2）创建BoundFields:

private Map<String, BoundField> getBoundFields(Gson context, TypeToken<?> type, Class<?> raw) {    Map<String, BoundField> result = new LinkedHashMap<String, BoundField>();    // 如果数据类型是Interface的话，直接返回    if (raw.isInterface()) {        return result;    }    Type declaredType = type.getType();    while (raw != Object.class) {        // 获得该类的所有Field        Field[] fields = raw.getDeclaredFields();        // 遍历所有Field        for (Field field : fields) {            // 判断是否能够序列化            boolean serialize = excludeField(field, true);            boolean deserialize = excludeField(field, false);            if (!serialize && !deserialize) {                continue;            }            // 访问Field            field.setAccessible(true);            Type fieldType = $Gson$Types.resolve(type.getType(), raw, field.getGenericType());            // 创建BoundField，将Field的name和boundField绑定到一起            BoundField boundField = createBoundField(context, field, getFieldName(field),                    TypeToken.get(fieldType), serialize, deserialize);            //            BoundField previous = result.put(boundField.name, boundField);            if (previous != null) {                throw new IllegalArgumentException(declaredType                        + " declares multiple JSON fields named " + previous.name);            }        }        // 获取父类，重复上述操作        type = TypeToken.get($Gson$Types.resolve(type.getType(), raw, raw.getGenericSuperclass()));        raw = type.getRawType();    }    return result;}

通过getField获得该类的所有Field,然后由Field信息创建（createBoundField）一个BoundField，并通过HashMap将两者绑定到一起，便于查询；

来看 createBoundField：

private ReflectiveTypeAdapterFactory.BoundField createBoundField(        final Gson context, final Field field, final String name,        final TypeToken<?> fieldType, boolean serialize, boolean deserialize) {    final boolean isPrimitive = Primitives.isPrimitive(fieldType.getRawType());    // special casing primitives here saves ~5% on Android...    return new ReflectiveTypeAdapterFactory.BoundField(name, serialize, deserialize) {        // 根据fieldType获得相应的TypeAdapter        final TypeAdapter<?> typeAdapter = context.getAdapter(fieldType);        @SuppressWarnings({"unchecked", "rawtypes"}) // the type adapter and field type always agree        @Override        void write(JsonWriter writer, Object value) throws IOException, IllegalAccessException {            Object fieldValue = field.get(value);            TypeAdapter t = new TypeAdapterRuntimeTypeWrapper(context, this.typeAdapter, fieldType.getType());            t.write(writer, fieldValue);        }        @Override        void read(JsonReader reader, Object value) throws IOException, IllegalAccessException {            // 进而调用对应Type的TypeAdapter去实现            Object fieldValue = typeAdapter.read(reader);            if (fieldValue != null || !isPrimitive) {                field.set(value, fieldValue);            }        }    };}

这里创建一个BoundField实例，并且重写了read，write方法；从后面的TypeAdapter，可以看到这些的作用；

3） ReflectiveTypeAdapterFactory的内部类Adapter:

public static final class Adapter<T> extends TypeAdapter<T> {    private final ObjectConstructor<T> constructor;    private final Map<String, BoundField> boundFields;    private Adapter(ObjectConstructor<T> constructor, Map<String, BoundField> boundFields) {        this.constructor = constructor;        this.boundFields = boundFields;    }    @Override    public T read(JsonReader in) throws IOException {        // 为空值，直接返回        if (in.peek() == JsonToken.NULL) {            in.nextNull();            return null;        }        T instance = constructor.construct();        try {            in.beginObject();            while (in.hasNext()) {                String name = in.nextName();                // boundFields是个HashMap，这里通过Field的name获取对应的boundFields                BoundField field = boundFields.get(name);                if (field == null || !field.deserialized) {                    in.skipValue();                } else {                    // 最终的对象创建逻辑在boundField中的read中实现；                    field.read(in, instance);                }            }        } catch (IllegalStateException e) {            throw new JsonSyntaxException(e);        } catch (IllegalAccessException e) {            throw new AssertionError(e);        }        in.endObject();        return instance;    }    @Override    public void write(JsonWriter out, T value) throws IOException {        if (value == null) {            out.nullValue();            return;        }        out.beginObject();        try {            for (BoundField boundField : boundFields.values()) {                if (boundField.serialized) {                    out.name(boundField.name);                    boundField.write(out, value);                }            }        } catch (IllegalAccessException e) {            throw new AssertionError();        }        out.endObject();    }}

可以看到这里解析逻辑，即调用前面所述的constructor创建一个instance，然后遍历jsonReader，通过读取其中的name，查找对应的FieldBounds，然后调用FieldBounds中的read方法；再回到FieldBounds中的read方法，可以看到，其可以看做一个递归实现了，继续查找该Field的类型对应的Adapter，然后调用该TypeAdpter去创建相应对象，最后进行返回。

具体的解析逻辑分析完毕，主要通过Type找到对应的TypeAdapter，如果有自定义的，则直接调用自定义Adpter的read方法；否则，使用可以看到，均是反射来实现，通过newInstance来获取实例，通过getDeclaredFields来获取Field信息；其主要工作解析原理还没有具体分析：

其主要的解析原理在JsonReader中，因为GSON中涉及到蛮多泛型、数组的打包处理，所以还要理清楚Type,、ParameterizedType、GenericArrayType、TypeVariable、WildcardType这些类的关系和概念。