1:到官网看下 gson的次要作用就是 Java Objects 和 JSON 之间的互相转换. 咱们看个最简略的例子.
@AllArgsConstructor
public static class Book{
private Integer id;
private String name;
}
public static void main(String[] args) {
Map<String,Book> map = Maps.newHashMap();
map.put("1", new Book(1,"1"));
map.put("2", new Book(2,"2"));
map.put("3", new Book(3,"3"));
final Gson gson = new Gson();
final String json = gson.toJson(map);
System.out.println(json);
final Map map1 = gson.fromJson(json, new TypeToken<Map<String,Book>>(){}.getType());
System.out.println(map1);
}
#输入后果
{"1":{"id":1,"name":"1"},"2":{"id":2,"name":"2"},"3":{"id":3,"name":"3"}}
{1=com.company.gson.Main$Book@491cc5c9, 2=com.company.gson.Main$Book@74ad1f1f, 3=com.company.gson.Main$Book@6a1aab78}
可见Java Object转成了json字符串,json字符串也反转为Java Object.
但此gson最值得钻研的中央就是从json自符串到Java Object对象过程中, 他怎么晓得要转换成Map<String,Book>这种对象构造？ 即整个转换的实践到底是什么？
2:咱们首先看下TypeToken到底是什么？
Map map1 = gson.fromJson(json, new TypeToken<Map<String,Book>>(){}.getType());通过剖析下面代码, new TypeToken<Map<String,Book>>(){}.getType() 是实例化了一个匿名外部类对象, 并且调用了这个匿名外部类对象的getType()办法.
要想晓得这个getType() 返回的是什么, 咱们必须到TypeToken类中看下源码.
#类申明
public class TypeToken<T> {
final Class<? super T> rawType;
final Type type;
final int hashCode;
#构造函数
@SuppressWarnings("unchecked")
protected TypeToken() {
this.type = getSuperclassTypeParameter(getClass());
this.rawType = (Class<? super T>) $Gson$Types.getRawType(type);
this.hashCode = type.hashCode();
}
public final Type getType() {
return type;
}可见TypeToken是个一般的泛型类. 而type变量就是保留了参数化类型对象. 见下图. 其实type就是ParameterizedType类型对象 理论实现类为sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl.
通过该对象能够获取泛型的理论对象,
p.getActualTypeArguments();
p.getRawType()通过下面两个办法,就能够获取泛型的理论类型 即:
java.util.Map<java.lang.String,com.company.gson.Main$Book>
理论就是咱们匿名外部类传入的想要转成的Java Object.
题外话: 想要弄清楚ParameterizedType 能够看下java里的Type接口的系列.
到此:咱们能够得出结论,咱们其实要反序列化,须要通知gson反序列化后的类型是什么, 此处通过匿名外部类把泛型传入进去. gson通过ParameterizedType获取到理论的类型 [见ParameterizedType接口的办法].
3:持续剖析源码
public <T> T fromJson(Reader json, Type typeOfT) throws JsonIOException, JsonSyntaxException {
JsonReader jsonReader = newJsonReader(json);
T object = (T) fromJson(jsonReader, typeOfT);
assertFullConsumption(object, jsonReader);
return object;
}入参是json字符传 和 typeOfT[理论是参数化类型对象,能够获取泛型的理论类型]. 所以外围反序列化代码进入到
T object = (T) fromJson(jsonReader, typeOfT);
只看外围代码
1:第一步
TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(typeOfT);
2:第二步
TypeAdapter<T> typeAdapter = getAdapter(typeToken);
3:第三步
T object = typeAdapter.read(reader);第一步:是通过TypeToken.get(typeOfT又返回一个TypeToken对象,此处能够进去看下是否还要咱们的匿名外部类对象有关系.代码如下:
/**
* Gets type literal for the given {@code Type} instance.
*/public static TypeToken<?> get(Type type) {
return new TypeToken<Object>(type);
}可见间接new了个TypeToken对象 并且把type间接传进去.
第二步:是通过typeToken对象返回一个TypeAdapter对象 间接看代码.
可见外围代码是 List<TypeAdapterFactory> factories;
遍历factories 并调用每一个工厂办法,传入gson对象和type类型 生成对应的TypeAdapter.
至此:gson的核心思想也就找到了, 就是依据不同的type，生成不同的TypeAdapter.
以后的工厂对象有这么多
而我例子中应用的是 MapTypeAdapterFactory
找到factories初始化的中央.
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);
// user's type adapters
factories.addAll(typeAdapterFactories);
// type adapters for basic platform types
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);
TypeAdapter<Number> longAdapter = longAdapter(longSerializationPolicy);
factories.add(TypeAdapters.newFactory(long.class, Long.class, longAdapter));
factories.add(TypeAdapters.newFactory(double.class, Double.class,
doubleAdapter(serializeSpecialFloatingPointValues)));
factories.add(TypeAdapters.newFactory(float.class, Float.class,
floatAdapter(serializeSpecialFloatingPointValues)));
factories.add(TypeAdapters.NUMBER_FACTORY);
factories.add(TypeAdapters.ATOMIC_INTEGER_FACTORY);
factories.add(TypeAdapters.ATOMIC_BOOLEAN_FACTORY);
factories.add(TypeAdapters.newFactory(AtomicLong.class, atomicLongAdapter(longAdapter)));
factories.add(TypeAdapters.newFactory(AtomicLongArray.class, atomicLongArrayAdapter(longAdapter)));
factories.add(TypeAdapters.ATOMIC_INTEGER_ARRAY_FACTORY);
factories.add(TypeAdapters.CHARACTER_FACTORY);
factories.add(TypeAdapters.STRING_BUILDER_FACTORY);
factories.add(TypeAdapters.STRING_BUFFER_FACTORY);
factories.add(TypeAdapters.newFactory(BigDecimal.class, TypeAdapters.BIG_DECIMAL));
factories.add(TypeAdapters.newFactory(BigInteger.class, TypeAdapters.BIG_INTEGER));
factories.add(TypeAdapters.URL_FACTORY);
factories.add(TypeAdapters.URI_FACTORY);
factories.add(TypeAdapters.UUID_FACTORY);
factories.add(TypeAdapters.CURRENCY_FACTORY);
factories.add(TypeAdapters.LOCALE_FACTORY);
factories.add(TypeAdapters.INET_ADDRESS_FACTORY);
factories.add(TypeAdapters.BIT_SET_FACTORY);
factories.add(DateTypeAdapter.FACTORY);
factories.add(TypeAdapters.CALENDAR_FACTORY);
factories.add(TimeTypeAdapter.FACTORY);
factories.add(SqlDateTypeAdapter.FACTORY);
factories.add(TypeAdapters.TIMESTAMP_FACTORY);
factories.add(ArrayTypeAdapter.FACTORY);
factories.add(TypeAdapters.CLASS_FACTORY);
// type adapters for composite and user-defined types
factories.add(new CollectionTypeAdapterFactory(constructorConstructor));
factories.add(new MapTypeAdapterFactory(constructorConstructor, complexMapKeySerialization));
this.jsonAdapterFactory = new JsonAdapterAnnotationTypeAdapterFactory(constructorConstructor);
factories.add(jsonAdapterFactory);
factories.add(TypeAdapters.ENUM_FACTORY);
factories.add(new ReflectiveTypeAdapterFactory(
constructorConstructor, fieldNamingStrategy, excluder, jsonAdapterFactory));
this.factories = Collections.unmodifiableList(factories);可见gson给咱们枚举了所有可能用到的工厂, 依据咱们反序列化的类型,依据工厂对象生成对应的TypeAdapter，并进而实现反序列化.
第三步：就是通过TypeAdapter 把JSON转成Java Object对象
发表回复