Gson 2.8.5源码解析（一）

序列化

将java对象，转换为Json格式的字符串

Gson gson = new Gson();
String json = gson.toJson(book);

• 创建StringWriter对象，再将其包装为JsonWriter对象
• 根据TypeToken得到TypeAdapter，回调typeAdapter.write(jsonWriter, src)
• 最终返回的就是这个stringWriter.toString()

public String toJson(Object src) {
    return toJson(src, src.getClass());
  }

//构建StringWriter对象,并最终返回序列化之后的对象
 public String toJson(Object src, Type typeOfSrc) {
    StringWriter writer = new StringWriter(); //构建StringWriter对象
    toJson(src, typeOfSrc, writer);
    return writer.toString(); //最终返回序列化之后的对象
  }

//StringWriter包装为JsonWriter对象
public void toJson(Object src, Type typeOfSrc, Appendable writer) throws JsonIOException {
     JsonWriter jsonWriter = newJsonWriter(Streams.writerForAppendable(writer)); 
     toJson(src, typeOfSrc, jsonWriter);
  }

//得到一个TypeAdapter类型的对象，进行传入jsonWriter，和对象src，写成字节流
public void toJson(Object src, Type typeOfSrc, JsonWriter writer) throws JsonIOException {
    TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfSrc));
    ((TypeAdapter<Object>) adapter).write(writer, src);
  }

反序列化

将json字符串转换为java对象

Gson gson = new Gson();
Book book = gson.fromJson(jsonStr, Book.class);

• 构建StringReader对象，并包装为JsonReader对象
• 得到typeToken对应的typeAdapter对象
• typeAdapter.read(jsonReader) 返回一个java对象

ReflectiveTypeAdapterFactory中的Adapter进行read操作，会构建一个新对象，并将json字符串中的value写入对象T中。

public <T> T fromJson(String json, Class<T> classOfT) throws JsonSyntaxException {
    Object object = fromJson(json, (Type) classOfT);
    return Primitives.wrap(classOfT).cast(object); //将object对象强转为T对象
  }

public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException {
    StringReader reader = new StringReader(json); //构建StringReader对象
    T target = (T) fromJson(reader, typeOfT);
    return target;
  }

public <T> T fromJson(Reader json, Type typeOfT) throws JsonIOException, JsonSyntaxException {
    JsonReader jsonReader = newJsonReader(json); //StringReader对象包装为JsonReader对象
    T object = (T) fromJson(jsonReader, typeOfT);
    return object;
  }

public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {
      TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(typeOfT);
      TypeAdapter<T> typeAdapter = getAdapter(typeToken);
      T object = typeAdapter.read(reader);
      return object;
  }

TypeAdapter的获取

• 做了缓存处理（不太明白calls是个threadLocal对象）
• 遍历，直到遇到符合规则的factory，并生成TypeAdapter对象，并放入缓存中
• FutherTypeAdapter代理类，提供统一接口和处理

private final ThreadLocal<Map<TypeToken<?>, FutureTypeAdapter<?>>> calls
      = new ThreadLocal<Map<TypeToken<?>, FutureTypeAdapter<?>>>(); //每个线程保存一个Map对象

  private final Map<TypeToken<?>, TypeAdapter<?>> typeTokenCache 
  		= new ConcurrentHashMap<TypeToken<?>, TypeAdapter<?>>(); //存储着TypeToken和typeAdapter的对应关系

 public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {
 	//首先尝试从缓存里取，如果有则直接返回
    TypeAdapter<?> cached = typeTokenCache.get(type == null ? NULL_KEY_SURROGATE : type);
    if (cached != null) { 
      return (TypeAdapter<T>) cached;
    }
    //获取当前线程的Map对象（存储着TypeToken和FutureTypeAdapter的对应关系）
    Map<TypeToken<?>, FutureTypeAdapter<?>> threadCalls = calls.get();
    boolean requiresThreadLocalCleanup = false;
    //如果当前线程没有存储过map对象，则新建，并放入calls中
    if (threadCalls == null) {
      threadCalls = new HashMap<TypeToken<?>, FutureTypeAdapter<?>>();
      calls.set(threadCalls);
      requiresThreadLocalCleanup = true;
    }

   //从threadCalls这个map对象中取出TypeToken所对应的FutureTypeAdapter对象，如果存在，则直接返回
    FutureTypeAdapter<T> ongoingCall = (FutureTypeAdapter<T>) threadCalls.get(type);
    if (ongoingCall != null) {
      return ongoingCall;
    }

    try {
      FutureTypeAdapter<T> call = new FutureTypeAdapter<T>();
      threadCalls.put(type, call);
      //创建FutureTypeAdapter对象，并存入threadCalls中，保存TypeToken和FutureTypeAdapter的对应关系
      for (TypeAdapterFactory factory : factories) {
        TypeAdapter<T> candidate = factory.create(this, type);
        if (candidate != null) {
         //遍历，直到遇到符合规则的factory，并生成TypeAdapter对象。
          call.setDelegate(candidate); //设置代理对象，也就是说是由candidate对数据进行真正的处理
          typeTokenCache.put(type, candidate); //放入缓存中
          return candidate;
        }
      }
      throw new IllegalArgumentException("GSON (" + GsonBuildConfig.VERSION + ") cannot handle " + type);
    } finally {
    //这里大概是缓存里有了，就没必要存储了吧
      threadCalls.remove(type);
      if (requiresThreadLocalCleanup) {
        calls.remove();
      }
    }
  }

//FutureTypeAdapter继承自TypeAdpter，仅仅是代理模式，抽象出来，统一管理
 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);
    }
  }

Factory的来源

• 默认有41个factory，很多元数据的处理，String/Integer/Boolean等
• 对于我们这个案例来说，用的是ReflectiveTypeAdapterFactory
  

ReflectiveTypeAdapterFactory

• 工厂类，返回一个静态内部类Adapter，通过反射的方式读取写入相应的值

public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {

@Override
public <T> TypeAdapter<T> create(Gson gson, final TypeToken<T> type) {
    Class<? super T> raw = type.getRawType();
    ObjectConstructor<T> constructor = constructorConstructor.get(type); //返回一个构造方法
    return new Adapter<T>(constructor, getBoundFields(gson, type, raw)); //getBoundFileds通过反射拿到所有的filed
  }

 public static final class Adapter<T> extends TypeAdapter<T> {
    private final ObjectConstructor<T> constructor;
    private final Map<String, BoundField> boundFields;

    Adapter(ObjectConstructor<T> constructor, Map<String, BoundField> boundFields) {
      this.constructor = constructor;
      this.boundFields = boundFields;
    }
	
	//反序列化，JsonReader读取字节流，返回一个T类型的对象
    @Override public T read(JsonReader in) throws IOException {
      T instance = constructor.construct();
        in.beginObject();
        while (in.hasNext()) {
          String name = in.nextName();
          BoundField field = boundFields.get(name);
          if (field == null || !field.deserialized) {
            in.skipValue(); //
          } else {
            field.read(in, instance);
          }
        }
      in.endObject();
      return instance;
    }

	//序列化，T对象，通过JsonWriter进行写操作，最终writer.toString返回一个json类型的字符串
    @Override public void write(JsonWriter out, T value) throws IOException {
      out.beginObject();
        for (BoundField boundField : boundFields.values()) {
          if (boundField.writeField(value)) {
            out.name(boundField.name); //写入key值
            boundField.write(out, value); //写入value值
          }
        }
      out.endObject();
    }
  }
}

序列化、反序列化总结

• 序列化：将java对象转换为json类型的字符串
• 反序列化：将json字符串转换为Java对象
• 如果没有自定义TokenAdapter、JsonSerializer、JsonDeserializer，且为自定义对象类型，大都是通过ReflectiveTypeAdapterFactory中的Adapter进行write操作。

序列化：

1. 构建StringWriter对象，包装为JsonWriter对象
2. 得到typeToken对应的typeAdapter对象
3. 回调typeAdapter.write(jsonWriter, T)
4. 返回jsonWriter.toString()

反序列化：

1. 构建StringReader，并包装为JsonReader对象
2. 得到typeToken对应的typeAdapter对象
3. 回调typeAdapter.read(jsonReader)，返回java对象T