安卓常用第三方框架-Gson

Gson简介

json因其轻量、高效等特性，而被广泛用作移动开发的信息交互的载体。
我们知道AndroidSDK提供了org.json工具包来解析Json数据，但是仍然避免不了解析过程中的一系列重复工作。所以就出现了许多第三方JSON解析框架。JSON官方网站也给我们列出了在各种语言中JSON的解析策略:

可以看到java语言中解析JSON的库有很多，但由于移动设备硬件与软件等各方面的因素，在这些库中比较适合用于移动开发的主要有Gson和FastJson。
今天我们先来介绍以下Gson。

Gson是Google自家开发的，所以Google也极力推荐使用这个库来解析JSON数据。
Google自己是这么说的：已经有一些开源项目可用来将Java对象转换成JSON，然而这里面大多数需要你在Bean类中添加Java注解，很多时候需要你自己去写Bean对象，而且大多数也不支持Java泛型。所以Google开发Gson有以下几个开发目标：
1.提供超简单的toJson()和fromJson()方法来实现Java对象与JSON对象的相互转换。
2.允许不可变对象与JSON之间进行相互转换。
3.支持Java泛型
4.支持任何复杂的对象(深层包含与泛型)

添加Gradle依赖

compile 'com.google.code.gson:gson:2.8.0'

下载地址：

Github：https://github.com/google/gson
MVN：https://mvnrepository.com/artifact/com.google.code.gson/gson

API文档

http://www.javadoc.io/doc/com.google.code.gson/gson/2.8.0

GSON的使用

1. 创建Gson对象
   调用构造方法new Gson()，或者使用GsonBuilder类构造Gson对象
2. 调用toJson()或fromJson()方法
   Gson对象中toJson()方法用来序列化，fromJson()方法用来反序列化

示例

1、基本类型

// 序列化
Gson gson = new Gson();
gson.toJson(1);            // ==> 1
gson.toJson("abcd");       // ==> "abcd"
gson.toJson(new Long(10)); // ==> 10
int[] values = { 1 };
gson.toJson(values);       // ==> [1]

// 反序列化
int one = gson.fromJson("1", int.class);
Integer one = gson.fromJson("1", Integer.class);
Long one = gson.fromJson("1", Long.class);
Boolean false = gson.fromJson("false", Boolean.class);
String str = gson.fromJson("\"abc\"", String.class);
String[] anotherStr = gson.fromJson("[\"abc\"]", String[].class);

2、简单Java对象

class BagOfPrimitives {
  private int value1 = 1;
  private String value2 = "abc";
  private transient int value3 = 3;
  BagOfPrimitives() {
    // 无参构造
  }
}

// 序列化
BagOfPrimitives obj = new BagOfPrimitives();
Gson gson = new Gson();
String json = gson.toJson(obj);

// ==> 生成的JSON字符串是   {"value1":1,"value2":"abc"}
// 反序列化
BagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class);
// ==> obj2与obj内容相同

** 注意： **
1、序列化的Java对象不能包含循环引用(内部类的字段是外部类的引用)，因为这样会导致无限递归
2、默认情况下，当前类以及父类的所有字段都将被序列化
3、Java对象的字段被标记为transient，那么默认下情况该字段将不被序列化或反序列化
4、序列化时，默认会跳过值为null的字段；反序列化时，JSON中没有java对象对应的字段则值为空
5、字段是synthetic的，该字段将不被序列化或反序列化
6、可以使用@Expose注解来设置是否序列化类中的字段
7、可以使用@SerializedName注解设置序列化或反序列化时的key，其中alternate可以设置反序列化时备选的key
上面所说的默认情况，可以在使用GsonBuilder创建Gson对象之前进行设置。比如
serializeNulls()：用来配置是否序列化值为null的字段
disableInnerClassSerialization()：调用该方法后Gson对象将不会序列化内部类
setDateFormat()：设置Date类型的序列化格式
…

3、嵌套对象

Gson可以反序列化静态内部类，但是不能反序列化普通的非静态内部类，因为它们构造对象时需要传入外部类对象的引用。所以反序列化时要么使用静态内部类，要么为非静态内部类定义一个InstanceCreator(Gson中已经提供了该接口)。比如下面的例子：

public class A {
  public String a;

  class B {

    public String b;

    public B() {
      // B的无参构造
    }
  }
}

由于B类是内部类所以Gson不能将{“b”:”abc”}反序列化成B的实例。需要反序列化B类则需要将B类指定为静态内部类。另一种解决方案是为B类定义一个InstanceCreator。

public class InstanceCreatorForB implements InstanceCreator<A.B> {
	private final A a;
	public InstanceCreatorForB(A a)  {
		this.a = a;
	}
	  public A.B createInstance(Type type) {
	    return a.new B();
	}
}

后者虽然可行，但是Gson不推荐使用该方法。

4、数组

Gson gson = new Gson();
int[] ints = {1, 2, 3, 4, 5};
String[] strings = {"abc", "def", "ghi"};

// 序列化
gson.toJson(ints);     // ==> [1,2,3,4,5]
gson.toJson(strings);  // ==> ["abc", "def", "ghi"]

// 反序列化
int[] ints2 = gson.fromJson("[1,2,3,4,5]", int[].class);
// ==> ints2 与 ints值相同

5、集合对象

Gson gson = new Gson();
Collection<Integer> ints = Lists.immutableList(1,2,3,4,5);//Guava Collections库

// 序列化
String json = gson.toJson(ints);  // ==> json is [1,2,3,4,5]

// 反序列化
Type collectionType = new TypeToken<Collection<Integer>>(){}.getType();
Collection<Integer> ints2 = gson.fromJson(json, collectionType);
// ==> ints2 is same as ints

6、其他特殊情况

Collections集合的局限性
Gson能序列化任意的集合对象，但是不能反序列化，因为序列化成字符串不需要指定生成结果的类型，相反，反序列化时，使用哪个集合必须是指定的，泛型也必须是指定的。

1、泛型的序列化与反序列化

当你调用toJson(obj)时，Gson会调用obj.getClass()获取字段信息来序列化。类似地，在fromJson()方法中你可以传入Obj.class来指定你要实例化的对象。但是，如果对象是泛型(比如说Collections集合)，由于泛型对象的Java类型擦除(Java Type Erasure)而丢失类型信息。

class Foo<T> {
  T value;
}
Gson gson = new Gson();
Foo<Integer> foo = new Foo<Integer>();
gson.toJson(foo); // 无法正确序列化value值

gson.fromJson(json, foo.getClass()); // 反序列失败

上面的代码无法将value解析成Integer类型，因为Gson调用foo.getClass()来获取类信息返回的是原始的Foo.class。也就是说Gson无法知道这是一个Foo<Integer>对象。
我们可以通过指定正确的泛型参数来解决这个问题，Gson提供给我们TypeToken类，我们可以创建一个匿名内部类对象，该类中getType()方法可以获取完整的泛型参数。

Type fooType = new TypeToken<Foo<Bar>>() {}.getType();
gson.toJson(foo, fooType);

gson.fromJson(json, fooType);

2、序列化与反序列化混合类型的集合

某些时候可能需要处理包含混合类型的JSON数组，比如：
[ 'hello', 5, { name:'GREETINGS', source:'guest' } ]
与之等价的集合对象如下：

class Event {
  private String name;
  private String source;
  private Event(String name, String source) {
    this.name = name;
    this.source = source;
  }
}
Collection collection = new ArrayList();
collection.add("hello");
collection.add(5);
collection.add(new Event("GREETINGS", "guest"));

Gson gson = new Gson();
//序列化，不会出现任何问题
String json = gson.toJson(collection);
//反序列化的结果可能不符合要求
Collection json = gson.fromJson(json,ArrayList.class);

上面的collection对象可以不做任何处理使用toJson(collection)来序列化

但是你调用Gson.fromJson()方法反序列化，得到的结果可能不是你想要的。Gson.fromJson会要求你提供一个明确的集合类型。比如你在这里调用Collection c2 = gson.fromJson(json,ArrayList.class)，它会将5解析成字符串”5”，将 { name:'GREETINGS', source:'guest' }解析成含有两个元素的map映射。

这个问题，Gson提供了三种解决方式：

（1）、使用Gson的解析器：底层基于流的解析器JsonReader或基于文档树的解析器JsonParser，然后再使用Gson.fromJson方法解析数组的每一个对象。
(JsonReader和JsonParser类似于XML的SAX和DOM两种解析方式)

这是首选的方法。示例如下：

public class RawCollectionsExample {
	static class Event {
		private String name;
		private String source;
		private Event(String name, String source) {
			this.name = name;
		      	this.source = source;
		}
		@Override
		public String toString() {
			return String.format("(name=%s, source=%s)", name, source);
		}
	}

	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void main(String[] args) {
		Gson gson = new Gson();
		Collection collection = new ArrayList();
		collection.add("hello");
		collection.add(5);
		collection.add(new Event("GREETINGS", "guest"));
		String json = gson.toJson(collection);
		System.out.println("Using Gson.toJson() on a raw collection: " + json);
		JsonParser parser = new JsonParser();
		JsonArray array = parser.parse(json).getAsJsonArray();	//使用DOM解析器
		String message = gson.fromJson(array.get(0), String.class);
		int number = gson.fromJson(array.get(1), int.class);
		Event event = gson.fromJson(array.get(2), Event.class);
		System.out.printf("Using Gson.fromJson() to get: %s, %d, %s", message, number, event);
	  }
}

（2）、在使用GsonBuilder创建Gson时为Collection.class注册一个类型适配器(TypeAdapter)，这个适配器用于将数组的每个成员映射到合适的对象中，这种方法的缺点是，使用该Gson对象解析其他Collection对象也按照该适配器指定的方式进行反序列化。注册方法如下：（其中TypeAdapter需要自己实现）

①使用GsonBuilder创建Gson对象时设置
Gson gson = new GsonBuilder().registerTypeAdapter(Collection.class,TypeAdapter).builde();

②也可以使用@JsonAdapter注解对class设置相应的类型适配器

//使用JsonAdapter注解自定义序列化
@JsonAdapter(UserJsonAdapter.class)
public class User {
	public final String firstName, lastName;
	private User(String firstName, String lastName) {
		this.firstName = firstName;
		this.lastName = lastName;
	}
}
public class UserJsonAdapter extends TypeAdapter<User>; {
	@Override public void write(JsonWriter out, User user) throws IOException {
		//实现序列化
		out.beginObject();
		out.name("name");
		out.value(user.firstName + " " + user.lastName);
		out.endObject();
	}
	@Override public User read(JsonReader in) throws IOException {
		// 实现反序列化
		in.beginObject();
		in.nextName();
		String[] nameParts = in.nextString().split(" ");
		in.endObject();
		return new User(nameParts[0], nameParts[1]);
	}
}

• 3、与第2中方法类似，只是这里不使用Collection.class注册，而使用其他自定义类来注册，比如MyCollectionMemberType.class。然后再使用fromJson() 与 Collection的TypeToken。这种方法只适用于JSON数组作为顶层元素出现，或者将出现Collection的字段改为Collection。

3、自定义序列化与反序列化

有时候默认的表示方法不是不能满足你的需要，这经常出现在类似于Date，Point等特殊类型上。你可能需要将Data序列化成”YY-MM-DD”这种格式，或者将Point序列化成”(x,y)”这样的字符串，而不是将它们分为多个int存储。这个时候就需要在创建Gson对象时对这些特殊类型进行以下处理：

• 1、JSON序列化器(Json Serializers)：对该类型对象自定义一个序列化方法，用于将该对象的实例转换成JSON字符串。
• 2、JSON反序列化器(Json Deserializers)：为该类型自定义一个反序列化方法，用于从JSON字符串创建该类型的实例。
• 3、实例创建器(Instance Creators)：用于创建JSON对象，如果该对象有无参构造方法或者反序列化器，则实例创建器可以不需要。

  GsonBuilder gson = new GsonBuilder();
  gson.registerTypeAdapter(MyType.class, new MyTypeAdapter());
  gson.registerTypeAdapter(MyType.class, new MySerializer());
  gson.registerTypeAdapter(MyType.class, new MyDeserializer());
  gson.registerTypeAdapter(MyType.class, new MyInstanceCreator());

  示例

  1、序列化器

  下面是一个Date的自定义序列化器

  private class DateSerializer implements JsonSerializer<Date> {
  	public JsonElement serialize(Date date, Type typeOfSrc, JsonSerializationContext context) {
  		//将日期序列化成 YY-MM-DD的格式
  		return new JsonPrimitive(date.getYear() + "-" + date.getMonth()+ "-" + date.getDay());
  	}
  }

当Gson序列化碰到Date对象时，它就会调用DateSerializer.serialize()方法

2、反序列化器

private class DateDeserializer implements JsonDeserializer<Date> {
	public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
		//Date对象会直接将YY-MM-DD格式的字符串解析成对象
		return new Date(json.getAsJsonPrimitive().getAsString());
	}
}

当Gson反序列化JSON字符串片段会调用DateDeserializer.deserialize()方法来实例化Date对象。

3、实例创建器

当反序列化对象时，Gson需要创建类的实例，所以这个类最好是有一个无参构造方法(不论是public或private)
显然，实例创建器是为那些没有无参构造方法的类创建对象的。

private class MoneyInstanceCreator implements InstanceCreator<Money> {
	public Money createInstance(Type type) {
		return new Money("1000000", CurrencyCode.USD);
	}
}