把之前做的笔记又重新整理了一下,发现简单只看了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.java
public 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的使用原理:
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这些类的关系和概念。