Gson源码分析

Gson(final Excluder excluder, final FieldNamingStrategy fieldNamingStrategy,
 final Map<Type, InstanceCreator<?>> instanceCreators, boolean serializeNulls,
 boolean complexMapKeySerialization, boolean generateNonExecutableGson, boolean htmlSafe,
 boolean prettyPrinting, boolean lenient, boolean serializeSpecialFloatingPointValues,
 LongSerializationPolicy longSerializationPolicy,
 List<TypeAdapterFactory> typeAdapterFactories) {

 ...

 factories.add(new ReflectiveTypeAdapterFactory(
 constructorConstructor, fieldNamingStrategy, excluder, jsonAdapterFactory));
}

public enum LongSerializationPolicy {
 DEFAULT() {
 @Override public JsonElement serialize(Long value){
 return new JsonPrimitive(value);
 }
 },

 STRING() {
 @Override public JsonElement serialize(Long value){
 return new JsonPrimitive(String.valueOf(value));
 }
 };

 public abstract JsonElement serialize(Long value);
}

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

public void toJson(Object src, Type typeOfSrc, JsonWriter writer) throws JsonIOException{
 TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfSrc));
 ...
 try {
 ((TypeAdapter<Object>) adapter).write(writer, src);
 } catch (Exception e) {
 ...
 }
}

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<?>> 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
 FutureTypeAdapter<T> ongoingCall = (FutureTypeAdapter<T>) threadCalls.get(type);
 if (ongoingCall != null) {
 return ongoingCall;
 }

 try {
 FutureTypeAdapter<T> call = new FutureTypeAdapter<T>();
 threadCalls.put(type, call);

 for (TypeAdapterFactory factory : factories) {
 TypeAdapter<T> candidate = factory.create(this, type);
 if (candidate != null) {
 call.setDelegate(candidate);
 typeTokenCache.put(type, candidate);
 return candidate;
 }
 }
 throw new IllegalArgumentException("GSON cannot handle " + type);
 } finally {
 threadCalls.remove(type);

 if (requiresThreadLocalCleanup) {
 calls.remove();
 }
 }
}

@Override 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!
 }

 ObjectConstructor<T> constructor = constructorConstructor.get(type);
 return new Adapter<T>(constructor, getBoundFields(gson, type, raw));
}

...

Adapter(ObjectConstructor<T> constructor, Map<String, BoundField> boundFields) {
 this.constructor = constructor;
 this.boundFields = boundFields;
}

private Map<String, BoundField> getBoundFields(Gson context, TypeToken<?> type, Class<?> raw){
 Map<String, BoundField> result = new LinkedHashMap<String, BoundField>();
 if (raw.isInterface()) {
 return result;
 }

 Type declaredType = type.getType();
 while (raw != Object.class) {
 Field[] fields = raw.getDeclaredFields();
 for (Field field : fields) {
 boolean serialize = excludeField(field, true);
 boolean deserialize = excludeField(field, false);
 if (!serialize && !deserialize) {
 continue;
 }
 field.setAccessible(true);
 Type fieldType = $Gson$Types.resolve(type.getType(), raw, field.getGenericType());
 List<String> fieldNames = getFieldNames(field);
 BoundField previous = null;
 for (int i = 0, size = fieldNames.size(); i < size; ++i) {
 String name = fieldNames.get(i);
 if (i != 0) serialize = false; // only serialize the default name
 BoundField boundField = createBoundField(context, field, name,
 TypeToken.get(fieldType), serialize, deserialize);
 BoundField replaced = result.put(name, boundField);
 if (previous == null) previous = replaced;
 }
 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;
}

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...
 JsonAdapter annotation = field.getAnnotation(JsonAdapter.class);
 TypeAdapter<?> mapped = null;
 if (annotation != null) {
 mapped = jsonAdapterFactory.getTypeAdapter(
 constructorConstructor, context, fieldType, annotation);
 }
 final boolean jsonAdapterPresent = mapped != null;
 if (mapped == null) mapped = context.getAdapter(fieldType);

 final TypeAdapter<?> typeAdapter = mapped;
 return new ReflectiveTypeAdapterFactory.BoundField(name, serialize, deserialize) {
 @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 = jsonAdapterPresent ? typeAdapter
 : new TypeAdapterRuntimeTypeWrapper(context, typeAdapter, fieldType.getType());
 t.write(writer, fieldValue);
 }
 @Override void read(JsonReader reader, Object value)
 throws IOException, IllegalAccessException {
 Object fieldValue = typeAdapter.read(reader);
 if (fieldValue != null || !isPrimitive) {
 field.set(value, fieldValue);
 }
 }
 @Override public boolean writeField(Object value) throws IOException, IllegalAccessException{
 if (!serialized) return false;
 Object fieldValue = field.get(value);
 return fieldValue != value; // avoid recursion for example for Throwable.cause
 }
 };
}

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 boolean writeField(Object value) throws IOException, IllegalAccessException;
 abstract void write(JsonWriter writer, Object value) throws IOException, IllegalAccessException;
 abstract void read(JsonReader reader, Object value) throws IOException, IllegalAccessException;
}

@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();
 BoundField field = boundFields.get(name);
 if (field == null || !field.deserialized) {
 in.skipValue();
 } else {
 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.writeField(value)) {
 out.name(boundField.name);
 boundField.write(out, value);
 }
 }
 } catch (IllegalAccessException e) {
 throw new AssertionError(e);
 }
 out.endObject();
}