GSON：
由谷歌开发的实现Java对象和JSON表达式相互转换的框架。
GSON简析
我们先来分析一下官方给出的框架使用代码：
Gson gson = new Gson(); // 或用建造者模式构建Gson对象GsonBuilder().create();
MyType target = new MyType();
String json = gson.toJson(target); // 序列化为Json
MyType target2 = gson.fromJson(json, MyType.class); // 反序列化为 target2
简要分析一下从这段代码可以看出的设计模式。一、建造者模式（GsonBuilder），二、门面模式（Gson类就是Gson框架的门面）。另外，作为Gson框架的核心类TypeAdapter里有两个设计模式：三、工厂模式（TypeAdapterFactory），四、适配器模式（TypeAdapter）。后续的文章我们将从这四个设计模式入手对Gson进行剖析。
GSON框架使用套路
作为一个最经典最常用的JSON解析框架，使用上已经无需多说了。直接上源码：
在app/build.gradle中添加依赖库：
dependencies{
implements 'com.google.code.gson:gson:2.8'
}
举下面这段JSON格式数据为例子，进行GSON解析。一般我们从后台get到的网络数据也就长这样。
[{"name":"Tom","age":20},
{"name":"James","age":30}]
定义Person类，拥有name和id两个字段，对应上面的JSON数据：
public class Person{
private String name;
private int age;
public String getName(){
return this.name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return this.age;
}
public void setAge(int age){
this.age = age;
}
}
一般从后台get到的都是GSON数组，可以用下面的程序解析。
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
String responseData = "[{\"name\":\"Tom\",\"age\":20},{\"name\":\"James\",\"age\":30}]";
parseJSONWithGSON(responseData);
}
private void parseJSONWithGSON(String jsonData){
Gson gson = new Gson();
List<Person> peopleList = gson.fromJson(jsonData,new TypeToken<List<Person>>(){}.getType());
for(Person people:peopleList){
System.out.println("name is"+people.getName()+" age is"+people.getAge() );
Log.d("MainAcitvity","name is "+people.getName());
Log.d("MainAcitvity","age is "+people.getAge());
}
}
}
Log图：
Gson对象的构造函数分析
Gson构造器共12个输入，如下所示：
1、final Excluder excluder,
默认：默认的排除器，具体得看Excluder类
2、final FieldNamingStrategy fieldNamingStrategy,
默认：使用IDENTITY命名规则
3、final Map<Type, InstanceCreator<?>> instanceCreators,
默认：emptyMap() 空Map
4、boolean serializeNulls,
默认：false 不支持空对象
5、boolean complexMapKeySerialization,
默认：false 不支持复杂Map的序列化
6、boolean generateNonExecutableGson,
默认：false 不生成可执行json
7、boolean htmlSafe,
默认：true 对html进行编码
8、boolean prettyPrinting,
默认：false 不支持输出格式化json
9、boolean lenient,
默认：false 使用标准json格式，不进行自定义
10、boolean serializeSpecialFloatingPointValues,
默认：false 不支持特殊浮点数序列化
11、LongSerializationPolicy longSerializationPolicy,
默认：默认的，具体得看LongSerializationPolicy类
12、List<TypeAdapterFactory> typeAdapterFactories
默认：空List
上源码分析：
public Gson() {
this(Excluder.DEFAULT, FieldNamingPolicy.IDENTITY,
Collections.<Type, InstanceCreator<?>>emptyMap(), DEFAULT_SERIALIZE_NULLS,
DEFAULT_COMPLEX_MAP_KEYS, DEFAULT_JSON_NON_EXECUTABLE, DEFAULT_ESCAPE_HTML,
DEFAULT_PRETTY_PRINT, DEFAULT_LENIENT, DEFAULT_SPECIALIZE_FLOAT_VALUES,
LongSerializationPolicy.DEFAULT, Collections.<TypeAdapterFactory>emptyList());
}
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) {
//ConstructorConstructor 用来统一调度 instanceCreators
this.constructorConstructor = new ConstructorConstructor(instanceCreators);
//排除器，在序列化对象的时候会根据使用者设置的规则排除一些数据
this.excluder = excluder;
//fieldNamingStrategy 负责命名规则的确定(比如大驼峰命名、小驼峰命名、下划线命名 等)
this.fieldNamingStrategy = fieldNamingStrategy;
//serializeNulls 是一个 boolean 类型的对象，用以表示是否支持空对象的序列化
this.serializeNulls = serializeNulls;
//是否要生成不可执行的 json
this.generateNonExecutableJson = generateNonExecutableGson;
//是否对 html 进行编码，即对部分符号进行转义(=、<、> 等)
this.htmlSafe = htmlSafe;
//是否在输出的时候格式化 json
this.prettyPrinting = prettyPrinting;
//是否设置 json 的自定义标准
this.lenient = lenient;
List<TypeAdapterFactory> factories = new ArrayList<TypeAdapterFactory>();
// 不能重写的内置类型适配器
factories.add(TypeAdapters.JSON_ELEMENT_FACTORY);
factories.add(ObjectTypeAdapter.FACTORY);
......
//设置对 long 类型的变量，是解析成字符串还是解析为 long 类型
TypeAdapter<Number> longAdapter = longAdapter(longSerializationPolicy);
//用于支持 double,float 类型的特殊值，比如 Infinity(无穷大) 或 -Infinity(负无穷大) 等
factories.add(TypeAdapters.newFactory(double.class, Double.class,
doubleAdapter(serializeSpecialFloatingPointValues)));
factories.add(TypeAdapters.newFactory(float.class, Float.class,
floatAdapter(serializeSpecialFloatingPointValues)));
// the excluder must precede all adapters that handle user-defined types
factories.add(excluder);
......
// //使用者自定义的 TypeAdapterFactory
factories.addAll(typeAdapterFactories);
......
factories.add(new CollectionTypeAdapterFactory(constructorConstructor));
//处理 Map 类型对象的 TypeAdapterFactory，会受到 complexMapKeySerialization 的影响
factories.add(new MapTypeAdapterFactory(constructorConstructor, complexMapKeySerialization));
......
this.factories = Collections.unmodifiableList(factories);
}
Gson对象的fromJson方法分析
fromJson方法一共又7个，我们调用的是fromJson(String json, Type typeOfT)。而fromJson(String json, Type typeOfT)调用fromJson(Reader json, Type typeOfT)调用fromJson(JsonReader reader, Type typeOfT)。
public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException {
if (json == null) {
return null;
}
//将字符串转成泛型T的主体方法
//StringReader 是一个 jdk 中存在的 String 和 Reader 的关联封装类
StringReader reader = new StringReader(json);
T target = (T) fromJson(reader, typeOfT);
return target;
}
继续追踪源码中的重载方法fromJson(Reader json, Type typeOfT)：
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;
}
继续追踪源码中的重载方法fromJson(JsonReader reader, Type typeOfT)：
public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {
boolean isEmpty = true;
boolean oldLenient = reader.isLenient();
// 打开 reader 的标准化检验
reader.setLenient(true);
try {
reader.peek();
isEmpty = false;
//TypeToken 本质上是 Class 的增强封装类
TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(typeOfT);
// TypeAdapter是Gson的核心类，进行匹配Json和对象
TypeAdapter<T> typeAdapter = getAdapter(typeToken);
// 生成对象并返回
T object = typeAdapter.read(reader);
return object;
} catch (EOFException e) {
if (isEmpty) {
return null;
}
throw new JsonSyntaxException(e);
} catch (IllegalStateException e) {
throw new JsonSyntaxException(e);
} catch (IOException e) {
throw new JsonSyntaxException(e);
} finally {
reader.setLenient(oldLenient);
}
}
参考文献
1、gson-2.8.0-javadoc.jar
2、Gson完全教程：https://www.jianshu.com/p/923a9fe78108
