【转载】Android Gson使用详解

最新推荐文章于 2021-11-15 16:35:51 发布

BaQiShiGuang

最新推荐文章于 2021-11-15 16:35:51 发布

阅读量319

点赞数

分类专栏： Android开发

Android开发专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Json 是一种文本形式的数据交换格式，比 xml 更为轻量。Json 的解析和生成的方式很多，在 Android 平台上最常用的类库有 Gson 和 FastJson 两种，这里要介绍的是 Gson

Gson 的 GitHub 主页点击这里：Gson

一、Gson的基本用法

1.1、Gson对象

在进行序列化与反序列操作前，需要先实例化一个 com .google.gson.Gson 对象，获取 Gson 对象的方法有两种

        //通过构造函数来获取
        Gson gson = new Gson();
        //通过 GsonBuilder 来获取，可以进行多项特殊配置
        Gson gson = new GsonBuilder().create();

1.2、生成 Json

利用 Gson 可以很方便地生成 Json 字符串，通过使用 addProperty 的四个重载方法

    public static void main(String[] args) {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("String", "leavesC");
        jsonObject.addProperty("Number_Integer", 23);
        jsonObject.addProperty("Number_Double", 22.9);
        jsonObject.addProperty("Boolean", true);
        jsonObject.addProperty("Char", 'c');
        System.out.println();
        System.out.println(jsonObject);
    }

addProperty 方法底层调用的是 add(String property, JsonElement value) 方法，即将基本数据类型转化为了 JsonElement 对象，JsonElement 是一个抽象类，而 JsonObject 继承了 JsonElement ，因此我们可以通过 JsonObject 自己来构建一个 JsonElement

    public static void main(String[] args) {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("String", "leavesC");
        jsonObject.addProperty("Number", 23);
        jsonObject.addProperty("Number", 22.9);
        jsonObject.addProperty("Boolean", true);
        jsonObject.addProperty("Char", 'c');
    JsonObject jsonElement = <span class="hljs-keyword">new</span> JsonObject();
    jsonElement.addProperty(<span class="hljs-string">"Boolean"</span>, <span class="hljs-literal">false</span>);
    jsonElement.addProperty(<span class="hljs-string">"Double"</span>, <span class="hljs-number">25.9</span>);
    jsonElement.addProperty(<span class="hljs-string">"Char"</span>, <span class="hljs-string">'c'</span>);
    jsonObject.add(<span class="hljs-string">"JsonElement"</span>, jsonElement);

    System.out.println();
    System.out.println(jsonObject);
}

1.3、Json与数组、List的转化

Json数组与字符串数组

    public static void main(String[] args) {
        //Json数组 转为 字符串数组
        Gson gson = new Gson();
        String jsonArray = "[\"https://github.com/leavesC\",\"https://www.jianshu.com/u/9df45b87cfdf\",\"Java\",\"Kotlin\",\"Git\",\"GitHub\"]";
        String[] strings = gson.fromJson(jsonArray, String[].class);
        System.out.println("Json数组 转为 字符串数组: ");
        for (String string : strings) {
            System.out.println(string);
        }
        //字符串数组 转为 Json数组
        jsonArray = gson.toJson(strings, String[].class);
        System.out.println("\n字符串数组 转为 Json数组: ");
        System.out.println(jsonArray);
    }

Json数组与 List

    public static void main(String[] args) {
        //Json数组 转为 List
        Gson gson = new Gson();
        String jsonArray = "[\"https://github.com/leavesC\",\"https://www.jianshu.com/u/9df45b87cfdf\",\"Java\",\"Kotlin\",\"Git\",\"GitHub\"]";
        List<String> stringList = gson.fromJson(jsonArray, new TypeToken<List<String>>() {
        }.getType());
        System.out.println("\nJson数组 转为 List: ");
        for (String string : stringList) {
            System.out.println(string);
        }
        //List 转为 Json数组
        jsonArray = gson.toJson(stringList, new TypeToken<List<String>>() {
        }.getType());
        System.out.println("\nList 转为 Json数组: ");
        System.out.println(jsonArray);
    }

1.4、序列化与反序列化

Gson 也提供了 toJson() 和 fromJson() 两个方法用于转化 Model 与 Json，前者实现了序列化，后者实现了反序列化
首先，声明一个 User 类

/**
 * 作者：chenZY
 * 时间：2018/3/17 18:32
 * 描述：https://github.com/leavesC
 */
public class User {
<span class="hljs-keyword">private</span> String name;

<span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> age;

<span class="hljs-keyword">private</span> <span class="hljs-keyword">boolean</span> sex;

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">User</span><span class="hljs-params">(String name, <span class="hljs-keyword">int</span> age, <span class="hljs-keyword">boolean</span> sex)</span> </span>{
    <span class="hljs-keyword">this</span>.name = name;
    <span class="hljs-keyword">this</span>.age = age;
    <span class="hljs-keyword">this</span>.sex = sex;
}

<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">toString</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-string">"User{"</span> +
            <span class="hljs-string">"name='"</span> + name + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">", age="</span> + age +
            <span class="hljs-string">", sex="</span> + sex +
            <span class="hljs-string">'}'</span>;
}

}

序列化的方法很简单，调用 gson 对象的 toJson 方法，传入要序列化的对象

    public static void main(String[] args) {
        //序列化
        User user = new User("leavesC", 24, true);
        Gson gson = new Gson();
        System.out.println();
        System.out.println(gson.toJson(user));
    }

反序化的方式也类似

    public static void main(String[] args) {
        //反序列化
        String userJson = "{\"name\":\"leavesC\",\"age\":24,\"sex\":true}";
        Gson gson = new Gson();
        User user = gson.fromJson(userJson, User.class);
        System.out.println();
        System.out.println(user);
    }

二、属性重命名

继续使用上一节声明的 User 类，根据 User 类声明的各个属性名，移动端的开发者希望接口返回的数据格式即是如下这样的

{"name":"leavesC","age":24,"sex":true}

如果没有和服务器端沟通好或者是 API 改版了，接口返回的数据格式可能是这样的

{"Name":"leavesC","age":24,"sex":true}

{"userName":"leavesC","age":24,"sex":true}

如果继续使用上一节介绍的方法，那无疑会解析出错
例如

    public static void main(String[] args) {
        //反序列化
        String userJson = "{\"userName\":\"leavesC\",\"age\":24,\"sex\":true}";
        Gson gson = new Gson();
        User user = gson.fromJson(userJson, User.class);
        System.out.println();
        System.out.println(user);
    }

name 属性值解析不到，所以为 null

此时为了兼顾多种格式的数据，就需要使用 SerializedName 注解
根据 SerializedName 的声明来看，SerializedName 包含两个属性值，一个是字符串，一个是字符串数组，而字符串数组含有默认值

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD})
public @interface SerializedName {
    String value();
<span class="hljs-selector-tag">String</span><span class="hljs-selector-attr">[]</span> <span class="hljs-selector-tag">alternate</span>() <span class="hljs-selector-tag">default</span> {};

}

SerializedName 的作用是为了在序列化或反序列化时，指导 Gson 如果将原有的属性名和其它特殊情况下的属性名联系起来

例如，修改 User 类，为 name 声明 SerializedName 注解，注解值为 userName

/**
 * 作者：chenZY
 * 时间：2018/3/17 18:32
 * 描述：https://github.com/leavesC
 */
public class User {
<span class="hljs-meta">@SerializedName</span>(<span class="hljs-string">"userName"</span>)
<span class="hljs-keyword">private</span> String name;

<span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> age;

<span class="hljs-keyword">private</span> <span class="hljs-keyword">boolean</span> sex;

}

在序列时，Json 格式就会相应改变

    public static void main(String[] args) {
        //序列化
        User user = new User("leavesC", 24, true);
        Gson gson = new Gson();
        System.out.println();
        System.out.println(gson.toJson(user));
    }

在反序列化时也一样，能够解析到正确的属性值

    public static void main(String[] args) {
        //反序列化
        String userJson = "{\"userName\":\"leavesC\",\"age\":24,\"sex\":true}";
        Gson gson = new Gson();
        User user = gson.fromJson(userJson, User.class);
        System.out.println();
        System.out.println(user);
    }

还有个问题没解决，为了应对多种属性名不一致的情况，难道我们要声明多个 User 类吗？这显然是不现实的，所以还需要为 User 类设置多个备选属性名，这就需要用到 SerializedName 注解的另一个属性值 alternate 了。

/**
 * 作者：chenZY
 * 时间：2018/3/17 18:32
 * 描述：https://github.com/leavesC
 */
public class User {
<span class="hljs-meta">@SerializedName</span>(value = <span class="hljs-string">"userName"</span>, alternate = {<span class="hljs-string">"user_name"</span>, <span class="hljs-string">"Name"</span>})
<span class="hljs-keyword">private</span> String name;

<span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> age;

<span class="hljs-keyword">private</span> <span class="hljs-keyword">boolean</span> sex;

}

以下几种情况都能够被正确的反序列化

    public static void main(String[] args) {
        //反序列化
        Gson gson = new Gson();
        String userJson = "{\"userName\":\"leavesC\",\"age\":24,\"sex\":true}";
        User user = gson.fromJson(userJson, User.class);
        System.out.println();
        System.out.println(user);
    userJson = <span class="hljs-string">"{\"user_name\":\"leavesC\",\"age\":24,\"sex\":true}"</span>;
    user = gson.fromJson(userJson, User.class);
    System.out.println();
    System.out.println(user);

    userJson = <span class="hljs-string">"{\"Name\":\"leavesC\",\"age\":24,\"sex\":true}"</span>;
    user = gson.fromJson(userJson, User.class);
    System.out.println();
    System.out.println(user);
}

三、字段过滤

有时候并不是所有的字段都需要进行系列化和反序列化，因此需要对某些字段进行排除，有四种方法可以来实现这种需求。

3.1、基于@Expose注解

Expose 注解包含两个属性值，且均声明了默认值。Expose 的含义即为“暴露”，即用于对外暴露字段，serialize 用于指定是否进行序列化，deserialize 用于指定是否进行反序列化。如果字段不声明 Expose 注解，则意味着不进行序列化和反序列化操作，相当于两个属性值均为 false 。此外，Expose 注解需要和 GsonBuilder 构建的 Gson 对象一起使用才能生效。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface Expose {
    boolean serialize() default true;
<span class="hljs-function"><span class="hljs-keyword">boolean</span> <span class="hljs-title">deserialize</span><span class="hljs-params">()</span> <span class="hljs-keyword">default</span> <span class="hljs-keyword">true</span></span>;

}

Expose 注解的注解值声明情况有四种

    @Expose(serialize = true, deserialize = true)   //序列化和反序列化都生效
    @Expose(serialize = false, deserialize = true)  //序列化时不生效，反序列化时生效
    @Expose(serialize = true, deserialize = false)  //序列化时生效，反序列化时不生效
    @Expose(serialize = false, deserialize = false) //序列化和反序列化都不生效，和不写注解一样

现在来看个例子，修改 User 类

/**
 * 作者：chenZY
 * 时间：2018/3/17 18:32
 * 描述：https://github.com/leavesC
 */
public class User {
<span class="hljs-meta">@Expose</span>(serialize = <span class="hljs-keyword">true</span>, deserialize = <span class="hljs-keyword">true</span>)   <span class="hljs-comment">//序列化和反序列化都生效</span>
<span class="hljs-keyword">private</span> String a;

<span class="hljs-meta">@Expose</span>(serialize = <span class="hljs-keyword">false</span>, deserialize = <span class="hljs-keyword">true</span>)  <span class="hljs-comment">//序列化时不生效，反序列化时生效</span>
<span class="hljs-keyword">private</span> String b;

<span class="hljs-meta">@Expose</span>(serialize = <span class="hljs-keyword">true</span>, deserialize = <span class="hljs-keyword">false</span>)  <span class="hljs-comment">//序列化时生效，反序列化时不生效</span>
<span class="hljs-keyword">private</span> String c;

<span class="hljs-meta">@Expose</span>(serialize = <span class="hljs-keyword">false</span>, deserialize = <span class="hljs-keyword">false</span>) <span class="hljs-comment">//序列化和反序列化都不生效，和不写注解一样</span>
<span class="hljs-keyword">private</span> String d;

<span class="hljs-keyword">private</span> String e;

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">User</span><span class="hljs-params">(String a, String b, String c, String d, String e)</span> </span>{
    <span class="hljs-keyword">this</span>.a = a;
    <span class="hljs-keyword">this</span>.b = b;
    <span class="hljs-keyword">this</span>.c = c;
    <span class="hljs-keyword">this</span>.d = d;
    <span class="hljs-keyword">this</span>.e = e;
}

<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">toString</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-string">"User{"</span> +
            <span class="hljs-string">"a='"</span> + a + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">", b='"</span> + b + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">", c='"</span> + c + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">", d='"</span> + d + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">", e='"</span> + e + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">'}'</span>;
}

}

按照如上的注解值，只有声明了 Expose 注解且 serialize 值为 true 的字段才能被序列化，只有声明了 Expose 注解且 deserialize 值为 true 的字段才能被反序列化

    public static void main(String[] args) {
        Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();
        User user = new User("A", "B", "C", "D", "E");
        System.out.println();
        System.out.println(gson.toJson(user));
    String json = <span class="hljs-string">"{\"a\":\"A\",\"b\":\"B\",\"c\":\"C\",\"d\":\"D\",\"e\":\"E\"}"</span>;
    user = gson.fromJson(json, User.class);
    System.out.println();
    System.out.println(user.toString());
}

3.2、基于版本

Gson 提供了 @Since 和 @Until 两个注解基于版本对字段进行过滤，@Since 和 @Until 都包含一个 Double 属性值，用于设置版本号。Since 的意思是“自……开始”，Until 的意思是“到……为止”，一样要和 GsonBuilder 配合使用。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
public @interface Since {
    double value();
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
public @interface Until {
double value();
}

当版本( GsonBuilder 设置的版本) 大于或等于 Since 属性值或小于 Until 属性值时字段会进行序列化和反序列化操作，而没有声明注解的字段都会加入序列化和反序列操作

现在来看个例子，修改 User 类

/**
 * 作者：chenZY
 * 时间：2018/3/17 18:32
 * 描述：https://github.com/leavesC
 */
public class User {
<span class="hljs-meta">@Since</span>(<span class="hljs-number">1.4</span>)
<span class="hljs-keyword">private</span> String a;

<span class="hljs-meta">@Since</span>(<span class="hljs-number">1.6</span>)
<span class="hljs-keyword">private</span> String b;

<span class="hljs-meta">@Since</span>(<span class="hljs-number">1.8</span>)
<span class="hljs-keyword">private</span> String c;

<span class="hljs-meta">@Until</span>(<span class="hljs-number">1.6</span>)
<span class="hljs-keyword">private</span> String d;

<span class="hljs-meta">@Until</span>(<span class="hljs-number">2.0</span>)
<span class="hljs-keyword">private</span> String e;

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">User</span><span class="hljs-params">(String a, String b, String c, String d, String e)</span> </span>{
    <span class="hljs-keyword">this</span>.a = a;
    <span class="hljs-keyword">this</span>.b = b;
    <span class="hljs-keyword">this</span>.c = c;
    <span class="hljs-keyword">this</span>.d = d;
    <span class="hljs-keyword">this</span>.e = e;
}

<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">toString</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-string">"User{"</span> +
            <span class="hljs-string">"a='"</span> + a + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">", b='"</span> + b + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">", c='"</span> + c + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">", d='"</span> + d + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">", e='"</span> + e + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">'}'</span>;
}

}

    public static void main(String[] args) {
        Gson gson = new GsonBuilder().setVersion(1.6).create();
        User user = new User("A", "B", "C", "D", "E");
        System.out.println();
        System.out.println(gson.toJson(user));

        String json = "{\"a\":\"A\",\"b\":\"B\",\"c\":\"C\",\"d\":\"D\",\"e\":\"E\"}";
        user = gson.fromJson(json, User.class);
        System.out.println();
        System.out.println(user.toString());
    }

3.3、基于访问修饰符

访问修饰符由 java.lang.reflect.Modifier 提供 int 类型的定义，而 GsonBuilder 对象的 excludeFieldsWithModifiers方法接收一个 int 类型可变参数，指定不进行序列化和反序列化操作的访问修饰符字段
看个例子

/**
 * 作者：chenZY
 * 时间：2018/3/17 18:32
 * 描述：https://github.com/leavesC
 */
public class ModifierSample {
public <span class="hljs-built_in">String</span> publicField = <span class="hljs-string">"public"</span>;

protected <span class="hljs-built_in">String</span> protectedField = <span class="hljs-string">"protected"</span>;

private <span class="hljs-built_in">String</span> privateField = <span class="hljs-string">"private"</span>;

<span class="hljs-built_in">String</span> defaultField = <span class="hljs-string">"default"</span>;

final <span class="hljs-built_in">String</span> finalField = <span class="hljs-string">"final"</span>;

<span class="hljs-keyword">static</span> <span class="hljs-built_in">String</span> staticField = <span class="hljs-string">"static"</span>;

}

    public static void main(String[] args) {
        Gson gson = new GsonBuilder().excludeFieldsWithModifiers(Modifier.PRIVATE, Modifier.STATIC).create();
        ModifierSample modifierSample = new ModifierSample();
        System.out.println(gson.toJson(modifierSample));
    }

3.4、基于策略

GsonBuilder 类包含 setExclusionStrategies(ExclusionStrategy... strategies)方法用于传入不定长参数的策略方法，用于直接排除指定字段名或者指定字段类型
看个例子

/**
 * 作者：chenZY
 * 时间：2018/3/17 18:32
 * 描述：https://github.com/leavesC
 */
public class Strategies {
<span class="hljs-keyword">private</span> String stringField;

<span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> intField;

<span class="hljs-keyword">private</span> <span class="hljs-keyword">double</span> doubleField;

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">Strategies</span><span class="hljs-params">(String stringField, <span class="hljs-keyword">int</span> intField, <span class="hljs-keyword">double</span> doubleField)</span> </span>{
    <span class="hljs-keyword">this</span>.stringField = stringField;
    <span class="hljs-keyword">this</span>.intField = intField;
    <span class="hljs-keyword">this</span>.doubleField = doubleField;
}

@<span class="hljs-function">Override
<span class="hljs-keyword">public</span> String <span class="hljs-title">toString</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-string">"Strategies{"</span> +
            <span class="hljs-string">"stringField='"</span> + stringField + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">", intField="</span> + intField +
            <span class="hljs-string">", doubleField="</span> + doubleField +
            <span class="hljs-string">'}'</span>;
}

}

public static void main(String[] args) {
        Gson gson = new GsonBuilder().setExclusionStrategies(new ExclusionStrategy() {
            @Override
            public boolean shouldSkipField(FieldAttributes fieldAttributes) {
                //排除指定字段名
                return fieldAttributes.getName().equals("intField");
            }

            @Override
            public boolean shouldSkipClass(Class<?> aClass) {
                //排除指定字段类型
                return aClass.getName().equals(double.class.getName());
            }
        }).create();

        Strategies strategies = new Strategies("stringField", 111, 11.22);
        System.out.println();
        System.out.println(gson.toJson(strategies));

        String json = "{\"stringField\":\"stringField\",\"intField\":111,\"doubleField\":11.22}";
        strategies = gson.fromJson(json, Strategies.class);
        System.out.println();
        System.out.println(strategies);
    }

字段名为 "intField" 和字段类型为 double 的字段都会被排除掉

setExclusionStrategies 方法在序列化和反序列化时都会生效，如果只是想指定其中一种情况下的排除策略或分别指定排除策略，可以改为使用以下两个方法

addSerializationExclusionStrategy(ExclusionStrategy strategy);

addDeserializationExclusionStrategy(ExclusionStrategy strategy);

四、个性化配置

4.1、输出 null

对于 Gson 而言，在序列化时如果某个属性值为 null 的话，那么在序列化时该字段不会参与进来，如果想要显示输出该字段的话，可以通过 GsonBuilder 进行配置

/**
 * 作者：chenZY
 * 时间：2018/3/17 18:32
 * 描述：https://github.com/leavesC
 */
public class Strategies {
<span class="hljs-keyword">private</span> String stringField;

<span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> intField;

<span class="hljs-keyword">private</span> <span class="hljs-keyword">double</span> doubleField;

}

 public static void main(String[] args) {
        Gson gson = new GsonBuilder()
                .serializeNulls() //输出null
                .create();
        Strategies strategies = new Strategies(null, 24, 22.333);
        System.out.println();
        System.out.println(gson.toJson(strategies));
 }

4.2、格式化输出Json

默认的序列化后的 Josn 字符串并不太直观，可以选择格式化输出

    public static void main(String[] args) {
        Gson gson = new GsonBuilder()
                .serializeNulls() //输出null
                .setPrettyPrinting()//格式化输出
                .create();
        Strategies strategies = new Strategies(null, 24, 22.333);
        System.out.println();
        System.out.println(gson.toJson(strategies));
    }

4.3、格式化时间

Gson 也可以对时间值进行格式化

/**
 * 作者：chenZY
 * 时间：2018/3/17 18:32
 * 描述：https://github.com/leavesC
 */
public class Strategies {
<span class="hljs-keyword">private</span> Date date;

<span class="hljs-keyword">private</span> Date date2;

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">Strategies</span><span class="hljs-params">(Date date, Date date2)</span> </span>{
    <span class="hljs-keyword">this</span>.date = date;
    <span class="hljs-keyword">this</span>.date2 = date2;
}

@<span class="hljs-function">Override
<span class="hljs-keyword">public</span> String <span class="hljs-title">toString</span><span class="hljs-params">()</span> </span>{
    SimpleDateFormat simpleDateFormat = <span class="hljs-keyword">new</span> SimpleDateFormat(<span class="hljs-string">"yyyy-MM-dd HH:mm:ss:SSS"</span>, Locale.CHINA);
    <span class="hljs-keyword">return</span> <span class="hljs-string">"Strategies{"</span> +
            <span class="hljs-string">"date="</span> + simpleDateFormat.format(date) +
            <span class="hljs-string">", date2="</span> + simpleDateFormat.format(date2) +
            <span class="hljs-string">'}'</span>;
}

}

public static void main(String[] args) {
        Gson gson = new GsonBuilder()
                .setPrettyPrinting()//格式化输出
                .setDateFormat("yyyy-MM-dd HH:mm:ss:SSS")//格式
化时间
                .create();
        Date date = new Date();
        Strategies strategies = new Strategies(date, new Date(date.getTime() + 1000000));
        System.out.println();
        System.out.println(gson.toJson(strategies));

        String json = "{\n" +
                "  \"date\": \"2018-03-17 19:38:50:033\",\n" +
                "  \"date2\": \"2018-03-17 19:55:30:033\"\n" +
                "}";
        System.out.println();
        System.out.println(gson.fromJson(json, Strategies.class));
    }

五、TypeAdapter

TypeAdapter 是一个泛型抽象类，用于接管某种类型的序列化和反序列化过程，包含两个抽象方法，分别用于自定义序列化和反序列化过程

public abstract void write(JsonWriter var1, T var2) throws IOException;

public abstract T read(JsonReader var1) throws IOException;

下面看个简单的例子

/**
 * 作者：chenZY
 * 时间：2018/3/17 18:32
 * 描述：https://github.com/leavesC
 */
public class User {
<span class="hljs-keyword">private</span> String name;

<span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> age;

<span class="hljs-keyword">private</span> <span class="hljs-keyword">boolean</span> sex;

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">User</span><span class="hljs-params">()</span> </span>{
}

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">User</span><span class="hljs-params">(String name, <span class="hljs-keyword">int</span> age, <span class="hljs-keyword">boolean</span> sex)</span> </span>{
    <span class="hljs-keyword">this</span>.name = name;
    <span class="hljs-keyword">this</span>.age = age;
    <span class="hljs-keyword">this</span>.sex = sex;
}

<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">toString</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-string">"User{"</span> +
            <span class="hljs-string">"name='"</span> + name + <span class="hljs-string">'\''</span> +
            <span class="hljs-string">", age="</span> + age +
            <span class="hljs-string">", sex="</span> + sex +
            <span class="hljs-string">'}'</span>;
}

}

定义 TypeAdapter 的子类 UserTypeAdapter 来接管 User 类的序列化和反序列化过程
这里设定当 User 类序列化时 Json 中的Key值都是大写字母开头，反序列化时支持“name”和“Name”两种不同的 Json 风格

public class UserTypeAdapter extends TypeAdapter<User> {
<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">write</span><span class="hljs-params">(JsonWriter jsonWriter, User user)</span> <span class="hljs-keyword">throws</span> IOException </span>{
    <span class="hljs-comment">//流式序列化成对象开始</span>
    jsonWriter.beginObject();
    <span class="hljs-comment">//将Json的Key值都指定为大写字母开头</span>
    jsonWriter.name(<span class="hljs-string">"Name"</span>).value(user.getName());
    jsonWriter.name(<span class="hljs-string">"Age"</span>).value(user.getAge());
    jsonWriter.name(<span class="hljs-string">"Sex"</span>).value(user.isSex());
    <span class="hljs-comment">//流式序列化结束</span>
    jsonWriter.endObject();
}

<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> User <span class="hljs-title">read</span><span class="hljs-params">(JsonReader jsonReader)</span> <span class="hljs-keyword">throws</span> IOException </span>{
    User user = <span class="hljs-keyword">new</span> User();
    <span class="hljs-comment">//流式反序列化开始</span>
    jsonReader.beginObject();
    <span class="hljs-keyword">while</span> (jsonReader.hasNext()) {
        <span class="hljs-keyword">switch</span> (jsonReader.nextName()) {
            <span class="hljs-comment">//首字母大小写均合法</span>
            <span class="hljs-keyword">case</span> <span class="hljs-string">"name"</span>:
            <span class="hljs-keyword">case</span> <span class="hljs-string">"Name"</span>:
                user.setName(jsonReader.nextString());
                <span class="hljs-keyword">break</span>;
            <span class="hljs-keyword">case</span> <span class="hljs-string">"age"</span>:
                user.setAge(jsonReader.nextInt());
                <span class="hljs-keyword">break</span>;
            <span class="hljs-keyword">case</span> <span class="hljs-string">"sex"</span>:
                user.setSex(jsonReader.nextBoolean());
                <span class="hljs-keyword">break</span>;
        }

    }
    <span class="hljs-comment">//流式反序列化结束</span>
    jsonReader.endObject();
    <span class="hljs-keyword">return</span> user;
}

}

    public static void main(String[] args) {
        Gson gson = new GsonBuilder().registerTypeAdapter(User.class, new UserTypeAdapter()).create();
        User user = new User("leavesC", 24, true);
        System.out.println();
        System.out.println(gson.toJson(user));

        String json = "{\"Name\":\"leavesC\",\"age\":24,\"sex\":true}";
        user = gson.fromJson(json, User.class);
        System.out.println();
        System.out.println(user);
    }

可以看到 User 类按照预定义的策略来完成序列化和反序列化了

六、JsonSerializer 和 JsonDeserializer

TypeAdapter 将序列化和反序列操作都接管了过来，其实 Gson 还提供了只接管序列化过程的接口，即 JsonSerializer
看个例子

    public static void main(String[] args) {
        Gson gson = new GsonBuilder().registerTypeAdapter(User.class, new JsonSerializer<User>() {
            @Override
            public JsonElement serialize(User user, Type type, JsonSerializationContext jsonSerializationContext) {
                JsonObject jsonObject = new JsonObject();
                jsonObject.addProperty("NameHi", user.getName());
                jsonObject.addProperty("Sex", user.isSex());
                jsonObject.addProperty("Age", user.getAge());
                return jsonObject;
            }
        }).create();
        User user = new User("leavesC", 24, true);
        System.out.println();
        System.out.println(gson.toJson(user));
    }

相对应的，JsonDeserializer 接口提供了反序列化的接口

public static void main(String[] args) {
        Gson gson = new GsonBuilder().registerTypeAdapter(User.class, new JsonDeserializer<User>() {
            @Override
            public User deserialize(JsonElement jsonElement, Type type, JsonDeserializationContext jsonDeserializationContext) throws JsonParseException {
                JsonObject jsonObject = jsonElement.getAsJsonObject();
                String name = null;
                //同时支持 userName 和 name 两种情况
                if (jsonObject.has("userName")) {
                    name = jsonObject.get("userName").getAsString();
                } else if (jsonObject.has("name")) {
                    name = jsonObject.get("name").getAsString();
                }
                int age = jsonObject.get("age").getAsInt();
                boolean sex = jsonObject.get("sex").getAsBoolean();
                return new User(name, age, sex);
            }
        }).create();
        String json = "{\"userName\":\"leavesC\",\"sex\":true,\"age\":24}";
        User user = gson.fromJson(json, User.class);
        System.out.println();
        System.out.println(user);
    json = <span class="hljs-string">"{\"name\":\"leavesC\",\"sex\":true,\"age\":24}"</span>;
    user = gson.fromJson(json, User.class);
    System.out.println();
    System.out.println(user);
}

这里有个比较麻烦的地方，那就是在使用 TypeAdapter 、JsonSerializer 和 JsonDeserializer 时，总需要调用 registerTypeAdapter 方法进行注册，那有没有更简单的注册方法呢？
有的，Gosn 还提供了另一个注解 @JsonAdapter 用于进行简单的声明

类似于这样，声明了 User 类的序列化或反序列化操作由 UserTypeAdapter 完成，注解的优先级高于 registerTypeAdapter 方法

@JsonAdapter(UserTypeAdapter.class)
public class User {

}

七、TypeAdapterFactory

TypeAdapterFactory 是用于创建 TypeAdapter 的工厂类，通过参数 TypeToken 来查找确定对应的 TypeAdapter，如果没有就返回 null 并由 Gson 默认的处理方法来进行序列化和反序列化操作，否则就由用户预定义的 TypeAdapter 来进行处理

        Gson gson = new GsonBuilder().registerTypeAdapterFactory(new TypeAdapterFactory() {
            @Override
            public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
                //如果 Gson 需要与 User 类相关的 TypeAdapter ，则返回我们自己定义的 TypeAdapter 对象
                if (typeToken.getType().getTypeName().equals(User.class.getTypeName())) {
                    return (TypeAdapter<T>) new UserTypeAdapter();
                }
                //找不到则返回null
                return null;
            }
        }).create();

八、结语

这一篇文章好像写得太长了一点？Gson 的知识点介绍到这里也差不多了，以后如果还发现新内容的话我会继续补充，现在就先这样啦
此外，可以来简书关注我：叶应是叶 -> https://www.jianshu.com/u/9df45b87cfdf

还有我的 GitHub 主页： leavesC -> https://github.com/leavesC

      </div>
    </div>

BaQiShiGuang

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【转载】Android Gson使用详解

Json 是一种文本形式的数据交换格式，比 xml 更为轻量。Json 的解析和生成的方式很多，在 Android 平台上最常用的类库有 Gson 和 FastJson 两种，这里要介绍的是 GsonGson 的 GitHub 主页点击这里：Gson一、Gson的基本用法1.1、Gson对象在进行序列化与反序列操作前，需要先实例化一个 com...
复制链接

扫一扫