序列化
将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操作。
序列化:
- 构建StringWriter对象,包装为JsonWriter对象
- 得到typeToken对应的typeAdapter对象
- 回调typeAdapter.write(jsonWriter, T)
- 返回jsonWriter.toString()
反序列化:
- 构建StringReader,并包装为JsonReader对象
- 得到typeToken对应的typeAdapter对象
- 回调typeAdapter.read(jsonReader),返回java对象T