1.概述
2.Gson的目標(biāo)
3.Gson的性能和擴(kuò)展性
4.Gson的使用者
5.如何使用Gson

• 通過Maven來使用Gson
• 基本舉例
• 對(duì)象舉例
• 使用對(duì)象的好處
• 嵌套類（包括內(nèi)部類）
• 數(shù)組舉例
• 集合舉例
• 集合的局限性
• 泛型的序列化和反序列化
• 任意類型集合的序列化和反序列化
• 內(nèi)置的序列化器和反序列化器
• 定制的序列化和反序列化
• 寫一個(gè)序列化解釋器
• 寫一個(gè)反序列化解釋器
• 寫一個(gè)實(shí)例化工廠(Writing a Instance Creator)
• 一個(gè)參數(shù)化類型的實(shí)例工廠(InstanceCreator for a Parameterized Type)
• 簡潔和美觀的Json格式化輸出
• 支持Null對(duì)象
• 支持版本化
• 忽略序列化和反序列化中的字段
• Java修飾符忽略
• Gson's @Expose
• 自定義忽略策略
• JSON字段取名幫助
• 通過經(jīng)典的序列化器和反序列化器分享狀態(tài)
• 流
  6.在設(shè)計(jì)Gson中一些問題
  7.未來Gson需要加強(qiáng)的方面

概述

Gson是一個(gè)Java庫，它不僅可以把Java對(duì)象轉(zhuǎn)化為Json格式，它也能將一段Json格式的字符串轉(zhuǎn)化為相對(duì)于的Java對(duì)象。
Gson適用于所有Java對(duì)象，即使是那些你不知道源代碼的對(duì)象。
Gson的目標(biāo)

• 提供簡單易用的方法比如 toString() ，構(gòu)造方法來轉(zhuǎn)化JAVA為JSON以及反轉(zhuǎn)化。
• 提供已存在的不可修改對(duì)象轉(zhuǎn)化為JSON以及反轉(zhuǎn)化。
• 提供對(duì)象的慣例表示
• 支持任意復(fù)雜對(duì)象
• 生成健壯 可讀的JSON輸出

Gson的性能和擴(kuò)展性

這里提供我們跑測(cè)試的電腦配置(dual opteron, 8GB RAM, 64-bit Ubuntu),你可以通過使用PerformanceTest類來運(yùn)行測(cè)試

• 能正常反序列化25MB大小的字符串(參照 PerformanceTest中的disabled_testStringDeserializationPerformance)
• 超大集合：
• 能正常序列化一百四十萬對(duì)象(參見PerformanceTest中的disabled_testLargeCollectionSerialization)
• 能正常反序列化87000個(gè)對(duì)象的集合(參見PerformanceTest中的disabled_testLargeCollectionDeserialization)
• Gson 1.4 將反序列的字節(jié)數(shù)組和集合限制從80KB提高到11MB。
  注意：刪除 disabled_前綴 來運(yùn)行這些TEST,我們使用這個(gè)前綴來阻止運(yùn)行這些測(cè)試樣例當(dāng)我們運(yùn)行Junit的測(cè)試樣例。

Gson的使用者

Gson最初創(chuàng)建是為了Google內(nèi)部大量的項(xiàng)目所使用，它現(xiàn)在被很多的開源項(xiàng)目和公司使用。

使用Gson

你可以使用 new Gson()方法 作為使用Gson的開始。 還有一個(gè)類GsonBuilder來創(chuàng)建一個(gè)Gson實(shí)例, 通過這個(gè)類你可以設(shè)置各種參數(shù)包括版本控制等等...

當(dāng)你調(diào)用Json操作時(shí)，Gson實(shí)例不會(huì)維護(hù)任何狀態(tài), 所以你可以所以復(fù)用相同的對(duì)象來重復(fù)Json的序列化和反序列操作。

通過Maven來使用Gson

通過Maven2/3來使用Gson, 添加下面的依賴來在Maven使用Gson
<dependencies> <dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> <version>2.5</version> <scope>compile</scope> </dependency> </dependencies>
現(xiàn)在你的Maven項(xiàng)目就可以使用Gson

基礎(chǔ)舉例

// SerializationGson gson = new Gson();gson.toJson(1);// ==> 1 gson.toJson("abcd"); // ==> "abcd" gson.toJson(new Long(10)); // ==> 10 int[] values = { 1 }; gson.toJson(values); // ==> [1] // Deserialization 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);

對(duì)象舉例

class BagOfPrimitives { private int value1 = 1; private String value2 = "abc"; private transient int value3 = 3; BagOfPrimitives() { // no-args constructor } } // Serialization BagOfPrimitives obj = new BagOfPrimitives(); Gson gson = new Gson(); String json = gson.toJson(obj); // ==> json is {"value1":1,"value2":"abc"}
注意 不要序列對(duì)象中使用循環(huán)引用，因?yàn)樗鼘?huì)導(dǎo)致無限遞歸
// DeserializationBagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class);// ==> obj2 is just like obj

使用對(duì)象時(shí)的一些細(xì)節(jié)

• 最好使用private修飾符
• 不需要通過注釋來表明哪些字段需要被序列化和反序列化，默認(rèn)當(dāng)前類的所有字段都會(huì)被包括
• 如果一個(gè)字段被表示為 transient(默認(rèn)) 它將會(huì)被忽略 不會(huì)被包含在Json序列化或者反序列化中
• nulls會(huì)被正確處理
• 當(dāng)序列化時(shí) 一個(gè)Null字段會(huì)在輸出時(shí)被跳過
• 當(dāng)反序列化時(shí) Json中一個(gè)缺失的實(shí)體會(huì)自動(dòng)設(shè)置相對(duì)應(yīng)的字段為null
• 如果一個(gè)字段是合成的，它會(huì)被直接忽略 也不會(huì)被包含在JSON的序列化和反序列化中。
• 在內(nèi)部類 匿名類 本地類中 相對(duì)應(yīng)外部類的字段會(huì)被忽略，也不會(huì)被包含在JSON的序列化和反序列化中。

嵌套類(包括內(nèi)部類)

Gson可以非常輕松的序列化靜態(tài)內(nèi)部類
Gson也可以反序列化靜態(tài)類，Gson不能自動(dòng)反序列化完全內(nèi)部類(pure inner classes) 因?yàn)樗麄儫o參構(gòu)造函數(shù)需要一個(gè)內(nèi)部對(duì)象的引用,然而這個(gè)引用在反序列化的時(shí)候是不可用的,你可以這樣處理這個(gè)問題，要么使這個(gè)內(nèi)部類靜態(tài)化，或者為他提供一個(gè)靜態(tài)工廠方法(instanceCreator),舉個(gè)例子：
public class A { public String a; class B { public String b; public B() { // No args constructor for B } } }
注意 上面的B類默認(rèn)是不能被Gson序列化
Gson 不能反序列化{"a":"abc"} 進(jìn)B實(shí)例 因?yàn)锽類是一個(gè)內(nèi)部類 如果它被定義為靜態(tài)類ClassB Gson就能反序列化字符串 另外一個(gè)解決方案就是為B類寫一個(gè)靜態(tài)工廠方法
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(); } }
上面解決方法是可行的，但是并不建議這么使用

數(shù)組舉例

Gson gson = new Gson(); int[] ints = {1, 2, 3, 4, 5}; String[] strings = {"abc", "def", "ghi"}; // Serialization gson.toJson(ints); // ==> [1,2,3,4,5] gson.toJson(strings); // ==> ["abc", "def", "ghi"] // Deserialization int[] ints2 = gson.fromJson("[1,2,3,4,5]", int[].class); // ==> ints2 will be same as ints
我們也支持多維數(shù)組，任何復(fù)雜元素類型。

集合舉例

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] // Deserialization Type collectionType = new TypeToken<Collection<Integer>>(){}.getType(); Collection<Integer> ints2 = gson.fromJson(json, collectionType); // ==> ints2 is same as ints
十分可怕： 注意我們是如何定義集合的類型，但是不幸的是，在Java中沒有辦法獲取。

集合的局限性

• 可以序列化集合的任意對(duì)象 但是無法從中反序列化
• 因?yàn)槭褂谜吒緵]有辦法聲明一個(gè)結(jié)果對(duì)象的類型
• 當(dāng)序列化的時(shí)候，集合必須是一個(gè)特定泛型
  當(dāng)遵循好的JAVA編碼格式， 這一切都能解釋通， 也不會(huì)成為問題。

序列化和反序列泛型類型

當(dāng)你調(diào)用 toJson(obj) Gson會(huì)調(diào)用 obj.getClass來獲取序列化字段的信息。類似，你可以特意指定MyClass.class 對(duì)象在fromJson(json,MyClass.class)方法，這種方式運(yùn)行正常當(dāng)它不是泛型類型，然而，當(dāng)對(duì)象是一個(gè)泛型類型的時(shí)候，泛型類型的信息會(huì)丟失因?yàn)镴ava類型的擦拭，下面這個(gè)例子來展示這一點(diǎn)。
class Foo<T> { T value; } Gson gson = new Gson(); Foo<Bar> foo = new Foo<Bar>(); gson.toJson(foo); // May not serialize foo.value correctly gson.fromJson(json, foo.getClass()); // Fails to deserialize foo.value as Bar
上面的代碼不能解析Bar類型的值 ，因?yàn)楫?dāng)Gson調(diào)用list.getclass()來獲得類的信息時(shí)候，這個(gè)方法返回一個(gè)未處理的類 Foo.class 這意味著Gson根本無法知道這是一個(gè)Foo<Bar>類型的對(duì)象，而不是一個(gè)無格式的Foo

你可以通過為你的泛型類型指定一個(gè)正確的參數(shù)來解決這個(gè)問題,你也可以通過使用TypeToken類來處理這個(gè)問題。

Type fooType = new TypeToken<Foo<Bar>>() {}.getType(); gson.toJson(foo, fooType); gson.fromJson(json, fooType);
我們通常獲取fooType 的方式是定義一個(gè)匿名內(nèi)部類，其中包含一個(gè)getType方法返回一個(gè)全部的參數(shù)類型。

任意類型集合的序列化和反序列化

有時(shí) 你處理的是JSON數(shù)組包含了混合類型 例如 ['hello',5, {name:'GREETINGS',source:'guest'}]
集合實(shí)現(xiàn)這種JSON格式是通過：
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; } }
你不需要做額外的操作 當(dāng)用Gson的toJson(collection)來序列化集合 獲得想要的輸出結(jié)果

然而 使用fromJson(json,Collection.class)反序列化卻失效， 因?yàn)镚son沒辦法知道如何將結(jié)果映射到類型上，Gson要求你提供一個(gè)泛型版本的集合類型在fromJson(), 所以你有三個(gè)選擇：

1. 使用 Gson's 解析API（低版本的流解析或者DOM解析） 來解析數(shù)組元素 然后使用Gson.fromJson()在對(duì)應(yīng)的數(shù)組元素上，這是一個(gè)比較好的解決方案，通過一個(gè)例子來說明如何使用。
2. 為Collection.class注冊(cè)一個(gè)類型adapter，來把每一個(gè)數(shù)組成員都映射到對(duì)應(yīng)的對(duì)象，這個(gè)方法不好之處在于它會(huì)混淆其他集合類型的反序列化
3. 為MyCollectionMemberType注冊(cè)一個(gè)類型adapter 通過
   Collection<MyCollectionMemberType>來使用fromjson()
   這個(gè)方法僅用于數(shù)組以頂層元素出現(xiàn) 或者 你可以通過集合的類型Collection<MyCollectionMemberType>來改變字段的類型
   .

內(nèi)置的序列化器和反序列化器

Gson擁有內(nèi)置的序列化器和反序列化器，為那些默認(rèn)顯示可能不合適的常用類，下面是這些類的清單：

1. java.net.URL to match it with strings like "https://github.com/google/gson/"
2. java.net.URI to match it with strings like "/google/gson/"
   你也可以找一些常用類的源代碼 比如JodaTime

定制的序列化和反序列化

有時(shí) 默認(rèn)的表示可能不是你想要的，這常常發(fā)生當(dāng)處理庫類的時(shí)候（DateTime, etc）Gson允許你來注冊(cè)你直接的常用的序列化和反序列化， 通常通過定義這兩部分來完成。

• Json Serialiers: 需要為對(duì)象定義序列化
• Json Deserializers： 為需要的類型定義反序列化
• InstanceCreator： 一般不需要 如果無參構(gòu)造器可以用或者反序列化以及被注冊(cè)

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());

寫一個(gè)序列化器

如下是為 JodaTime DateTime class寫一個(gè)定制的序列化器
private class DateTimeSerializer implements JsonSerializer<DateTime> { public JsonElement serialize(DateTime src, Type typeOfSrc, JsonSerializationContext context) { return new JsonPrimitive(src.toString()); } }
Gson調(diào)用serialize方法當(dāng)有DateTime對(duì)象需要序列化

寫一個(gè)反序列化器

如下是為 JodaTime DateTime class寫一個(gè)定制的反序列化器
private class DateTimeDeserializer implements JsonDeserializer<DateTime> { public DateTime deserialize(JsonElement json, Type typeOfT,JsonDeserializationContext context) throws JsonParseException { return new DateTime(json.getAsJsonPrimitive().getAsString()); } }
Gson調(diào)用deserialize 當(dāng)它需要反序列化JSON字符串碎片進(jìn)DateTime對(duì)象

序列化器和反序列化器需要注意事項(xiàng)

通常你要注冊(cè)單個(gè)處理器來為所有反省類型對(duì)應(yīng)一個(gè)未處理類型

• 例如 假設(shè)你有一個(gè)ID類來表示或者轉(zhuǎn)化ID(比如 外部對(duì)應(yīng)內(nèi)部表示)
• Id<T> 類型有相同的序列化為所有泛型類型
• 反序列化非常相似但是不完全相同
• 需要調(diào)用new Id(Class<T>,String)來返回Id<T>的實(shí)例

編寫靜態(tài)工廠方法

當(dāng)反序列化一個(gè)對(duì)象時(shí)，Gson需要?jiǎng)?chuàng)建以個(gè)默認(rèn)類的實(shí)例，一個(gè)好的類意味著序列化和反序列化都應(yīng)該有一個(gè)無參構(gòu)造器

• public private都行
  通常 靜態(tài)工廠方法在你處理庫類時(shí)卻沒有定義一個(gè)無參構(gòu)造器
  private class MoneyInstanceCreator implements InstanceCreator<Money> { public Money createInstance(Type type) { return new Money("1000000", CurrencyCode.USD); } }
  類型需要是對(duì)應(yīng)的泛型類型
• 當(dāng)構(gòu)造器需要制定的泛型類型信息非常有用
• 舉例 如果Id類能存儲(chǔ)那些Id被創(chuàng)建的類

參數(shù)化類型的靜態(tài)工廠方法

有時(shí)候 你需要實(shí)例化的類型是參數(shù)化類型，一般，這不是一個(gè)問題 應(yīng)為實(shí)際創(chuàng)建的實(shí)例是raw類型，如下是一個(gè)例子
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(); }}

然后，有時(shí)你確實(shí)需要?jiǎng)?chuàng)建一個(gè)基于現(xiàn)有的參數(shù)化類型，如果這樣的話，你可以把參數(shù)化類型傳給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); }}
在上面例子中， 一個(gè)ID類的實(shí)例是不能被創(chuàng)建的 如果沒有傳入?yún)?shù)化類型的真實(shí)類型。我們是通過傳入方法參數(shù)type來解決這個(gè)問題，類型對(duì)象在這個(gè)例子中是 Id<Foo>的Java參數(shù)化類型的表示，真正的實(shí)例應(yīng)該被綁定到Id<Foo> 因?yàn)镮d類僅有一個(gè)參數(shù)化類型的參數(shù) T 我們使用由持有Foo.class的getActualTypeArgument()零元素的類型數(shù)組。

簡練 優(yōu)雅打印JSON輸出格式

默認(rèn)JSON輸出是由Gson提供的簡練JSON格式，這意味著JSON輸出格式是沒有任何空格，因此 在名 、值、對(duì)象數(shù)組、對(duì)象是沒有任何空格的。與此同時(shí)null字段也會(huì)在輸出時(shí)被忽略(注意： null值還是會(huì)存在集合/數(shù)組對(duì)象中) 在[Null Object Support] 中有更多關(guān)于如何配置Gson來輸出所有的Null值

如果你喜歡使用優(yōu)雅的打印功能，你就一定通過使用GsonBuilder要配置你的Gson實(shí)例
JsonFormatter方法是不會(huì)通過我們的公有api暴露出去的，所以客戶端是無法通過配置默認(rèn)的答應(yīng)設(shè)置/間距來輸出格式化的JSON 現(xiàn)在，我們僅僅提供一個(gè)默認(rèn)的JsonPrintFormatter方法 這個(gè)方法默認(rèn)一場的長度是80字節(jié) 2字節(jié)縮進(jìn) 4字節(jié)右邊距

下面通過一個(gè)例子展示如何配置Gson實(shí)例，使用默認(rèn)的JsonPrintFormatter
而不是JsonCompactFormatter
Gson gson = new GsonBuilder().setPrettyPrinting().create(); String jsonOutput = gson.toJson(someObject);

Null對(duì)象支持

對(duì)于null對(duì)象 Gson的默認(rèn)處理方式是直接忽略 這將提供更簡練的輸出格式，然而 客戶端必須提供一個(gè)默認(rèn)值當(dāng)JSON格式需要轉(zhuǎn)會(huì)對(duì)應(yīng)的JAVA對(duì)象中是
你可以配置Gson實(shí)例來輸出null:
Gson gson = new GsonBuilder().serializeNulls().create();
例子如下：
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);
輸出結(jié)果如下：
{"s":null,"i":5} null

版本支持

可以使用@Since注解來維持相同的對(duì)象的不同版本，這個(gè)注釋可以被用來類、域、在未來的版本也會(huì)支持 Methods ，為了提高這個(gè)功能的影響力，你必須配置你的Gson實(shí)例忽略任何版本更好的域 對(duì)象。如果Gson實(shí)例沒有設(shè)置任何版本 那么序列化和反序列化所有字段和類 并無視版本。
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);
輸出結(jié)果
`
{"newField":"new","field":"old"}

{"newerField":"newer","newField":"new","field":"old"}
`

忽略序列化和反序列化中的字段

Java Modifier Exclusion

默認(rèn) 你可以表示一個(gè)字段為transient 它就會(huì)被忽略， 同樣一個(gè)字段被表示為static也會(huì)被忽略，如果你想加入一些transicent字段 你可以按下面來操作：
import java.lang.reflect.Modifier;Gson gson = new GsonBuilder() .excludeFieldsWithModifiers(Modifier.STATIC) .create();
注意 你可以使用任意多的修飾符常量給excludeFieldsWithModifiers方法 例如

Gson gson = new GsonBuilder() .excludeFieldsWithModifiers(Modifier.STATIC, Modifier.TRANSIENT, Modifier.VOLATILE) .create();

Gson's @Expose

如果上面的忽略字段和類的方法對(duì)你不起作用 你也可以寫自己的忽略策略并配置到Gson里面，參照 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);}
輸出結(jié)果：
{"longField":1234}

JSON字段命名支持

Gson支持預(yù)定義字段命名策略，包含標(biāo)準(zhǔn)JAVA字段命名(駱駝峰命名 這玩意不是微軟定義的嗎 以小寫字母開始--- sampleFieldNameInJava)，并用它來給Json字段命名。參照 FieldNamingPolicy類來獲取更多關(guān)于預(yù)定義命名策略
它也提供一套基于注釋策略來允許客戶端自定義各自字段基礎(chǔ)，注意基于注釋策略有字段命名確定機(jī)制 ，如果注釋值提供的字段命名不合法則會(huì)包Runtime異常
下面是一個(gè)如何使用的例子：
`
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);

輸出結(jié)果如下：
{"custom_naming":"first","SomeOtherField":"second"}
`
如果你有一個(gè)自定義的命名策略的需要（見討論），你可以使用“serializedname注釋。

在自定義序列化和反序列化中共享狀態(tài)

有時(shí)你需要在自定義序列化/反序列化器共享狀態(tài)（見討論）。你可以使用以下三種策略來完成這個(gè)：
1.在靜態(tài)域存儲(chǔ)分享的狀態(tài)
2.聲明序列化器或者反序列化器作為父類型的內(nèi)部類，并使用父類型的實(shí)例字段來存儲(chǔ)共享狀態(tài)
3.使用Java ThreadLocal
1.2不是線程安全，3是線程安全的

流

此外gson的對(duì)象模型和數(shù)據(jù)綁定，您可以使用gson讀取和寫入流。您還可以將流媒體和對(duì)象模型的訪問組合起來，以獲得最佳的兩種方法。

在設(shè)計(jì)gson時(shí)的一些問題

當(dāng)我們?cè)O(shè)計(jì)Gson的一些討論 詳見Gson設(shè)計(jì)文檔。它還包括與其他Java庫，可用于JSON轉(zhuǎn)換gson比較。

Gson未來加強(qiáng)方向

詳情查看最新列表關(guān)于需要加強(qiáng)的方向，或者你想提一些新的建議，在項(xiàng)目網(wǎng)站上看到問題部分。