Android入门——数据解析之使用GSON解析JSON字符串（二）

引言

前一篇文章Android进阶——数据解析之创建及使用JSON字符串（一）总结了关于JSON的基本知识以及原生方式解析JSON（初学者可以先移步去了解下JSON），但原生方式在解析复杂JSON时，就会显得有点麻烦和力不从心，而且不够简捷，于是乎在现实项目中很多开发者都会去采用第三方开源库去解析，比如Google的Gson、阿里的FastJson等等，这篇文章先总结GSON解析。

一、Gson概述

Gson是Google的一个开源Java库，可用于将简单的Java对象POJO（Plain Ordinary Java Object,实际就是普通JavaBeans)转换为JSON字符串形式。同时也可以将JSON字符串转换为等效的POJO。而且Gson可以使用任意Java对象，包括您没有源代码的预先存在的对象，Gson把Json字符串映射成对象时的结构。

说到POJO，Gson给了以下的建议和注意事项：

• 成员变量都应声明为private

• 尽量不要使用@Expose 注解指明某个字段是否会被序列化或者反序列化，所有包含在当前类（包括父类）中的字段都应该默认被序列化或者反序列化

• 如果某个字段被 transient 或synthetic修饰，就不会被序列化或者反序列化

• 当序列化的时候，如果对象的某个字段为null，是不应输出到Json字符串中的；当反序列化的时候，某个字段在Json字符串中找不到对应的值，应该被赋值为null

• 内部类（或者匿名类anonymous class，或者局部类local class(可以理解为在方法内部声明的类)）的某个字段和外部类的某个字段一样的话，就会被忽视，不会被序列化或者反序列化

二、Gson 常用术语

• Serialization ：序列化，使POJO到JSON字符串的过程。

• Deserialization：反序列化，JSON字符串转换成POJO。

• JsonElement：该类是一个抽象类，是JsonObject、JsonArray、JsonPrimitive，JsonNull的父类，代表着JSON串的基本元素，该元素可以是一个JsonObject、一个JsonArray、一个Java的基本类型JsonPrimitive、JsonNull等。通过JsonElement提供了一系列的方法来判断当前的JsonElement是否是上述子类的一种，比如isJsonObject()用来判断当前的json元素是否是一个数组类型。

• JsonPrimitive ：对Java的基本类型及其对应的对象类进行了封装，并通过setValue方法为value赋值

• JSONObject ：json对象类，包含了键值对，键是字符串类型，它的值是一个JsonElement。源码中是用 LinkedTreeMap

三、Gson 的常用注解

1、 @SerializedName注解

该注解能指定该字段在JSON中对应的字段名称，当你的POJO中的成员变量名和你JSON字符串的键名不同的时候，可以使用该注解来一一映射。@SerializedName注解中可以设置两个属性，value直接设置JSON字符串中要映射的属性名，alternate 设置备选属性，接受一个字符串数组，当由于设计不严谨或者其他原因每个客户端中定义的JSON属性字段名称不一样的时候，就可以使用alternate 增加备选属性，此时无论出现那个value还是alternate 里的属性都能映射成功（当alternate 里定义的属性出现任意一个时均可以得到正确的结果。当多种情况同时出时，以最后一个出现的值为准）

public class User {

  @SerializedName(value = "nl")
  private int age;

  @SerializedName(value = "xm",alternate = {"mz","m"})
  private String name;

}

当使用注解之后这样的字符串{“nl”:1,”xm”:”CrazyMo_”} 可以被被解析到POJO中对应的age和name字段中。

2、@Since和@Until注解

@Since和@Until注解可以在类，字段，以及将来的版本中的“方法”使用来维护同一对象的多个版本。@Since表示“从…开始”（即xxx 之后），Until 表示”直到…才”，（即xx 之前）。值得注意的是要让这两个注解生效必须将Gson实例配置为忽略大于某个版本号的任何字段/对象。如果Gson实例上没有设置任何版本，则无论版本如何，它都会对所有字段和类进行序列化和反序列化。

  public class Simple {
      private String name;
      @Since(2.0)
      private int id;//id在版本2.0之后才会序列化
      @Until(0.5)
      private String ttx;//，txt在0.5之前才会得到序列化
}

序列化或反序列化带@Since 和@Util 注解的POJO时，需要通过GsonBuilder去设置版本号

VersionedClass versionedObject = new VersionedClass();
Gson gson = new GsonBuilder().setVersion(1.0).create();
String jsonOutput = gson.toJson(someObject);

3、 @Expose注解

该注解能够指定该字段是否能够序列化或者反序列化，默认支持（即为true），Gson建议所有的字段都应该被序列化或者反序列化。如果需要使用得通过GsonBuilder来创建Gson并初始化调用方法builder.excludeFieldsWithoutExposeAnnotation()使之生效。

public class Employee {

  @Expose(deserialize = false)
  private String sex;

  @Expose
  private String name;

  @Expose(serialize = false)
  private int age;

  @Expose(serialize = false, deserialize = false)
  private boolean married;

}
//builder.excludeFieldsWithoutExposeAnnotation()方法是该注解生效
final GsonBuilder builder = new GsonBuilder();
builder.excludeFieldsWithoutExposeAnnotation();
final Gson gson = builder.create();

四、使用Gson完成序列化和反序列化

1、引入Gson类库

直接在APP模块下的gradle.build引入

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
    compile 'com.android.support:appcompat-v7:25.3.1'
    compile 'com.android.support.constraint:constraint-layout:1.0.2'
    testCompile 'junit:junit:4.12'
    compile 'com.google.code.gson:gson:2.8.1'
}

使用Gson完成序列化或反序列化很简单，尤其是当POJO的成员变量名和JSON字符串中的键一一对应的时候，只需要构造对象new Gson()并调用toJson方法或者fromJson系方法即可。

gson.toJson(Object);//序列化
gson.fromJson(Reader,Class);//反序列化
gson.fromJson(String,Class);
gson.fromJson(Reader,Type);
gson.fromJson(String,Type);//其中可以直接写T.class，也可以通过Type type = new TypeToken<T>() {}.getType();

而当POJO的成员变量名和JSON字符串中的键没有一一对应的时候，我们无论是序列化或是反序列化还需要通过代码设置映射，设置映射的方式有两种：通过 使用@SerializedName注解和自定义的类型适配器(TypeAdapter)。

2、序列化（POJO——>JSON）自定义类型适配器(TypeAdapter)的使用

实现序列化自定义类型适配器(TypeAdapter)很简单只需要实现JsonSerializer泛型序列化接口即可。

public interface JsonSerializer<T> {
    /**
     * Gson 会在解析指定类型T数据的时候自动触发当前回调方法进行序列化
     * @param T 需要转化为Json数据的类型，实现的时候传入要具体的类型
     * @return 返回T指定的类对应JsonElement
     */
    public JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context);
}

以{“Name”:”JayChou”,”Sex”:”Man”,”Famoussons”:[“开不了口”,”星晴”,”七里香”]}转化为

public class SuperStar {
    private String[] famousSongs;
    private String name;
    private String sex;
    //getter和setter方法等其他方法略
 }

实现自定义序列化类型适配器

    public class StarSerialiser implements JsonSerializer<SuperStar> {

        @Override
        public JsonElement serialize(SuperStar star, Type typeOfSrc, JsonSerializationContext context) {
            final JsonObject jsonObject = new JsonObject();
            jsonObject.addProperty("Name", star.getName());//把SuperStar中的name字段映射到JSON字符串中的Name属性
            jsonObject.addProperty("Sex", star.getSex());//把SuperStar中的sex字段映射到JSON字符串中的Sex属性
            ///jsonObject.add("isbn-13", star.getFamousSongs());

            final JsonArray jsonSongsArray = new JsonArray();
            for (final String song : star.getFamousSongs()) {
                final JsonPrimitive jsonSong = new JsonPrimitive(song);
                jsonSongsArray.add(jsonSong);
            }
            jsonObject.add("Famoussons", jsonSongsArray);//由于famoussons对应的值是数组所以对应的是JsonArray
            return jsonObject;
        }
    }

借助自定义序列化类型适配器完成序列化

    private void parseBean2JSON(){
        //使用GsonBuilder 创建gson对象
        Gson gson = new GsonBuilder()
                .registerTypeAdapter(SuperStar.class, new StarSerialiser())//注册适配器
                .create();
        SuperStar superStar=new SuperStar(new String[]{"开不了口", "星晴", "七里香"},"JayChou","Man");
        String json = gson.toJson(superStar);
        Log.e("JSON",json.toString());/**06-16 14:36:33.092 16511-16511/com.crazymo.parsejson E/JSON: {"Name":"JayChou","Sex":"Man","Famoussons":["开不了口","星晴","七里香"]}*/
    }

3、反序列化（JSON——>POJO）自定义类型适配器(TypeAdapter)的使用

实现反序列化自定义类型适配器(TypeAdapter)很简单只需要实现JsonDeserializer 泛型反序列化接口即可。

public interface JsonDeserializer<T> {
     public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
      throws JsonParseException;
}

还是以上面的为例，实现反序列化自定义类型适配器

    public class StarDeserializer implements JsonDeserializer<SuperStar>{

        @Override
        public SuperStar deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
            JsonObject jsonObject = json.getAsJsonObject();//要转换的JSON字符串最外层是{}对应的是对象将我们的JsonElement转化为JsonObject
            JsonElement jsonName = jsonObject.get("Name");//通过上一步得到JsonObject对象之后就可以通过键得到对应的值
            String name = jsonName.getAsString();//Gson是先通过JSONObject的键获取对应的值，但是此时值的类型是JsonElement的还需要转为String
            String sex = jsonObject.get("Sex").getAsString();
            JsonArray jsonSongsArray = jsonObject.get("Famoussons").getAsJsonArray();
            String[] songs = new String[jsonSongsArray.size()];
            for (int i = 0; i < songs.length; i++) {
                JsonElement jsonAuthor = jsonSongsArray.get(i);
                songs[i] = jsonAuthor.getAsString();
            }

            SuperStar star = new SuperStar(songs,name,sex);
            return star;
        }
    }

测试

    private void parseJSON2Bean(){
        String json="{\"Name\":\"JayChou\",\"Sex\":\"Man\",\"Famoussons\":[\"开不了口\",\"星晴\",\"七里香\"]}";
        GsonBuilder gsonBuilder = new GsonBuilder();//通过GsonBuilder构造gson
        //gsonBuilder.registerTypeAdapter(SuperStar.class, new StarDeserializer());
        gsonBuilder.registerTypeAdapter(new TypeToken<SuperStar>() {}.getType(), new StarDeserializer());
        Gson gson = gsonBuilder.create();
        SuperStar star=gson.fromJson(json,SuperStar.class);
        Log.e("JSON",star.toString());

    }

Gson也支持直接读取本地的JSON文件完成序列化，直接传入一个InputStreamReader对象inReader再调用gson.fromJson（inReader,type）

五、支持空对象null

默认情况下Gson为了实现更紧凑的输出格式而忽略空对象字段，所以必须为这些字段定义一个默认值。要想输出null，就需要对gson进行以下配置

Gson gson = new GsonBuilder().serializeNulls().create();//配置Gson实例以输出null的方式：

以官网上为例

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);//{"s":null,"i":5}
json = gson.toJson(null);
System.out.println(json);//null

六、使用GsonBuilder导出null值、格式化输出、日期时间

从上面的例子我们知道可以通过GsonBuilder构造gson对象并注册类型适配器来解决POJO与JSON中字段不匹配的问题，其实GsonBuilder还可以帮助我们实现其他一些辅助格式化的工作，可以通过GsonBuilder来间接配置Gson。

Gson gson = new GsonBuilder()
        //序列化null
        .serializeNulls()
        // 设置日期时间格式，另有2个重载方法
        // 在序列化和反序化时均生效
        .setDateFormat("yyyy-MM-dd")
        // 禁此序列化内部类（而非嵌套类）
        .disableInnerClassSerialization()
        //生成不可执行的Json（多了 )]}' 这4个字符）
        .generateNonExecutableJson()
        //禁止转义html标签
        .disableHtmlEscaping()
        //格式化输出
        .setPrettyPrinting()
        .create();

PS:内部类和嵌套类的区别

//静态的内部类称嵌套类（Nested Class）
class Outer {
  class Inner { } //Inner class
  static class Nested { }  //Nested class
}
/*********区别***********/
/*1、内部类的对象隐含一个外部类的对象引用，可以直接引用外部类的方法和属性，另外内部类不能定义静态的属性和*方法，创建内部类对象必须依赖于一个外部对象。
*2、嵌套类不能直接引用外部类的non-satic属性和方法，创建嵌套类对象时不依赖外部类 对象
*********区别***********/