精品国产高清中文字幕,成人国产精品中文字幕,亚洲欧美日韩国产精品专区

Gson - 學(xué)習(xí)

Posted on 2018-08-29 10:34 冰碟閱讀(586) 評論(0) 收藏舉報

Google 的 Gson 庫，Gson 是一個非常強大的庫，可以將 JSON 格式的數(shù)據(jù)轉(zhuǎn)化成 Java 對象，也支持將 Java 對象轉(zhuǎn)成 JSON 數(shù)據(jù)格式。

Gson 依賴

本文將會快速開始使用 Gson 進行序列化操作。由于很多讀者都是 Android 開發(fā)人員，我們會提供 Java 環(huán)境中的 Gson。在開始之前，我們需要引入 Gson 庫到自己的項目中，最新的版本是 2.8.0.

Gradle 項目添加

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

Maven 項目添加

<dependencies>
    <dependency>
       <groupId>com.google.code.gson</groupId>
       <artifactId>gson</artifactId>
      <version>2.8.0</version>
       <scope>compile</scope>
    </dependency>
</dependencies>

基礎(chǔ)

序列化：

UserSimple userObject = new UserSimple(
    "Norman",
    "norman@futurestud.io",
    26,
    true
);

Gson gson = new Gson();
String userJson = gson.toJson(userObject);

反序列化：

String userJson = "{'age':26,'email':'norman@futurestud.io','isDeveloper':true,'name':'Norman'}";
Gson gson = new Gson();
UserSimple userObject = gson.fromJson(userJson, UserSimple.class);

數(shù)組反序列化：

public class Founder {
    String name;
    int flowerCount;
}


String founderJson = "[{'name': 'Christian','flowerCount': 1}, {'name': 'Marcus', 'flowerCount': 3}, {'name': 'Norman', 'flowerCount': 2}]";

Gson gson = new Gson();
Founder[] founderArray = gson.fromJson(founderJson, Founder[].class);

列表List反序列化：

String founderJson = "[{'name': 'Christian','flowerCount': 1}, {'name': 'Marcus', 'flowerCount': 3}, {'name': 'Norman', 'flowerCount': 2}]";

Gson gson = new Gson();

Type founderListType = new TypeToken<ArrayList<Founder>>(){}.getType();

List<Founder> founderList = gson.fromJson(founderJson, founderListType);

列表作為對象的一部分：反序列化時不需要傳遞 TypeToken

public class GeneralInfo {
    String name;
    String website;
    List<Founder> founders;
}


String generalInfoJson = "{'name': 'Future Studio Dev Team', 'website': 'https://futurestud.io', 'founders': [{'name': 'Christian', 'flowerCount': 1 }, {'name': 'Marcus','flowerCount': 3 }, {'name': 'Norman','flowerCount': 2 }]}";

Gson gson = new Gson();

GeneralInfo generalInfoObject = gson.fromJson(generalInfoJson, GeneralInfo.class);

Map反序列化：

public class AmountWithCurrency {
    String currency;
    int amount;
}

String dollarJson = "{ '1$': { 'amount': 1, 'currency': 'Dollar'}, '2$': { 'amount': 2, 'currency': 'Dollar'}, '3€': { 'amount': 3, 'currency': 'Euro'} }";

Gson gson = new Gson();

Type amountCurrencyType = new TypeToken<HashMap<String, AmountWithCurrency>>(){}.getType();

HashMap<String, AmountWithCurrency> amountCurrency =
gson.fromJson(dollarJson, amountCurrencyType);

Map 數(shù)據(jù)結(jié)構(gòu)沒有根元素，如 "[",我們就可以像解析 List 那用解析嵌套的 Map。

Set反序列化

String founderJson = "[{'name': 'Christian','flowerCount': 1}, {'name': 'Marcus', 'flowerCount': 3}, {'name': 'Norman', 'flowerCount': 2}]";

Gson gson = new Gson();

Type founderSetType = new TypeToken<HashSet<Founder>>(){}.getType();

HashSet<Founder> founderSet = gson.fromJson(founderJson, founderSetType);

泛型序列化：每種數(shù)據(jù)類型需要 new TypeToken 才能解析成功

Gson gson = new Gson();

List<Integer> integerList = new ArrayList<>();  
integerList.add(1);  
integerList.add(2);  
integerList.add(3);

List<String> stringList = new ArrayList<>();  
stringList.add("1");  
stringList.add("2");  
stringList.add("3");

Type integerType = new TypeToken<List<Integer>>() {}.getType();  
Type stringType = new TypeToken<List<String>>() {}.getType();

String integerJson = gson.toJson(integerList, integerType);  
String stringJson = gson.toJson(stringList, stringType);

@SerializedName

@SerializedName 是另一個非常實用的注解。@SerializedName 注解更改了自動匹配 JSON 字段的方式，平時開發(fā)中，我們總是默認保持 Java 類屬性字段名和 JSON 的字段是一一對應(yīng)，可有使用并不是總是這樣的情況，也許你沒有訪問繼承 Java 類或者你必須遵守公司的命名規(guī)則，這就需要使 @SerializedName 注解來匹配 Gson 字段，是一種非常優(yōu)雅的方式。

public class UserSimple {     
      @SerializedName("fullName")   
      String name;    
      String email;  
      boolean isDeveloper;  
      int age;
  }

 @SerializedName(value = "fullName", alternate = "username")    
 private String name;

SerializedName 接受兩個參數(shù)，value、alternate。

SerializedName 改變了默認序列化和默認反序列化的字段取值，序列化時就是 value 的名稱就是字段的名稱，alternate 屬性是用在反序列化上。

GsonBuider

public class UserNaming {
   String Name;
   String email_of_developer;
   boolean isDeveloper;
   int _ageOfDeveloper;
}

命名規(guī)則：

FieldNamingPolicy.IDENTITY：完全匹配我們 Java model 中的字段名，不管你有沒有設(shè)置其他注解屬性

GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.setFieldNamingPolicy(FieldNamingPolicy.IDENTITY);
Gson gson = gsonBuilder.create();

UserNaming user = new UserNaming("Norman", "norman@futurestud.io", true, 26);
String usersJson = gson.toJson(user);

輸出：

{
    "Name": "Norman",
    "_ageOfDeveloper": 26,
    "email_of_developer": "norman@futurestud.io",
    "isDeveloper": true
}

FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES：將修改生成的 JSON 中的字段名，格式將全部變成小寫，并且每個單詞用“_” 分割

{
    "name": "Norman",
    "_age_of_developer": 26,
    "email_of_developer": "norman@futurestud.io",
    "is_developer": true
}

FieldNamingPolicy.LOWER_CASE_WITH_DASHES：每個單詞用“-” 分隔

FieldNamingPolicy.UPPER_CAMEL_CASE：規(guī)則是每個單詞的第一個字母都要大寫，其他不變

 {
    "Name": "Norman",
    "_AgeOfDeveloper": 26,
    "Email_of_developer": "norman@futurestud.io",
     "IsDeveloper": true
}

FieldNamingPolicy.UPPER_CAMEL_CASE_WITH_SPACES：每個單詞的第一個字母會大寫、每個單詞使用空格分隔、含有 “_” 的鏈接的不會在使用空格

{
    "Name": "Norman",
    "_Age Of Developer": 26,
    "Email_of_developer": "norman@futurestud.io",
    "Is Developer": true
}

FieldNamingStrategy 自定義規(guī)則

FieldNamingStrategy customPolicy = new FieldNamingStrategy() {
    @Override
        public String translateName(Field f) {
            return f.getName().replace("_", "");
      }
};

GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.setFieldNamingStrategy(customPolicy);
Gson gson = gsonBuilder.create();

UserNaming user = new UserNaming("Norman", "norman@futurestud.io", true, 26);
String usersJson = gson.toJson(user);

序列化null

GsonBuilder gsonBuilder = new GsonBuilder();  
gsonBuilder.serializeNulls(); //重點
Gson gson = gsonBuilder.create();

UserSimple user = new UserSimple("Norman", null, 26, true);  
String usersJson = gson.toJson(user);

輸出：

{
      "age": 26,
      "email": null,
       "isDeveloper": true,
      "name": "Norman"
}

忽略策略

ExclusionStrategies 將 Date 和 boolean 類型的字段忽略、shouldSkipField 是用來忽略單個字段的，如果你想要忽略帶有 “_” 的字段

GsonBuilder gsonBuilder = new GsonBuilder();  
gsonBuilder.setExclusionStrategies(new ExclusionStrategy() {  
    @Override
    public boolean shouldSkipField(FieldAttributes f) {
        return f.getName().contains("_");
    }

    @Override
    public boolean shouldSkipClass(Class<?> incomingClass) {
        return incomingClass == Date.class || incomingClass == boolean.class;
    }
});
Gson gson = gsonBuilder.create();

UserDate user = new UserDate("Norman", "norman@futurestud.io", 26, true);  
String usersJson = gson.toJson(user);

上面的例子使用的是 setExclusionStrategies 方法，不管是序列化還是反序列化都會起作用，如果我們只想其中一個起作用，選擇調(diào)下面的方法就行了：

addSerializationExclusionStrategy()
addDeserializationExclusionStrategy()

用法和 ExclusionStrategy 的實現(xiàn)一樣，可重寫兩個方法實現(xiàn)。

基于 Modifiers 的忽略規(guī)則：

public class UserModifier {  
    private String name;
    private transient String email;
    private static boolean isDeveloper;
    private final int age;
}

如果你想忽略 final 和 static 類型的字段, 保留 transient 類型的字段

GsonBuilder gsonBuilder = new GsonBuilder();  
gsonBuilder.excludeFieldsWithModifiers(Modifier.STATIC, Modifier.FINAL);  
Gson gson = gsonBuilder.create();

UserModifier user = new UserModifier("Norman", "norman@fs.io", 26, true);  
String usersJson = gson.toJson(user);

注解 @Expose

public class UserSimple {  
        @Expose()
        String name; // equals serialize & deserialize

        @Expose(serialize = false, deserialize = false)
        String email; // equals neither serialize nor deserialize

        @Expose(serialize = false)
        int age; // equals only deserialize

        @Expose(deserialize = false)
        boolean isDeveloper; // equals only serialize
}

根據(jù) @Expose 的用法，UserSimple 序列化 JSON 輸出只有 name 和 isDeveloper，其他連個字段就不會被輸出，因為 serialize 都是 false；

反序列化的話，只有 email 和 isDeveloper 被忽略，因為 deserialize = false

transient :使用 transient 來描述字段，將不能被序列化和反序列化

Lenient屬性：

Gson 內(nèi)部使用的是 JsonReader 類，看源碼能發(fā)現(xiàn)里面有一個 lenient 的屬性，默認是 false，也就是說默認值接受標準的 JSON 格式數(shù)據(jù)，如果數(shù)據(jù)有問題，將拋出異常解析失敗。

JsonReader 也提供了設(shè)置 lenient 屬性的方法，來忽略一些不標準的 JSON 數(shù)據(jù)格式。

特殊類型 Floats & Doubles

如果你 Java 對象中包含一個正常的 Floats 或者 Doubles 類型的數(shù)據(jù)，是可以正常序列化得到 JSON的，如果你傳入 Float.POSITIVE_INFINITY 值，Gson 將會拋出異常，因為這個值是不能符合 JSON 標準的

解決的辦法就是通過 GsonBuilder 設(shè)置 serializeSpecialFloatingPointValues() 方法

GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.serializeSpecialFloatingPointValues();
    Gson gson = gsonBuilder.create();
    UserFloat userFloat = new UserFloat("Norman", Float.POSITIVE_INFINITY);
    String usersJson = gson.toJson(userFloat);
    System.out.println("userJson:" + usersJson);

自定義序列化：

public class UserSubscription {  
    String name;
    String email;
    int age;
    boolean isDeveloper;

    // new!
    List<Merchant> merchantList;
}

public class Merchant {  
    private int Id;
    private String name;

    // possibly more properties
}

JsonSerializer<Merchant> serializer = new JsonSerializer<Merchant>() {  
    @Override
    public JsonElement serialize(Merchant src, Type typeOfSrc, JsonSerializationContext context) {
        JsonObject jsonMerchant = new JsonObject();

        jsonMerchant.addProperty("Id", src.getId());

        return jsonMerchant;
    }
};

GsonBuilder gsonBuilder = new GsonBuilder();


gsonBuilder.registerTypeAdapter(Merchant.class, serializer);

Gson customGson = gsonBuilder.create();  
String customJSON = customGson.toJson(subscription);

自定義序列化List：

JsonSerializer<List<Merchant>> serializer =  
    new JsonSerializer<List<Merchant>>() {
        @Override
        public JsonElement serialize(List<Merchant> src, Type typeOfSrc, JsonSerializationContext context) {
            JsonObject jsonMerchant = new JsonObject();

            List<String> merchantIds = new ArrayList<>(src.size());
            for (Merchant merchant : src) {
                merchantIds.add("" + merchant.getId());
            }

            String merchantIdsAsString = TextUtils.join(",", merchantIds);

            jsonMerchant.addProperty("Ids", merchantIdsAsString);

            return jsonMerchant;
        }
}

GsonBuilder gsonBuilder = new GsonBuilder();

Type merchantListType = new TypeToken<List<Merchant>>() {}.getType();  

gsonBuilder.registerTypeAdapter(merchantListType, serializer);

Gson customGson = gsonBuilder.create();  
String customJSON = customGson.toJson(subscription);

//結(jié)果
{
  "age": 26,
  "email": "norman@fs.io",
  "isDeveloper": true,
  "merchantList": {
    "Ids": "23,42"
  },
  "name": "Norman"
}

簡化：

JsonSerializer<List<Merchant>> serializer =  
    new JsonSerializer<List<Merchant>>() {
        @Override
        public JsonElement serialize(List<Merchant> src, Type typeOfSrc, JsonSerializationContext context) {
            JsonArray jsonMerchant = new JsonArray();

            for (Merchant merchant : src) {
                jsonMerchant.add("" + merchant.getId());
            }

            return jsonMerchant;
        }
}
//結(jié)果

{
  "age": 26,
  "email": "norman@fs.io",
  "isDeveloper": true,
  "merchantList": [
    "23",
    "42"
  ],
  "name": "Norman"
}

自定義反序列化：

前三個表示年月日，是一個日期結(jié)構(gòu)，后面四個字段表示一個 model 信息

//模型
public class UserDate {  
    private String name;
    private String email;
    private boolean isDeveloper;
    private int age;
    private Date registerDate;
}

//Json
｛       
    "year": 116,
    "month": 5,
    "day": 21,
    "age": 26,
    "email": "norman@futurestud.io",
    "isDeveloper": true,
    "name": "Norman"
}

JsonDeserializer<UserDate> deserializer = new JsonDeserializer<UserDate>() {  
    @Override
    public UserDate deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        JsonObject jsonObject = json.getAsJsonObject();

        Date date = new Date(
                jsonObject.get("year").getAsInt(),
                jsonObject.get("month").getAsInt(),
                jsonObject.get("day").getAsInt()
        );

        return new UserDate(
                jsonObject.get("name").getAsString(),
                jsonObject.get("email").getAsString(),
                jsonObject.get("isDeveloper").getAsBoolean(),
                jsonObject.get("age").getAsInt(),
                date
        );
    }
};

GsonBuilder gsonBuilder = new GsonBuilder();


gsonBuilder.registerTypeAdapter(UserDate.class, deserializer);

Gson customGson = gsonBuilder.create();  
UserDate customObject = customGson.fromJson(userJson, UserDate.class);

自定義對象示例創(chuàng)建：

//Json

 {
      "age": 26,
      "email": "norman@fs.io",
      "isDeveloper": true,
      "name": "Norman"
}

//Model
public class UserContext {  
    private String name;
    private String email;
    private boolean isDeveloper;
    private int age;

    // additional attribute, which is not part of the data model
    private Context context; 

    public UserContext(Context context) {
        this.context = context;
    }
}

如果你還是用原來的方式來反序列化，那么得到的 Context 肯定是null。你需要在映射之前的構(gòu)造函數(shù)中來創(chuàng)建 Context，這是就需要用到 InstanceCreators。

String userSimpleJson = ...; // the JSON from the server, see above

GsonBuilder gsonBuilder = new GsonBuilder();  
gsonBuilder.registerTypeAdapter(  
    UserContext.class, 
    new UserContextInstanceCreator(getApplicationContext())
);
Gson customGson = gsonBuilder.create();

UserContext customObject = customGson.fromJson(userSimpleJson, UserContext.class);

private class UserContextInstanceCreator implements InstanceCreator<UserContext> {  
    private Context context;

    public UserContextInstanceCreator(Context context) {
        this.context = context;
    }

    @Override
    public UserContext createInstance(Type type) {
        // create new object with our additional property
        UserContext userContext = new UserContext(context);

        // return it to gson for further usage
        return userContext;
    }
}

@JsonAdapter 注解：

public class MerchantListSerializer implements JsonSerializer<List<Merchant>> {  
    @Override
    public JsonElement serialize(List<Merchant> src, Type typeOfSrc, JsonSerializationContext context) {
        JsonArray jsonMerchant = new JsonArray();

        for (Merchant merchant : src) {
            jsonMerchant.add("" + merchant.getId());
        }

        return jsonMerchant;
    }
}

public class UserSubscriptionAnnotation {  
    String name;
    String email;
    int age;
    boolean isDeveloper;

    // new!
    @JsonAdapter(MerchantListSerializer.class)
    List<Merchant> merchantList;
}

UserSubscriptionAnnotation subscription = new UserSubscriptionAnnotation( "Norman", "norman@fs.io", 26, true, subscribedMerchants);

Gson gson = new Gson();

String fullJSON = gson.toJson(subscription);

只有是類的形式，我們才能使用注解 @JsonAdapter 來添加 MerchantListSerializer。就像之前的一些注解用法一樣，并添加到你需要序列化的 Java model 中。

可以看到 merchantList 被添加了 @JsonAdapter(MerchantListSerializer.class) 注解，而 MerchantListSerializer 正是我們序列化過程的實現(xiàn)類，這樣我們就不用使用 GsonBuilder 它來創(chuàng)建的 Gson 對象，而是使用默認創(chuàng)建對象就可以，也不需要那些復(fù)雜的設(shè)置。

反序列化：和序列化不同的是，@JsonAdapter(UserDateDeserializer.class) 注解是要添加在類級別上面，這是一點不同。

轉(zhuǎn)載自：
作者：無名小子的雜貨鋪
鏈接：https://www.jianshu.com/p/215708d00015
來源：簡書
簡書著作權(quán)歸作者所有，任何形式的轉(zhuǎn)載都請聯(lián)系作者獲得授權(quán)并注明出處。

刷新頁面返回頂部

只為成功找方向，不為失敗找借口

公告

Gson - 學(xué)習(xí)

Gson 依賴

Gradle 項目添加

Maven 項目添加

GsonBuider