欧美性free极品另类,2021久久天天躁狠狠躁夜夜,日韩国产欧美

Gson是一個Java庫，用來實現Json和Java對象之間的相互轉換。Gson是一個托管在https://github.com/google/gson的開源項目。

Gson中主要的類是Gson，也可以使用類GsonBuilder在創建Gson對象的同時設置一些選項。
Gson對象在處理Json時不會保存任何狀態，所以使用者能夠很輕松的對同一個Gson對象進行多次序列化、反序列化等操作。

示例：基本使用

				?

									//Serialization

									Gson gson = new Gson();

									gson.toJson(1);   //==> prints 1

									gson.toJson("abcd");  //==> prints "abcd"

									gson.toJson(new Long(10)); //==> prints 10

									int[] values = { 1 };

									gson.toJson(values);  //==> prints [1]

									//Deserialization

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

									//Serialization

									BagOfPrimitives 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：

				?

									//Serialization

									BagOfPrimitives obj = new BagOfPrimitives();

									Gson gson = new Gson();

									String json = gson.toJson(obj); 

									//==> json is {"value1":1,"value2":"abc"}

不要序列化含有循環引用的對象，否則會造成無限的遞歸。

反序列化：

				?

									//Deserialization

									BagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class); 

									//==> obj2 is just like obj

處理對象時的一些細節：

推薦使用私有字段（譯者：可以通過反射獲取私有字段的名稱和值）
沒有必要使用標注指明哪些字段該被序列化或者反序列化。在當前類（也包括其父類）中的所有字段都默認會被序列化/反序列化。
如果某字段在聲明時使用了關鍵字transient，默認情況下不會被序列化/反序列化。
Gson如下處理null字段：
序列化時候null字段會被跳過
反序列化時，類中有但Json中沒有的字段將設值為null。
synthetic字段不會被序列化/反序列化。
在外部類(outer classes)中的內部類（inner classes）、匿名類（anonymous classes）和局部類（local classes）中的字段不會被序列化/反序列化。

嵌套類（包括內部類）的處理

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<A.B> {

									 private final A a;

									 public InstanceCreatorForB(A a) {

									 this.a = a;

									 }

									 public A.B createInstance(Type type) {

									 return a.new B();

									 }

									}

這種方法是可行的，但是不推薦。（譯者表示沒看懂這個實例創建器，不知道該怎么用）

示例：數組

				?

									Gson gson = new Gson();

									int[] ints = {1, 2, 3, 4, 5};

									String[] strings = {"abc", "def", "ghi"};

									//Serialization

									gson.toJson(ints);  ==> prints [1,2,3,4,5]

									gson.toJson(strings); ==> prints ["abc", "def", "ghi"]

									//Deserialization

									int[] ints2 = gson.fromJson("[1,2,3,4,5]", int[].class);

									==> ints2 will be same as ints

Gson也支持具有復雜數據類型的多維數組。

示例：集合（Collection）

				?

									Gson gson = new Gson();

									Collection<Integer> ints = Lists.immutableList(1,2,3,4,5);

									//Serialization

									String 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

處理集合(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 correctly

									gson.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為常用的但是默認表示可能并不合適的類提供了序列化/反序列化器。
下面是這些類的一個列表：

java.net.URL，例如會序列化為字符串 http://code.google.com/p/google-gson/
java.net.URI，例如會序列化為字符串/p/google-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()。

對于序列化器/反序列化器，應注意：

很多情況下，你想要注冊一個處理程序將泛型與一個原始類型對應起來，
例如，假如你有一個叫做Id的類來表示和轉換Id
Id<T>類型中，所有的泛型擁有相同的序列化器，這個序列化器就是輸出id的值
反序列化器很像，但并不會完全一樣。例如要返回一個Id<T>對象，需要調用new Id(Class<T>, String)。
Gson支持注冊一個處理程序，你也可以為指定的泛型注冊指定的處理程序。toJson和fromJson的Type參數包含了泛型信息以幫助你寫出一個可以將所有的泛型與同一個原始類型對應起來的處理程序。

寫一個實例創建器

在反序列化一個對象時，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標注。

在序列化器和反序列化器之間共享狀態

有時你會需要在序列化器和反序列化器之間共享狀態，你可以使用下面的三個方法達到目的：

在一個靜態字段中存儲共享狀態
將序列化/反序列化器聲明為一個父類型的內部類，然后使用父類型的實例的字段存儲共享狀態
使用Java中的ThreadLocal

前兩種方法不是線程安全的，第三種是。

GSON解析null出錯解決辦法
GSON有一個缺點就是無法設置null替換，
我們只能手動的批量替換服務器返回的null了，正常的接口定義的時候是絕對不允許服務器返回null的，后臺結果卻總會出現null！
如果搜索的話有一個常見的答案，

				?

									Gson gson = new GsonBuilder().serializeNulls().create();

但是這個卻無法解決反序列問題,怎么解決呢？
解決辦法如下：

				?

									Gson gson = new GsonBuilder().registerTypeAdapterFactory(new NullStringToEmptyAdapterFactory()).create();

									//然后用上面一行寫的gson來序列化和反序列化實體類type

									gson.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);

									 }

									}