Gson是一個(gè)Java庫(kù)，用來(lái)實(shí)現(xiàn)Json和Java對(duì)象之間的相互轉(zhuǎn)換。Gson是一個(gè)托管在https://github.com/google/gson的開(kāi)源項(xiàng)目。
Gson中主要的類是Gson，也可以使用類GsonBuilder在創(chuàng)建Gson對(duì)象的同時(shí)設(shè)置一些選項(xiàng)。
Gson對(duì)象在處理Json時(shí)不會(huì)保存任何狀態(tài)，所以使用者能夠很輕松的對(duì)同一個(gè)Gson對(duì)象進(jìn)行多次序列化、反序列化等操作。
示例：基本使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
//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"} |
示例：對(duì)象與Json之間轉(zhuǎn)換
定義BagOfPrimitives類：
|
1
2
3
4
5
6
7
8
|
class BagOfPrimitives { private int value1 = 1; private String value2 = "abc"; private transient int value3 = 3; BagOfPrimitives() { // no-args constructor }} |
序列化為Json：
|
1
2
3
4
5
|
//SerializationBagOfPrimitives obj = new BagOfPrimitives();Gson gson = new Gson();String json = gson.toJson(obj); //==> json is {"value1":1,"value2":"abc"} |
不要序列化含有循環(huán)引用的對(duì)象，否則會(huì)造成無(wú)限的遞歸。
反序列化：
|
1
2
3
|
//DeserializationBagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class); //==> obj2 is just like obj |
處理對(duì)象時(shí)的一些細(xì)節(jié)：
- 推薦使用私有字段（譯者：可以通過(guò)反射獲取私有字段的名稱和值）
- 沒(méi)有必要使用標(biāo)注指明哪些字段該被序列化或者反序列化。在當(dāng)前類（也包括其父類）中的所有字段都默認(rèn)會(huì)被序列化/反序列化。
- 如果某字段在聲明時(shí)使用了關(guān)鍵字transient，默認(rèn)情況下不會(huì)被序列化/反序列化。
- Gson如下處理null字段：
- 序列化時(shí)候null字段會(huì)被跳過(guò)
- 反序列化時(shí)，類中有但Json中沒(méi)有的字段將設(shè)值為null。
- synthetic字段不會(huì)被序列化/反序列化。
- 在外部類(outer classes)中的內(nèi)部類（inner classes）、匿名類（anonymous classes）和局部類（local classes）中的字段不會(huì)被序列化/反序列化。
嵌套類（包括內(nèi)部類）的處理
Gson可以很輕松地序列化嵌套類，且能夠反序列化靜態(tài)的嵌套類。Gson無(wú)法自動(dòng)地反序列化純粹的內(nèi)部類，是因?yàn)閮?nèi)部類的無(wú)參構(gòu)造函數(shù)需要引用包含它的對(duì)象（即外部類的實(shí)例）。要反序列化靜態(tài)類，可以將內(nèi)部類靜態(tài)化或者提供一個(gè)自定義的實(shí)例創(chuàng)造器（instance creator）。下面是一個(gè)示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class A { public String a; class B { public String b; public B() { // No args constructor for B } }} |
上面的類B無(wú)法被Gson序列化。由于類B是一個(gè)（非靜態(tài)的）內(nèi)部類，Gson也無(wú)法反序列化{"b":"abc"}到類B的實(shí)例中。如果B被聲明為static class B，那么Gson就能對(duì)這個(gè)字符串反序列化了。
另外一個(gè)解決方法是為B寫(xiě)一個(gè)實(shí)例創(chuàng)建器：
|
1
2
3
4
5
6
7
8
9
|
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(); }} |
這種方法是可行的，但是不推薦。（譯者表示沒(méi)看懂這個(gè)實(shí)例創(chuàng)建器，不知道該怎么用）
示例：數(shù)組
|
1
2
3
4
5
6
7
8
9
10
11
|
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 ints |
Gson也支持具有復(fù)雜數(shù)據(jù)類型的多維數(shù)組。
示例：集合（Collection）
|
1
2
3
4
5
6
7
8
9
10
|
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)時(shí)的限制：
- 可以序列化任意對(duì)象的集合，反序列化就不行了。
- 反序列化時(shí)，集合必須是指定的泛型。
序列化/反序列化泛型
當(dāng)使用toJson(obj)時(shí)，Gson調(diào)用obj.getClass()獲取字段信息以在序列化中使用。類似的，也可以將對(duì)象MyClass.class作為參數(shù)傳遞給fromJson(json, MyClass.class)方法，這可以在在對(duì)象不是泛型的時(shí)候使用。不過(guò)，當(dāng)對(duì)象是一個(gè)泛型類型的對(duì)象，由于Java中類型擦除（Type Erasure）這一機(jī)制，泛型類型信息會(huì)丟失。下面的例子將說(shuō)明這一點(diǎn)：
|
1
2
3
4
5
6
7
8
|
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類型，這是因?yàn)镚son調(diào)用foo.getClass()獲取類的信息，但是這種那個(gè)方法返回的是一個(gè)原始的類，即Foo.class。這意味著Gson無(wú)法知道這是一個(gè)Foo<Bar>類型的對(duì)象。
要解決這個(gè)問(wèn)題，可以是為你的泛型指定正確的參數(shù)化的類型。可以使用TypeToken類做到：
|
1
2
3
|
Type fooType = new TypeToken<Foo<Bar>>() {}.getType();gson.toJson(foo, fooType);gson.fromJson(json, fooType); |
fooType實(shí)際上定義了一個(gè)匿名的內(nèi)部類，這個(gè)內(nèi)部類含有一個(gè)可以返回全部參數(shù)化類型的getType()方法。
序列化/反序列化含有任意類型的對(duì)象的集合
有時(shí)候處理的JSON包含了混合的類型，例如:
|
1
|
['hello',5,{name:'GREETINGS',source:'guest'}] |
對(duì)應(yīng)的集合應(yīng)該是：
|
1
2
3
4
|
Collection collection = new ArrayList();collection.add("hello");collection.add(5);collection.add(new Event("GREETINGS", "guest")); |
其中的Event類如下定義：
|
1
2
3
4
5
6
7
8
|
class Event { private String name; private String source; private Event(String name, String source) { this.name = name; this.source = source; }} |
通過(guò)Gson，你不需要做任何特殊的事情就可以序列化集合：toJson(collection)會(huì)輸出令人滿意的結(jié)果。
然而，通過(guò)fromJson(json, Collection.class)反序列化是不行的，這是因?yàn)镚son無(wú)法將json中的的內(nèi)容與類型對(duì)應(yīng)起來(lái)。Gson需要你在fromJson中提供一個(gè)通用版本的集合類型。你有三個(gè)選擇：
方案1：使用Gson解析器的API（低級(jí)的流解析器或者DOM解析器JsonParser）去解析數(shù)組元素，然后使用Gson.fromJson()處理每一個(gè)數(shù)組元素。這是首選的方案。
方案2：為Collection.class注冊(cè)一類型適配器將數(shù)組中的元素映射到合適的對(duì)象。這種方法的缺點(diǎn)是會(huì)使你在處理其他的集合類型時(shí)候產(chǎn)生不便。
方案3：為MyCollectionMemberType注冊(cè)一個(gè)類型適配器，在fromJson中使用Collection<MyCollectionMemberType>。只有當(dāng)數(shù)組看起來(lái)像一個(gè)高級(jí)的元素或者你能夠?qū)⒆侄晤愋透某蒀ollection<MyCollectionMemberType>，這種方法才比較可行。
內(nèi)置的序列化/反序列化器
Gson為常用的但是默認(rèn)表示可能并不合適的類提供了序列化/反序列化器。
下面是這些類的一個(gè)列表：
- java.net.URL，例如會(huì)序列化為字符串 http://code.google.com/p/google-gson/
- java.net.URI，例如會(huì)序列化為字符串/p/google-gson/
自定義序列化/反序列化
有時(shí)候，Gson的默認(rèn)實(shí)現(xiàn)并不是你想要的，這在處理一些類庫(kù)時(shí)（例如DateTime）時(shí)比較常見(jiàn)。
Gson允許你注冊(cè)自定義的序列化/反序列化器。要這樣做的話，你需要實(shí)現(xiàn)以下幾個(gè)部分：
Json序列化器：需要為一個(gè)對(duì)象自定義序列化
Json反序列化器：需要為一個(gè)類型自定義反序列化
類創(chuàng)建器：如果存在無(wú)參構(gòu)造函數(shù)或者已經(jīng)注冊(cè)了一個(gè)反序列化器，就不需要了。
|
1
2
3
4
5
|
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會(huì)檢查類型適配器是否實(shí)現(xiàn)了多個(gè)接口，并為這些接口注冊(cè)類型適配器。
寫(xiě)一個(gè)序列化器
下面是一個(gè)為DateTime自定義序列化器的示例：
|
1
2
3
4
5
|
private class DateTimeSerializer implements JsonSerializer<DateTime> { public JsonElement serialize(DateTime src, Type typeOfSrc, JsonSerializationContext context) { return new JsonPrimitive(src.toString()); }} |
Gson在序列化DateTime實(shí)例時(shí)會(huì)調(diào)用toJson()。
寫(xiě)一個(gè)反序列化器
下面的示例是講如何寫(xiě)一個(gè)DateTime類的反序列化器：
|
1
2
3
4
5
6
|
private class DateTimeDeserializer implements JsonDeserializer<DateTime> { public DateTime deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException { return new DateTime(json.getAsJsonPrimitive().getAsString()); }} |
當(dāng)Gson需要將一個(gè)JSON字符串發(fā)反序列化為DateTime對(duì)象時(shí)，會(huì)調(diào)用 fromJson()。
對(duì)于序列化器/反序列化器，應(yīng)注意：
- 很多情況下，你想要注冊(cè)一個(gè)處理程序?qū)⒎盒团c一個(gè)原始類型對(duì)應(yīng)起來(lái)，
- 例如，假如你有一個(gè)叫做Id的類來(lái)表示和轉(zhuǎn)換Id
- Id<T>類型中，所有的泛型擁有相同的序列化器，這個(gè)序列化器就是輸出id的值
- 反序列化器很像，但并不會(huì)完全一樣。例如要返回一個(gè)Id<T>對(duì)象，需要調(diào)用new Id(Class<T>, String)。
- Gson支持注冊(cè)一個(gè)處理程序，你也可以為指定的泛型注冊(cè)指定的處理程序。toJson和fromJson的Type參數(shù)包含了泛型信息以幫助你寫(xiě)出一個(gè)可以將所有的泛型與同一個(gè)原始類型對(duì)應(yīng)起來(lái)的處理程序。
寫(xiě)一個(gè)實(shí)例創(chuàng)建器
在反序列化一個(gè)對(duì)象時(shí)，Gson需要?jiǎng)?chuàng)建一個(gè)類的實(shí)例。在序列化/反序列化時(shí)具有良好表現(xiàn)的類是指這個(gè)類擁有一個(gè)無(wú)參構(gòu)造函數(shù)。通常，當(dāng)處理一個(gè)類庫(kù)中沒(méi)有無(wú)參構(gòu)造函數(shù)的類時(shí)，需要使用實(shí)例創(chuàng)建器。
實(shí)例創(chuàng)建器示例：
|
1
2
3
4
5
|
private class MoneyInstanceCreator implements InstanceCreator<Money> { public Money createInstance(Type type) { return new Money("1000000", CurrencyCode.USD); }} |
參數(shù)化類型的實(shí)例創(chuàng)建器
有時(shí)候要實(shí)例化的類型會(huì)是一個(gè)參數(shù)化類型。總的來(lái)說(shuō)，由于真正的實(shí)例是一個(gè)原始類型，所以這不是什么問(wèn)題。下面是一個(gè)示例：
|
1
2
3
4
5
6
7
8
9
10
|
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(); }} |
不過(guò)，有時(shí)你需要基于真正的參數(shù)化類型來(lái)創(chuàng)建實(shí)例。在這種情況下，你可以將類型參數(shù)傳遞給createInstance方法。下面是一個(gè)例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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); }} |
在上面的示例中，如果沒(méi)有將真正的類型傳遞給參數(shù)化類型，Id類的實(shí)例是無(wú)法創(chuàng)建的。通過(guò)給方法傳遞參數(shù)type，我們才得以解決這個(gè)問(wèn)題。這里，type對(duì)象可以看做是Id<Foo>的Java參數(shù)化類型的表示，相應(yīng)的實(shí)例應(yīng)該被綁定到Id<Foo>。由于類Id只有一個(gè)參數(shù)化類型的參數(shù)T，我們使用getActualTypeArgument()返回的類型數(shù)組的第0個(gè)元素，在這個(gè)例子中就是Foo.class。
緊湊的輸出 VS 優(yōu)美的輸出
Gson中Json默認(rèn)的輸出是緊湊的JSON格式。也就是說(shuō)在JSON中沒(méi)有多余的空白符。所以在JSON的輸出中字段名和字段值之間、字段之間、數(shù)組元素之間是沒(méi)有空白的。另外，null字段不會(huì)被輸出（注意：在集合和數(shù)組對(duì)象中null會(huì)被保留的）。
如果要輸出的優(yōu)美些，你需要使用GsonBuilder對(duì)Gson的實(shí)例進(jìn)行配置。JsonFormatter不存在于公有API中，所以客戶端無(wú)法配置默認(rèn)的輸出設(shè)置。現(xiàn)在我們只提供了JsonPrintFormatter，其默認(rèn)情況下每行80個(gè)字符，縮進(jìn)使用2個(gè)字符，右邊距是4個(gè)字符。
下面的示例展示了如何讓Gson實(shí)例使用JsonPrintFormatter，而不是使用默認(rèn)的JsonCompactFormatter。
|
1
2
|
Gson gson = new GsonBuilder().setPrettyPrinting().create();String jsonOutput = gson.toJson(someObject); |
空對(duì)象
在Gson的默認(rèn)實(shí)現(xiàn)中，null對(duì)象是被忽略的。這可以讓輸出格式（既可以認(rèn)為是序列化的結(jié)果）更加緊密；不過(guò)客戶端必須為其定義一個(gè)默認(rèn)的值，以使得JSON能夠正常的反序列化。
如果要讓Gson實(shí)例可以序列化null，可以：
|
1
|
Gson gson = new GsonBuilder().serializeNulls().create(); |
注意，當(dāng)序列化null的時(shí)，會(huì)在JsonElement結(jié)構(gòu)中添加一個(gè)JsonNull元素。因此，我們可以可以在自定義的序列化器/反序列化器中使用這個(gè)對(duì)象（gson）。
下面是一個(gè)例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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); |
輸出：
|
1
2
|
{"s":null,"i":5}null |
版本支持
可以使用@Since標(biāo)注來(lái)維護(hù)同一個(gè)對(duì)象的多個(gè)版本。這個(gè)標(biāo)注可以用在類和字段上，將來(lái)也會(huì)支持用在方法上。為了使用這個(gè)特性，你需要配置Gson實(shí)例，讓其忽略大于某個(gè)版本號(hào)的字段和對(duì)象。如果沒(méi)有在Gson對(duì)象中設(shè)置版本，序列化/反序列化時(shí)會(huì)使用所有的字段和類。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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); |
輸出：
|
1
2
3
|
{"newField":"new","field":"old"}{"newerField":"newer","newField":"new","field":"old"} |
從序列化/反序列化中排除字段
Gson支持使用很多方法來(lái)去除類、字段、字段類型。如果下面的方法無(wú)法滿足你的需求，可以使用自定義序列化/反序列化器的方法。
1.Java Modifier Exclusion
默認(rèn)情況下，如果將一個(gè)字段聲明為transient，這個(gè)字段就會(huì)被排除。另外，如果一個(gè)字段被聲明為static，默認(rèn)情況下這個(gè)字段也會(huì)被排除。如果要包含某些聲明為transient的字段，你可以這樣做：
|
1
2
3
4
5
|
import java.lang.reflect.Modifier;Gson gson = new GsonBuilder() .excludeFieldsWithModifiers(Modifier.STATIC) .create(); |
注意，在excludeFieldsWithModifiers方法中，你可以使用任意數(shù)量的Modifier常量。例如：
|
1
2
3
|
Gson gson = new GsonBuilder() .excludeFieldsWithModifiers(Modifier.STATIC, Modifier.TRANSIENT, Modifier.VOLATILE) .create(); |
2.使用@Expose字段排除
這個(gè)特性允許你在類中標(biāo)記特定的字段使其在序列化/反序列化中不被排除/被排除。要使用這個(gè)標(biāo)注，你應(yīng)該使用new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create()創(chuàng)建Gson。Gson實(shí)例會(huì)排除類中所有沒(méi)被@Expose標(biāo)注的字段。
3.用戶定義排除策略
如果上面的排除方法無(wú)法滿足需求，你也可以自定義自己的排除策略。更多內(nèi)容，可以參考ExclusionStrategy JavaDoc。
下面的例子展示了如何排除使用了@Foo標(biāo)注的字段，排除String類的頂級(jí)類型或者聲明的字段類型：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
@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); } |
輸出：
|
1
|
{"longField":1234} |
JSON字段命名的支持
Gson的一些預(yù)定義的字段命名策略，可以將標(biāo)準(zhǔn)的Java字段名稱（也就是駝峰命名法，例如sampleFieldNameInJava）轉(zhuǎn)換成一個(gè)Json的字段名（也就是sample_field_name_in_java或者SampleFieldNameInJava）。更多信息，可以參考FieldNamingPolicy。
Gson也有一個(gè)基于標(biāo)注的策略讓客戶端自定義字段的名稱。這個(gè)策略下，如果提供了一個(gè)非法的字段名作為標(biāo)注的值，會(huì)使Gson拋出Runtime異常。
下面的示例展示了如何使用這兩種Gson命名策略：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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); |
輸出：
|
1
|
{"custom_naming":"first","SomeOtherField":"second"} |
如果要自定義名稱，可以使用@SerializedName標(biāo)注。
在序列化器和反序列化器之間共享狀態(tài)
有時(shí)你會(huì)需要在序列化器和反序列化器之間共享狀態(tài)，你可以使用下面的三個(gè)方法達(dá)到目的：
- 在一個(gè)靜態(tài)字段中存儲(chǔ)共享狀態(tài)
- 將序列化/反序列化器聲明為一個(gè)父類型的內(nèi)部類，然后使用父類型的實(shí)例的字段存儲(chǔ)共享狀態(tài)
- 使用Java中的ThreadLocal
前兩種方法不是線程安全的，第三種是。
GSON解析null出錯(cuò)解決辦法
GSON有一個(gè)缺點(diǎn)就是無(wú)法設(shè)置null替換，
我們只能手動(dòng)的批量替換服務(wù)器返回的null了，正常的接口定義的時(shí)候是絕對(duì)不允許服務(wù)器返回null的，后臺(tái)結(jié)果卻總會(huì)出現(xiàn)null！
如果搜索的話有一個(gè)常見(jiàn)的答案，
|
1
|
Gson gson = new GsonBuilder().serializeNulls().create(); |
但是這個(gè)卻無(wú)法解決反序列問(wèn)題,怎么解決呢？
解決辦法如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
Gson gson = new GsonBuilder().registerTypeAdapterFactory(new NullStringToEmptyAdapterFactory()).create();//然后用上面一行寫(xiě)的gson來(lái)序列化和反序列化實(shí)體類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); }} |
