Gson在Android开发中，我们经常用到，主要用于把服务端给我们返回的json字符串，解析成相应的实体类，我们今天来看一下源码。
image.png
Gson通常是创建一个实例，然后调用toJson和fromJson方法使用。Gson实例是线程安全的，你可以在多线程中重用它
如果你只需要默认的配置，你可以通过调用new Gson（）来创建一个默认的实例。你也可以自定义配置，通过调用GsonBuilder来创建Gson实例。
image.png
Gson gson = new Gson();
Type listType = new TypeToken<List<String>>(){}.getType();
List<String> target = new LinkedList<>();
target.add("blah");
String json = gson.toJson(target,listType); //序列化
List<String> target2 = gson.fromJson(json,listType); //反序列化
关于TypeToken的问题
Type listType = new TypeToken<List<String>>(){}.getType();
创建TypeToken对象后面加了大括号，表示我们创建了一个匿名内部类。我们点进去TypeToken源码进去看一下
image.png
我们看这个构造器的修饰符是protected，不是public
/**
* Converts a tree of {@link JsonElement}s into its equivalent JSON representation.
*
* @param jsonElement root of a tree of {@link JsonElement}s
* @return JSON String representation of the tree
* @since 1.4
*/
public String toJson(JsonElement jsonElement) {
StringWriter writer = new StringWriter();
toJson(jsonElement, writer);
return writer.toString();
}
/**
* Writes out the equivalent JSON for a tree of {@link JsonElement}s.
*
* @param jsonElement root of a tree of {@link JsonElement}s
* @param writer Writer to which the Json representation needs to be written
* @throws JsonIOException if there was a problem writing to the writer
* @since 1.4
*/
public void toJson(JsonElement jsonElement, Appendable writer) throws JsonIOException {
try {
JsonWriter jsonWriter = newJsonWriter(Streams.writerForAppendable(writer));
toJson(jsonElement, jsonWriter);
} catch (IOException e) {
throw new JsonIOException(e);
}
}
这个方法是把实体序列化，转化为json字符串
image.png
TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfSrc)); //获取类型的TypeAdapter
/**
* Returns the type adapter for {@code} type.
*
* @throws IllegalArgumentException if this GSON cannot serialize and
* deserialize {@code type}.
*/
@SuppressWarnings("unchecked")
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 (" + GsonBuildConfig.VERSION + ") cannot handle " + type);
} finally {
threadCalls.remove(type);
if (requiresThreadLocalCleanup) {
calls.remove();
}
}
}
我们把String 转换成实体类，通常都这么写
Gson gson = new Gson();
String strJson = "{name:"1"}";
UserBean userBean = gson.fromJson(strJson, UserBean.class);
我们来看一下fromJson这个方法
@SuppressWarnings("unchecked")
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;
}
Gson支持以流的方式来读取字符
我们继续看源码
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;
TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(typeOfT);
TypeAdapter<T> typeAdapter = getAdapter(typeToken);
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，来获取这个类型对应的TypeToken
通过TypeToken来生成对应的适配器
最终转化成Object对象
Java在运行时，泛型参数的类型会被擦除，导致在运行期间所有的泛型类型都是Object类型
我们在代码中测试下：
List<String> listStr = new ArrayList<>();
List<Integer> listInt = new ArrayList<>();
Log.i("test-----", String.valueOf(listStr.getClass()));
Log.i("test----", String.valueOf(listInt.getClass()));
Log.i("test----", String.valueOf(listInt.getClass().isAssignableFrom(listStr.getClass())));
运行结果：
01-09 09:03:23.037 11017-11017/? I/test-----: class java.util.ArrayList
01-09 09:03:23.037 11017-11017/? I/test----: class java.util.ArrayList
01-09 09:03:23.037 11017-11017/? I/test----: true
说明Java运行时，泛型参数类型被擦除了
所以我再把数据转换成List型，要这么写
Type listType = new TypeToken<List<String>>(){}.getType();
List<String> target = new LinkedList<>();
target.add("blah");
List<String> target2 = gson.fromJson(json,listType); //反序列
TypeToken 类是用来解决java运行时泛型类型被擦除的，通过TypeToken可以获得具体的参数类型
我们在代码中测试一下：
List<String> list = new ArrayList<>();
TypeToken<ArrayList<String>> typeToken = new TypeToken<ArrayList<String>>(){};
Log.i("test------", String.valueOf(typeToken.getType()));
运行结果：
I/test------: java.util.ArrayList<java.lang.String>
