Gson是一個Java庫，用來實現Json和Java對象之間的相互轉換。 Gson是一個託管在https://github.com/google/gson的開源項目。
Gson中主要的類是Gson，也可以使用類GsonBuilder在創建Gson對象的同時設置一些選項。
Gson對像在處理Json時不會保存任何狀態，所以使用者能夠很輕鬆的對同一個Gson對象進行多次序列化、反序列化等操作。
示例：基本使用
//SerializationGson gson = new Gson();gson.toJson(1); //==> prints 1gson.toJson("abcd"); //==> prints "abcd"gson.toJson(new Long(10)); //==> prints 10int[] values = { 1 };gson.toJson(values); //==> prints [1]//Deserializationint one = gson.fromJson("1", int.class);Integer one = gson.fromJson("1", Integer.class);Long one = gson.fromJson("1", Long.class);Boolean f = gson.fromJson("false", Boolean.class);String str = gson.fromJson("/"abc/"", String.class);String anotherStr = gson.fromJson("[/"abc/"]", String.class);//SerializationBagOfPrimitives obj = new BagOfPrimitives();Gson gson = new Gson();String json = gson.toJson(obj); //==> json is {"value1":1,"value2":"abc"}示例：對象與Json之間轉換
定義BagOfPrimitives類：
class BagOfPrimitives { private int value1 = 1; private String value2 = "abc"; private transient int value3 = 3; BagOfPrimitives() { // no-args constructor }}序列化為Json：
//SerializationBagOfPrimitives obj = new BagOfPrimitives();Gson gson = new Gson();String json = gson.toJson(obj); //==> json is {"value1":1,"value2":"abc"}不要序列化含有循環引用的對象，否則會造成無限的遞歸。
反序列化：
//DeserializationBagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class); //==> obj2 is just like obj
處理對象時的一些細節：
嵌套類（包括內部類）的處理
Gson可以很輕鬆地序列化嵌套類，且能夠反序列化靜態的嵌套類。 Gson無法自動地反序列化純粹的內部類，是因為內部類的無參構造函數需要引用包含它的對象（即外部類的實例）。要反序列化靜態類，可以將內部類靜態化或者提供一個自定義的實例創造器（instance creator）。下面是一個示例：
public class A { public String a; class B { public String b; public B() { // No args constructor for B } }}上面的類B無法被Gson序列化。由於類B是一個（非靜態的）內部類，Gson也無法反序列化{"b":"abc"}到類B的實例中。如果B被聲明為static class B，那麼Gson就能對這個字符串反序列化了。
另外一個解決方法是為B寫一個實例創建器：
public class InstanceCreatorForB implements InstanceCreator<AB> { private final A a; public InstanceCreatorForB(A a) { this.a = a; } public AB createInstance(Type type) { return a.new B(); }}這種方法是可行的，但是不推薦。 （譯者表示沒看懂這個實例創建器，不知道該怎麼用）
示例：數組
Gson gson = new Gson();int[] ints = {1, 2, 3, 4, 5};String[] strings = {"abc", "def", "ghi"};//Serializationgson.toJson(ints); ==> prints [1,2,3,4,5]gson.toJson(strings); ==> prints ["abc", "def", "ghi"]//Deserializationint[] ints2 = gson.fromJson("[1,2,3,4,5]", int[].class);==> ints2 will be same as intsGson也支持具有復雜數據類型的多維數組。
示例：集合（Collection）
Gson gson = new Gson();Collection<Integer> ints = Lists.immutableList(1,2,3,4,5);//SerializationString json = gson.toJson(ints); //==> json is [1,2,3,4,5]//DeserializationType collectionType = new TypeToken<Collection<Integer>>(){}.getType();Collection<Integer> ints2 = gson.fromJson(json, collectionType);//ints2 is same as ints處理集合(Collection)時的限制：
序列化/反序列化泛型
當使用toJson(obj)時，Gson調用obj.getClass()獲取字段信息以在序列化中使用。類似的，也可以將對象MyClass.class作為參數傳遞給fromJson(json, MyClass.class)方法，這可以在在對像不是泛型的時候使用。不過，當對像是一個泛型類型的對象，由於Java中類型擦除（Type Erasure）這一機制，泛型類型信息會丟失。下面的例子將說明這一點：
class Foo<T> { T value;}Gson gson = new Gson();Foo<Bar> foo = new Foo<Bar>();gson.toJson(foo); // May not serialize foo.value correctlygson.fromJson(json, foo.getClass()); // Fails to deserialize foo.value as Bar上面的代碼將value解釋為Bar類型，這是因為Gson調用foo.getClass()獲取類的信息，但是這種那個方法返回的是一個原始的類，即Foo.class。這意味著Gson無法知道這是一個Foo<Bar>類型的對象。
要解決這個問題，可以是為你的泛型指定正確的參數化的類型。可以使用TypeToken類做到：
Type fooType = new TypeToken<Foo<Bar>>() {}.getType();gson.toJson(foo, fooType);gson.fromJson(json, fooType);fooType實際上定義了一個匿名的內部類，這個內部類含有一個可以返回全部參數化類型的getType()方法。
序列化/反序列化含有任意類型的對象的集合
有時候處理的JSON包含了混合的類型，例如:
['hello',5,{name:'GREETINGS',source:'guest'}]對應的集合應該是：
Collection collection = new ArrayList();collection.add("hello");collection.add(5);collection.add(new Event("GREETINGS", "guest"));其中的Event類如下定義：
class Event { private String name; private String source; private Event(String name, String source) { this.name = name; this.source = source; }}通過Gson，你不需要做任何特殊的事情就可以序列化集合：toJson(collection)會輸出令人滿意的結果。
然而，通過fromJson(json, Collection.class)反序列化是不行的，這是因為Gson無法將json中的的內容與類型對應起來。 Gson需要你在fromJson中提供一個通用版本的集合類型。你有三個選擇：
方案1：使用Gson解析器的API（低級的流解析器或者DOM解析器JsonParser）去解析數組元素，然後使用Gson.fromJson()處理每一個數組元素。這是首選的方案。
方案2：為Collection.class註冊一類型適配器將數組中的元素映射到合適的對象。這種方法的缺點是會使你在處理其他的集合類型時候產生不便。
方案3：為MyCollectionMemberType註冊一個類型適配器，在fromJson中使用Collection<MyCollectionMemberType>。只有當數組看起來像一個高級的元素或者你能夠將字段類型改成Collection<MyCollectionMemberType>，這種方法才比較可行。
內置的序列化/反序列化器
Gson為常用的但是默認表示可能並不合適的類提供了序列化/反序列化器。
下面是這些類的一個列表：
自定義序列化/反序列化
有時候，Gson的默認實現並不是你想要的，這在處理一些類庫時（例如DateTime）時比較常見。
Gson允許你註冊自定義的序列化/反序列化器。要這樣做的話，你需要實現以下幾個部分：
Json序列化器：需要為一個對象自定義序列化
Json反序列化器：需要為一個類型自定義反序列化類創建器：如果存在無參構造函數或者已經註冊了一個反序列化器，就不需要了。
GsonBuilder gson = new GsonBuilder();gson.registerTypeAdapter(MyType2.class, new MyTypeAdapter());gson.registerTypeAdapter(MyType.class, new MySerializer());gson.registerTypeAdapter(MyType.class, new MyDeserializer());gson.registerTypeAdapter(MyType.class, new MyInstanceCreator());
registerTypeAdapter會檢查類型適配器是否實現了多個接口，並為這些接口註冊類型適配器。
寫一個序列化器
下面是一個為DateTime自定義序列化器的示例：
private class DateTimeSerializer implements JsonSerializer<DateTime> { public JsonElement serialize(DateTime src, Type typeOfSrc, JsonSerializationContext context) { return new JsonPrimitive(src.toString()); }}Gson在序列化DateTime實例時會調用toJson()。
寫一個反序列化器
下面的示例是講如何寫一個DateTime類的反序列化器：
private class DateTimeDeserializer implements JsonDeserializer<DateTime> { public DateTime deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException { return new DateTime(json.getAsJsonPrimitive().getAsString()); }}當Gson需要將一個JSON字符串發反序列化為DateTime對象時，會調用fromJson()。
對於序列化器/反序列化器，應注意：
寫一個實例創建器
在反序列化一個對象時，Gson需要創建一個類的實例。在序列化/反序列化時具有良好表現的類是指這個類擁有一個無參構造函數。通常，當處理一個類庫中沒有無參構造函數的類時，需要使用實例創建器。
實例創建器示例：
private class MoneyInstanceCreator implements InstanceCreator<Money> { public Money createInstance(Type type) { return new Money("1000000", CurrencyCode.USD); }}參數化類型的實例創建器
有時候要實例化的類型會是一個參數化類型。總的來說，由於真正的實例是一個原始類型，所以這不是什麼問題。下面是一個示例：
class MyList<T> extends ArrayList<T> {}class MyListInstanceCreator implements InstanceCreator<MyList<?>> { @SuppressWarnings("unchecked") public MyList<?> createInstance(Type type) { // No need to use a parameterized list since the actual instance will have the raw type anyway. return new MyList(); }}不過，有時你需要基於真正的參數化類型來創建實例。在這種情況下，你可以將類型參數傳遞給createInstance方法。下面是一個例子：
public class Id<T> { private final Class<T> classOfId; private final long value; public Id(Class<T> classOfId, long value) { this.classOfId = classOfId; this.value = value; }}class IdInstanceCreator implements InstanceCreator<Id<?>> { public Id<?> createInstance(Type type) { Type[] typeParameters = ((ParameterizedType)type).getActualTypeArguments(); Type idType = typeParameters[0]; // Id has only one parameterized type T return Id.get((Class)idType, 0L); }}在上面的示例中，如果沒有將真正的類型傳遞給參數化類型，Id類的實例是無法創建的。通過給方法傳遞參數type，我們才得以解決這個問題。這裡，type對象可以看做是Id<Foo>的Java參數化類型的表示，相應的實例應該被綁定到Id<Foo>。由於類Id只有一個參數化類型的參數T，我們使用getActualTypeArgument()返回的類型數組的第0個元素，在這個例子中就是Foo.class。
緊湊的輸出VS 優美的輸出
Gson中Json默認的輸出是緊湊的JSON格式。也就是說在JSON中沒有多餘的空白符。所以在JSON的輸出中字段名和字段值之間、字段之間、數組元素之間是沒有空白的。另外，null字段不會被輸出（注意：在集合和數組對像中null會被保留的）。
如果要輸出的優美些，你需要使用GsonBuilder對Gson的實例進行配置。 JsonFormatter不存在於公有API中，所以客戶端無法配置默認的輸出設置。現在我們只提供了JsonPrintFormatter，其默認情況下每行80個字符，縮進使用2個字符，右邊距是4個字符。
下面的示例展示瞭如何讓Gson實例使用JsonPrintFormatter，而不是使用默認的JsonCompactFormatter。
Gson gson = new GsonBuilder().setPrettyPrinting().create();String jsonOutput = gson.toJson(someObject);
空對象
在Gson的默認實現中，null對像是被忽略的。這可以讓輸出格式（既可以認為是序列化的結果）更加緊密；不過客戶端必須為其定義一個默認的值，以使得JSON能夠正常的反序列化。
如果要讓Gson實例可以序列化null，可以：
Gson gson = new GsonBuilder().serializeNulls().create();
注意，當序列化null的時，會在JsonElement結構中添加一個JsonNull元素。因此，我們可以可以在自定義的序列化器/反序列化器中使用這個對象（gson）。
下面是一個例子：
public class Foo { private final String s; private final int i; public Foo() { this(null, 5); } public Foo(String s, int i) { this.s = s; this.i = i; }}Gson gson = new GsonBuilder().serializeNulls().create();Foo foo = new Foo();String json = gson.toJson(foo);System.out.println(json);json = gson.toJson(null);System.out.println(json);輸出：
{"s":null,"i":5}null版本支持
可以使用@Since標註來維護同一個對象的多個版本。這個標註可以用在類和字段上，將來也會支持用在方法上。為了使用這個特性，你需要配置Gson實例，讓其忽略大於某個版本號的字段和對象。如果沒有在Gson對像中設置版本，序列化/反序列化時會使用所有的字段和類。
public class VersionedClass { @Since(1.1) private final String newerField; @Since(1.0) private final String newField; private final String field; public VersionedClass() { this.newerField = "newer"; this.newField = "new"; this.field = "old"; }}VersionedClass versionedObject = new VersionedClass();Gson gson = new GsonBuilder().setVersion(1.0).create();String jsonOutput = gson.toJson(someObject);System.out.println(jsonOutput);System.out.println();gson = new Gson();jsonOutput = gson.toJson(someObject);System.out.println(jsonOutput);輸出：
{"newField":"new","field":"old"}{"newerField":"newer","newField":"new","field":"old"}從序列化/反序列化中排除字段
Gson支持使用很多方法來去除類、字段、字段類型。如果下面的方法無法滿足你的需求，可以使用自定義序列化/反序列化器的方法。
1.Java Modifier Exclusion
默認情況下，如果將一個字段聲明為transient，這個字段就會被排除。另外，如果一個字段被聲明為static，默認情況下這個字段也會被排除。如果要包含某些聲明為transient的字段，你可以這樣做：
import java.lang.reflect.Modifier;Gson gson = new GsonBuilder() .excludeFieldsWithModifiers(Modifier.STATIC) .create();
注意，在excludeFieldsWithModifiers方法中，你可以使用任意數量的Modifier常量。例如：
Gson gson = new GsonBuilder() .excludeFieldsWithModifiers(Modifier.STATIC, Modifier.TRANSIENT, Modifier.VOLATILE) .create();
2.使用@Expose字段排除
這個特性允許你在類中標記特定的字段使其在序列化/反序列化中不被排除/被排除。要使用這個標註，你應該使用new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create()創建Gson。 Gson實例會排除類中所有沒被@Expose標註的字段。
3.用戶定義排除策略
如果上面的排除方法無法滿足需求，你也可以自定義自己的排除策略。更多內容，可以參考ExclusionStrategy JavaDoc。
下面的例子展示瞭如何排除使用了@Foo標註的字段，排除String類的頂級類型或者聲明的字段類型：
@Retention(RetentionPolicy.RUNTIME) @Target({ElementType.FIELD}) public @interface Foo { // Field tag only annotation } public class SampleObjectForTest { @Foo private final int annotatedField; private final String stringField; private final long longField; private final Class<?> clazzField; public SampleObjectForTest() { annotatedField = 5; stringField = "someDefaultValue"; longField = 1234; } } public class MyExclusionStrategy implements ExclusionStrategy { private final Class<?> typeToSkip; private MyExclusionStrategy(Class<?> typeToSkip) { this.typeToSkip = typeToSkip; } public boolean shouldSkipClass(Class<?> clazz) { return (clazz == typeToSkip); } public boolean shouldSkipField(FieldAttributes f) { return f.getAnnotation(Foo.class) != null; } } public static void main(String[] args) { Gson gson = new GsonBuilder() .setExclusionStrategies(new MyExclusionStrategy(String.class)) .serializeNulls() .create(); SampleObjectForTest src = new SampleObjectForTest(); String json = gson.toJson(src); System.out.println(json); }輸出：
{"longField":1234}JSON字段命名的支持
Gson的一些預定義的字段命名策略，可以將標準的Java字段名稱（也就是駝峰命名法，例如sampleFieldNameInJava）轉換成一個Json的字段名（也就是sample_field_name_in_java或者SampleFieldNameInJava）。更多信息，可以參考FieldNamingPolicy。
Gson也有一個基於標註的策略讓客戶端自定義字段的名稱。這個策略下，如果提供了一個非法的字段名作為標註的值，會使Gson拋出Runtime異常。
下面的示例展示瞭如何使用這兩種Gson命名策略：
private class SomeObject { @SerializedName("custom_naming") private final String someField; private final String someOtherField; public SomeObject(String a, String b) { this.someField = a; this.someOtherField = b; }}SomeObject someObject = new SomeObject("first", "second");Gson gson = new GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE).create();String jsonRepresentation = gson.toJson(someObject);System.out.println(jsonRepresentation);輸出：
{"custom_naming":"first","SomeOtherField":"second"}如果要自定義名稱，可以使用@SerializedName標註。
在序列化器和反序列化器之間共享狀態
有時你會需要在序列化器和反序列化器之間共享狀態，你可以使用下面的三個方法達到目的：
前兩種方法不是線程安全的，第三種是。
GSON解析null出錯解決辦法
GSON有一個缺點就是無法設置null替換，
我們只能手動的批量替換服務器返回的null了，正常的接口定義的時候是絕對不允許服務器返回null的，後台結果卻總會出現null！
如果搜索的話有一個常見的答案，
Gson gson = new GsonBuilder().serializeNulls().create();
但是這個卻無法解決反序列問題,怎麼解決呢？
解決辦法如下：
Gson gson = new GsonBuilder().registerTypeAdapterFactory(new NullStringToEmptyAdapterFactory()).create();//然後用上面一行寫的gson來序列化和反序列化實體類typegson.fromJson(json, type);gson.toJson(type);//NullStringToEmptyAdapterFactory的代碼public class NullStringToEmptyAdapterFactory<T> implements TypeAdapterFactory { @SuppressWarnings("unchecked") public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) { Class<T> rawType = (Class<T>) type.getRawType(); if (rawType != String.class) { return null; } return (TypeAdapter<T>) new StringNullAdapter(); }}// StringNullAdapter代碼public class StringNullAdapter extends TypeAdapter<String> { @Override public String read(JsonReader reader) throws IOException { // TODO Auto-generated method stub if (reader.peek() == JsonToken.NULL) { reader.nextNull(); return ""; } return reader.nextString(); } @Override public void write(JsonWriter writer, String value) throws IOException { // TODO Auto-generated method stub if (value == null) { writer.nullValue(); return; } writer.value(value); }}