Android：Gson解析——从简单数据到复杂数据

最新推荐文章于 2024-09-18 15:28:05 发布

noige

最新推荐文章于 2024-09-18 15:28:05 发布

阅读量2.2k

点赞数

Json是一种轻量级的数据交换语言，以文字为基础，且易于让人阅读和编写，同时也易于机器解析和生成，因而在客户端与服务器交互中得到广泛应用。但Json自带的解析类用起来却差强人意，所以市面上因运而生了很多Json转换利器，本文主要介绍其中之一Gson。Gson是google发布的library，主要为了方便将Java对象序列化Serialization至轻量化的封包格式JSON，提供了很多方便快捷的方法。

通过gradle导入包

登录网站MVNRepository，在搜索框中搜索gson，即可出现各种不同的版本，选择gradle下需要的版本，并复制到gradle文件中即可。

Gson基本用法

Gson提供了两个方法直接用于解析和生成方法，二者都有重载方法：

fromJson()：实现反序列化
toJson()：实现序列化

基本数据类型的生成

Gson gson = new Gson();
String jsonNumber = gson.toJson(100); // 100
String jsonBoolean = gson.toJson(false); // false
String jsonString = gson.toJson("String"); //"String"

POJO类的生成与解析

对于普通Java类：

public class User {
   public String name; 
   public int age; 
}

生成JSON

Gson gson = new Gson();
User user = new User("Sunny",24);
String jsonObject = gson.toJson(user); // {"name":"Sunny","age":24}

解析JSON

Gson gson = new Gson();
String jsonString = "{\"name\":\"sunny\",\"age\":24}";
User user = gson.fromJson(jsonString, User.class);

注：POJO（Plain Old Java Object）表示普通Java对象，不是JavaBean，EntityBean或者SessionBean。POJO不担当任何特殊的角色，也不实现任何特殊的Java框架的接口。

Gson中的泛型

当我们解析Json数组时，一般有两种方式：使用数组，使用List。而List对于增删都比较方便，所以实际用List较多

数组

String[] strings = gson.fromJson(jsonArray, String[].class);

但对于List将上面代码中的 String[].class ，不能直接改为List<String>.class。对于Java来说 List<String> 和List<User>这两个字节码文件只有一个，就是 List.class，这就是Java泛型使用时要注意的泛型擦除问题。

List

为了解决上述问题，Gson提供TypeToken来实现对泛型的支持。TypeToken 这个类帮助我们捕获（capture）像 List 这样的泛型信息。Java编译器会把捕获到的泛型信息编译到这个匿名内部类里，然后在运行时就可以被 getType() 方法用反射的 API 提取到。也就是将泛型T转成 .class

List<String> stringList = gson.fromJson(jsonArray, new TypeToken<List<String>>() {}.getType());

注：TypeToken
的构造方法是protected
修饰的,所以上面才会写成new TypeToken<List<String>>() {}.getType()
而不是new TypeToken<List<String>>().getType()

@Expose、@SerializeName注解的使用

Json解析的字段和值得名称和类型是一一对应的，但有时前端和后台使用的语言不同，二者语言规范风格不同，命名时常常会出现不和谐的地方。这时 @Expose @SerializeName 两个注解就要发挥他们的作用啦

@Expose注解：区分实体中不想被序列化的属性，其自身包含两个属性deserialize(反序列化)和serialize(序列化)，默认都为true
@SerializeName注解：定义属性序列化后的名称
使用 new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();创建Gson对象，没有@Expose注释的属性将不会被序列化.。另外想要不序列化某个属性，也可以使用transient。

Gson在序列化和反序列化时需要使用反射，说到反射就想到注解,一般各类库都将注解放到annotations包下，打开源码在com.google.gson包下有一个annotations类，其中有一个SerializedName的注解类，这就是我们用到的。

Gson解析复杂Json数据

首先，要知道两个类：
1、JsonParse
从名称我们就可以看出，这是一个解析类。没错，它可以把 JSON 数据分别通过getAsJsonObject和getAsJsonArray解析成JsonObject和JsonArray。这跟普通的解析 JSON 差不多。
2、JsonElement
是一个抽象类，代表 JSON 串中的某一个元素，可以是JsonObject/JsonArray/JsonPrimitive/...中的任何一种元素。

没有数据头的纯数组

JSON里面只有一个数组，而数组中没有名字：

[
  {
    "name": "zhangsan",
    "age": "10",
    "phone": "11111",
    "email": "11111@11.com"
  },
  {
    "name": "lisi",
    "age": "20",
    "phone": "22222",
    "email": "22222@22.com"
  },
  ...
]

开始解析，首先定义一个用户类：

public class UserBean {
    //变量名跟JSON数据的字段名需要一致
    private String name ;
    private String age;
    private String phone;
    private String email;
    ...
}

方法一：Gson可以直接解析成一个List

List<UserBean> userList = gson.fromJson(jsonStr, new TypeToken<List<UserBean>>(){}.getType());

方法二：传统老实方法

    //Json的解析类对象
    JsonParser parser = new JsonParser();
    //将JSON的String 转成一个JsonArray对象
    JsonArray jsonArray = parser.parse(strByJson).getAsJsonArray();

    Gson gson = new Gson();
    ArrayList<UserBean> userBeanList = new ArrayList<>();

    //加强for循环遍历JsonArray
    for (JsonElement user : jsonArray) {
        //使用GSON，直接转成Bean对象
        UserBean userBean = gson.fromJson(user, UserBean.class);
        userBeanList.add(userBean);
    }

有数据头的纯数组数据

{
  "user": [
    {
      "name": "zhangsan",
      "age": "10",
      "phone": "11111",
      "email": "11111@11.com"
    },
    {
      "name": "lisi",
      "age": "20",
      "phone": "22222",
      "email": "22222@22.com"
    },
    ...
  ]
}

开始解析：

    //先转JsonObject
    JsonObject jsonObject = new JsonParser().parse(strByJson).getAsJsonObject();
    //再转JsonArray 加上数据头
    JsonArray jsonArray = jsonObject.getAsJsonArray("user");

    Gson gson = new Gson();
    ArrayList<UserBean> userBeanList = new ArrayList<>();

    //循环遍历
    for (JsonElement user : jsonArray) {
        //通过反射 得到UserBean.class
        UserBean userBean = gson.fromJson(user, new TypeToken<UserBean>() {}.getType());
        userBeanList.add(userBean);
    }

有数据头的复杂数据

{
  "code": 200,
  "msg": "OK",
  "user": [
    {
      "name": "zhangsan",
      "age": "10",
      "phone": "11111",
      "email": "11111@11.com"
    },
    {
      "name": "lisi",
      "age": "20",
      "phone": "22222",
      "email": "22222@22.com"
    },
    ...
  ]
}

开始解析：
第一步：根据 JSON 建立 Bean ，注意这里的 Bean 是返回所有字段，因为 GSON 能直接解析成 List ，同时把 get/set 省略。

public class ResultBean {
    //注意变量名与字段名一致
    private int code;
    private String msg;
    private List<UserBean> user;

    public class UserBean{
        private String name ;
        private String age;
        private String phone;
        private String email;
        ...
    }
    ...
}

注意：这个类中有一个UserBean，也可以定义在外面，可以作为JsonArray解析后存入List中的对象。

   //GSON直接解析成对象
    ResultBean resultBean = new Gson().fromJson(strByJson,ResultBean.class);
    //对象中拿到集合
    List<ResultBean.UserBean> userBeanList = resultBean.getUser();