最新公告
  • 新注册用户请前往个人中心绑定邮箱以便接收相关凭证邮件!!!点击前往个人中心
  • 除了FastJson,你还有选择: Gson简易指南

    本文所涉及所有代码片段均在下面仓库中,感兴趣的小伙伴欢迎参考学习:

    https://github.com/wrcj12138aaa/gson-actions

    版本支持:

    • JDK 8
    • gson 2.8.5
    • junit 5.5.1
    • Lomok 1.18.8

    Gson 简介

    在正式介绍 Gson 之前,我们可以先从官方的wiki看下 Gson 的描述,了解它是什么?

    Gson is a Java library that can be used to convert Java Objects into their JSON representation. It can also be used to convert a JSON string to an equivalent Java object。

    从描述可以看出,Gson 是用于将 Java 对象与 JSON格式字符串数据相互转换的 Java 库。它起初在Google 内部广泛使用在 Android 平台 和 Java 服务端上。2008 年开源之后,成为了谷歌又一个被广泛使用的开源框架,截止目前(2019.09.08) 在GitHub 上已有1W6 多星,相同作用的类库还有 Spring Framework 中集成的 Jackson,以及阿里开源的 FastJson等。

    在使用方面,Gson 提供简易的API fromJson/toJson 来实现 Java 与 JSON 之间的转换,并且能生成紧凑,可读的 JSON 字符串输出,还支持复杂对象转换和丰富的自定义表示,足以满足在日常开发中我们绝大部分的 JSON 数据处理需求。

    我们通常将对象与JSON字符串间的转换称之为序列化和反序列化(Serialization/Deserialization)。将对象转化成 JSON字符串的过程称为序列化,将JSON 字符串转化成对象的过程称为反序列化。

    Gson 基本使用

    使用 Gson 框架进行序列化与反序列操作,都离不开 com.google.gson.Gson 对象,它也是 Gson 框架的关键对象,提供的公共 API 具备了多种序列化和反序列方式。

    Gson 对象的创建主要有两种方式:

    • 使用 new 关键字直接创建:Gson gson = new Gson()
    • 由 GsonBuilder 对象构建:Gson gson = new GsonBuilder().create()

    通常情况下,上面两种方式创建的 Gson 对象在进行序列化与反序列操作时行为都是一样的,但是第二种方式构建 Gson 对象时,允许进行额外的行为定制,比如格式化 JSON 字符串的输出内容,是否序列化 null 值等等。

    Java 序列化

    简单对象的序列化

    我们可以通过下面的例子来看下通过上述两种方式序列化 Java 对象的不同效果:

    publicclassResultTest{

    @Test

    voidtest_serialization(){

    Gson gson = new Gson();

    Result result = new Result(200, “成功”, null);

    String json = gson.toJson(result);

    System.out.println(“json is ” + json);

    Gson buildedGson = new GsonBuilder().setPrettyPrinting().serializeNulls().create();

    String buildedJson = buildedGson.toJson(result);

    System.out.println(“buildedJson is ” + buildedJson);

    }

    classResult{

    privateint code;

    private String message;

    private Object data;

    publicResult(int code, String message, Object data){

    this.code = code;

    this.message = message;

    this.data = data;

    }

    }

    }

    运行该测试用例,在控制台可以看到如下日志输出:

    从结果可以看出,默认的 Gson 对象行为序列化对象时会将 null 值的字段忽略,而执行 com.google.gson.GsonBuilder#serializeNulls 方法后将允许 Gson 对象序列化 null 字段;并且正常序列化后的 JSON 字符串是紧凑格式,节省字符串内存,使用 com.google.gson.GsonBuilder#setPrettyPrinting 方法之后最终输出的 JSON 字符串是更易读的格式。当然除了这两个方法,GsonBuilder 还提供了许多定制序列化和反序列化行为的API,我们将后面的内容进一步讲解。

    JosnObject 生成 JSON

    除了上述将自定义类的对象转换成 JSON 的方式之外,还可以使用 Gson 框架提供的 JsonObject 构建普通对象,然后使用 toJson 方法生成 JSON 字符串,在原测试类中补充下方测试类,并运行查看效果如下

    @Test

    voidtest_jsonObject_serialization(){

    Gson gson = new Gson();

    JsonObject jsonObject = new JsonObject();

    jsonObject.addProperty(“code”, 400);

    jsonObject.addProperty(“message”, “参数错误”);

    String toJson = gson.toJson(jsonObject);

    String exceptedJson = “{\”code\”:400,\”message\”:\”参数错误\”}”;

    Assertions.assertEquals(exceptedJson, toJson); //true

    }

    JsonObject 使用 addProperty(property,value) 方法只能用来添加 String,Number,Boolean,Character这四类数据, 因为内部是调用 com.google.gson.JsonObject#add, 并将 value 封装成了 JsonPrimitive 对象,然后保存到了内部自定义的 LinkedTreeMap 集合变量 members 中;如果需要在 JsonObject 对象上添加其他对象时,就需要直接使用 add(String property, JsonElement value) 方法添加一个 JsonElement 对象。这里的 JsonElement 是一个抽象类,JsonObject 和 JsonPrimitive 都继承了JsonElement,所以我们最终通过新的 JsonObject 对象来作为原 JsonObject 上的属性对象:

    Gson gson = new Gson();

    JsonObject jsonObject = new JsonObject();

    //…

    JsonObject nestJsonObject = new JsonObject();

    nestJsonObject.addProperty(“username”, “one”);

    nestJsonObject.addProperty(“score”, 99);

    jsonObject.add(“data”, nestJsonObject);

    String toJson2 = gson.toJson(jsonObject);

    System.out.println(toJson2);

    // {“code”:400,”message”:”参数错误”,”data”:{“username”:”one”,”score”:99}}

    JSON 反序列化

    简单对象的反序列化

    现在我们再来看下 JSON 反序列化成 Java 对象用法,这里主要使用方法是 com.google.gson.Gson#fromJson,它最基础的用法就是 fromJson(String json, Class<T> classOfT),尝试将 JSON 字符串转为指定 Class 的对象,如果转换失败,就会抛出 JsonSyntaxException 异常。我们可以在原来代码上新增一个测试用例,运行看下效果:

    @Test

    voidtest_deserialization(){

    String json = “{\”code\”:400,\”message\”:\”参数错误\”}”;

    Result result = new Gson().fromJson(json, Result.class);

    Assertions.assertEquals(400, result.code); // true

    Assertions.assertEquals(“参数错误”, result.message); // true

    }

    反序列化 Map

    除了将JSON 字符串序列化为自定义的Java 对象之外,我们该可以转为 Map 集合,Gson 提供了对 Map 集合的转换,使用起来也十分简单:

    @Test

    voidtest_map(){

    String jsonString = “{’employee.name’:’one’,’employee.salary’:10}”;

    Gson gson = new Gson();

    Map map = gson.fromJson(jsonString, Map.class);

    assertEquals(2, map.size());

    assertEquals(“one”, map.get(“employee.name”));

    assertEquals(Double.class, map.get(“employee.salary”).getClass());

    }

    需要注意的是转换后的 Map 对象真实类型并不是我们经常用的 HashMap,而是 Gson 自定义集合LinkedTreeMap ,它实现Map 接口了,存储键值对,在新增和删除上实现上进行了优化,并且将存储键值对的顺序作为遍历顺序,也就是先存入的先被遍历到。除此之外,JSON 字符串里的数值型数据都会转转换为 Double 类型,而 true/false 数据被会被转换成 Boolean 类型,具体判断依据可以参考 com.google.gson.internal.bind.ObjectTypeAdapter#read 方法实现。

    JSON 与 Array,List 转换

    JSON 转换 Array

    当我们正对 JSON 数据进行数组转换时,类似普通对象转换的方式即可,toJson 方法直接使用转为 JSON 数据;使用fromJson 指定数组类型转换为对应类型的数组。

    @Test

    voidtest_array(){

    Gson gson = new Gson();

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

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

    String s = gson.toJson(ints);// [1,2,3,4,5]

    assertEquals(“[1,2,3,4,5]”, s); // true

    String s1 = gson.toJson(strings);// [“abc”, “def”, “ghi”]

    assertEquals(“[\”abc\”,\”def\”,\”ghi\”]”, s1);

    String[] strings1 = gson.fromJson(s1, String[].class);

    assertEquals(strings.length, strings1.length); // true

    assertEquals(strings[0], strings1[0]); // true

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

    assertEquals(1, ints2[0]); // true

    assertEquals(5, ints2[4]); // true

    }

    JSON 转换 List

    要将 List 数据转换为 JSON数据,使用 Gson 的方式与处理 Array 数据一样;而将JSON 数据转为 List 对象的操作略有不同,要将一个 JSON 数组数据转则换为一个自定义类的List 时,我们按照原来的写法如下:

    @Test

    publicvoidgivenJsonString_whenIncorrectDeserializing(){

    Gson gson = new Gson();

    String inputString = “[{\”id\”:1,\”name\”:\”one\”},{\”id\”:2,\”name\”:\”two\”}]”;

    List<Person> outputList = gson.fromJson(inputString, List.class);

    outputList.get(0).getId();

    }

    但是不幸的是,运行这段代码后会抛出 ClassCastException 异常,具体描述如下:

    java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.one.learn.Person

    从上述描述中我们可以知道执行 fromJson 之后,反序列化后得到的 List 元素类型为 LinkedTreeMap,而不是 Person,所以以 Person 对象方式访问 id 属性时就会抛出 ClassCastException 异常。那又该如何处理呢, 我们需要使用 Gson 的 另外一个 fromJson 方法:fromJson(String json, Type typeOfT) ,先看下使用方式

    @Test

    publicvoidgivenJsonString_whenCorrectDeserializing_(){

    Gson gson = new Gson();

    String inputString = “[{\”id\”:1,\”name\”:\”one\”},{\”id\”:2,\”name\”:\”two\”}]”;

    Type type = new TypeToken<List<Person>>(){}.getType();

    List<Person> outputList = gson.fromJson(inputString, type);

    int id = outputList.get(0).getId();

    assertEquals(1, id); // true

    assertEquals(“one”, outputList.get(0).getName()); // true

    }

    这个方法中的 Type 对象通过 TypeToken 对象的 getType 方法获取到,是 TypeToken 对象所关联的泛型类型。而这里 TypeToken 是 Gson 为了支持泛型而引入的类,来解决 Java 无法提供泛型类型表示的问题,由于 TypeToken 的构造方法是protected修饰的,无法直接构造,使用就需要写成new TypeToken<List<String>>() {}.getType() 形式。

    Gson 进阶用法

    接触了 Gson 基本的使用之后,我们接着进一步学习 Gson 的其他用法。

    泛型对象的反序列化

    上节内容简单接触了 Gson 对泛型的支持,接下来用代码来展示下它的强大之处,首先我们将上文的 Result 类调整下接受泛型参数:

    classResult<T> {

    privateint code;

    private String message;

    private T data;

    publicResult(int code, String message, T data){

    this.code = code;

    this.message = message;

    this.data = data;

    }

    }

    然后对一个有内嵌对象的 JSON字符串进行解析成 Result<User>对象,示例代码如下:

    @Test

    voidtest_genric_object(){

    String json = “{\”code\”:200,\”message\”:\”操作成功\”,\”data\”:{\”username\”: \”one\”,\”avater\”: \”image.jpg\”” +

    “}}”;

    Type type = new TypeToken<Result<User>>(){}.getType();

    Result<User> result = new Gson().fromJson(json, type);

    Assertions.assertEquals(200, result.code);

    Assertions.assertEquals(“one”, result.data.getUsername());

    Assertions.assertEquals(“image.jpg”, result.data.getAvater());

    }

    classUser{

    private String username;

    private String avater;

    public String getUsername(){

    return username;

    }

    public String getAvater(){

    return avater;

    }

    }

    利用 TypeToken 对象获取具体泛型类型 Result<User>, 然后在 fromJson 方法中传入就会根据对应类型的执行反序列化操作。

    自定义序列化

    如果我们要对Java 对象的某些字段进行特殊处理,比如隐藏某些字段的序列化,对字段的数据格式化处理等,我们可以通过实现 JsonSerializer 接口,对序列化逻辑进行自定义。例如,我们需要对 Date 类型属性进行特定格式的处理,可以声明 DateSerializer 类实现如下:

    classDateSerializerimplementsJsonSerializer<Date> {

    SimpleDateFormat dateTime = new SimpleDateFormat(“yyyy-MM-dd”);

    @Override

    public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context){

    returnnew JsonPrimitive(dateTime.format(src));

    }

    }

    然后在构建 Gson 对象前,利用 GsonBuilder 将 DateSerializer 实例进行注册,使用方式如下:

    Gson gson = new GsonBuilder().registerTypeAdapter(Date.class, new DateSerializer()).create();

    这样一来,一旦遇到要序列化 Date 类型的字段时,都会通过自定义的 serialize 方法将日期以 yyyy-MM-dd 格式进行输出,如下方的示例代码:

    @Test

    voidtest_dateSerializer(){

    MyObject myObject = new MyObject(new Date(), “one”);

    Gson gson = new GsonBuilder().registerTypeAdapter(Date.class, new DateSerializer()).create();

    String json = gson.toJson(myObject);

    String exceptedJson = “{\”date\”:\”2019-09-08\”,\”name\”:\”one\”}”;

    Assertions.assertEquals(exceptedJson, json); // true

    }

    classMyObject{

    private Date date;

    private String name;

    publicMyObject(Date date, String name){

    this.date = date;

    this.name = name;

    }

    publicMyObject(){

    }

    }

    自定义反序列化

    与自定义序列化实现方式类似,想要自定义反序列化逻辑,就需要同样要实现一个叫 JsonDeserializer 的接口,进行自定义反序列化逻辑的实现。比如现在有个 JSON 字符串内容为 {“CODE”: 400, “MESSAGE”: “参数错误”},需要被反序列化为前文提到的 Result 对象,由于字段名不一样,为了实现对应的转换,就需要自定义 ResultDeserializer 类,具体实现如下:

    classResultDeserializerimplementsJsonDeserializer<Result> {

    @Override

    public Result deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)throws JsonParseException {

    JsonObject object = json.getAsJsonObject();

    Result<Object> result = new Result<>(object.getAsJsonPrimitive(“CODE”).getAsInt(),object.getAsJsonPrimitive(“MESSAGE”).getAsString(), null);

    return result;

    }

    }

    接下来就是利用 GsonBuilder 注册 ResultDeserializer 实例,生成对应的 Gson 对象,用于反序列化操作时生效:

    @Test

    voidtest_resultDeserializer(){

    //language=JSON

    String json = “{\”CODE\”: 400,\”MESSAGE\”: \”参数错误\”}”;

    Gson gson = new GsonBuilder().registerTypeAdapter(Result.class, new ResultDeserializer()) .create();

    Result result = gson.fromJson(json, Result.class);

    Assertions.assertEquals(400, result.code); // true

    Assertions.assertEquals(“参数错误”, result.message); // true

    }

    Gson 常用注解

    Gson 除了提供一些 API 供开发者使用之外,还有一些具有特性的注解可以使用,接下来就介绍在 Gson 中最常用的注解。

    @Expose

    这个注解只能用在字段上,作用就是注明对应的字段是否将在序列化或者反序列化时暴露出来,有两个属性 serialize 和 deserialize ,默认都为 true。当给一个字段加上 注解@Expose(serialize = true, deserialize = false),则表示了该字段尽在序列化时可见,在反序列化时会忽略赋值。需要额外注意的一点是,@Expose 注解只有在用 GsonBuilder 方式构建 Gson 时有效,并且构建前必须调用 excludeFieldsWithoutExposeAnnotation 方法,否则解析时对声明注解的字段没有任何效果,下面是具体的使用示例:

    @Test

    voidtest_expose(){

    MySubClass subclass = new MySubClass(42L, “the answer”, “Verbose field not to serialize”);

    MyClass source = new MyClass(1L, “foo”, “bar”, subclass);

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

    String s = gson.toJson(source);

    System.out.println(s);

    // {“name”:”foo”,”subclass”:{“id”:42,”description”:”the answer”,”otherVerboseInfo”:”Verbose field not to serialize”}}

    }

    @Data

    @AllArgsConstructor

    classMyClass{

    privatelong id;

    @Expose(serialize = false, deserialize = true)

    private String name;

    privatetransient String other;

    @Expose

    private MySubClass subclass;

    }

    @Data

    @AllArgsConstructor

    classMySubClass{

    @Expose

    privatelong id;

    @Expose

    private String description;

    @Expose

    private String otherVerboseInfo;

    }

    在 Gson 中 transient 关键字修饰的字段默认不会被序列化和反序列化,这个行为是与 Java 原生的序列化和反序列化操作一致的。

    @Since

    该注解用于标记对应字段或者类型的版本,让 Gson 可以指定版本号进行序列化和反序列化操作。当Web服务上的 JSON 数据对应的实体类存在多个版本的字段时,这个注解就十分有用。

    同样地,该注解只针对使用 GsonBuilder 方式构建的 Gson 对象,并且使用 setVersion 方法指明版本号时有效,设置后只会解析对象中对应版本的字段,下面为具体示例:

    publicclassVersioningSupportTest{

    @Test

    voidtest(){

    VersionedClass versionedObject = new VersionedClass();

    Gson gson = new GsonBuilder().setVersion(1.0).create();

    String jsonOutput = gson.toJson(versionedObject);

    System.out.println(jsonOutput); // {“newField”:”new”,”field”:”old”}

    }

    }

    classVersionedClass{

    @Since(1.1)

    privatefinal String newerField;

    @Since(1.0)

    privatefinal String newField;

    privatefinal String field;

    publicVersionedClass(){

    this.newerField = “newer”;

    this.newField = “new”;

    this.field = “old”;

    }

    }

    @SerializedName

    这个注解使用起来比较简单,也很有用。@SerializedName 指定了成员字段被序列化和反序列化时所采用的名称,便于我们调整JSON数据与对应实体类字段名不一致的问题,下面是具体使用方式:

    publicclassJSONFieldNamingSupportTest{

    privateclassSomeObject{

    @SerializedName(“custom_naming”)

    privatefinal String someField;

    privatefinal String someOtherField;

    publicSomeObject(String a, String b){

    this.someField = a;

    this.someOtherField = b;

    }

    }

    @Test

    voidtest(){

    SomeObject someObject = new SomeObject(“first”, “second”);

    String jsonRepresentation = gson.toJson(someObject);

    System.out.println(jsonRepresentation);

    // {“custom_naming”:”first”,”someOtherField”:”second”}

    SomeObject someObject1 = gson.fromJson(jsonRepresentation, SomeObject.class);

    System.out.println(someObject1);

    // SomeObject{someField=’first’, someOtherField=’second’}

    }

    }

    @JsonAdapter

    不同于上面的注解,@JsonAdapter 只作用于类上,主要作用就是代替GsonBuilder.registerTypeAdapter 方法的执行,直接通过 @JsonAdapter(aClass.class) 方式指定 JsonDeserializer 对象或者 JsonSerializer 对象,可以起到相同的想过,并且优先级比GsonBuilder.registerTypeAdapter的优先级更高,由于只是将 registerTypeAdapter方法执行简化成了注解方法,这里就不再演示,直接在前文自定义反序列化一节的 Result<T> 类上使用就可以看到效果。

    结语

    本文主要学习总结了 Gson 框架的序列化和反序列操作使用方式,以及介绍了 Gson 多种特性用法,希望对处理 JSON 数据感到头疼的小伙伴有所帮助。

    在看

    本站所有文章均由网友分享,仅用于参考学习用,请勿直接转载,如有侵权,请联系网站客服删除相关文章。若由于商用引起版权纠纷,一切责任均由使用者承担
    极客文库 » 除了FastJson,你还有选择: Gson简易指南

    常见问题FAQ

    如果资源链接失效了怎么办?
    本站用户分享的所有资源都有自动备份机制,如果资源链接失效,请联系本站客服QQ:2580505920更新资源地址。
    如果用户分享的资源与描述不符怎么办?
    可以联系客服QQ:2580505920,如果要求合理可以安排退款或者退赞助积分。
    如何分享个人资源获取赞助积分或其他奖励?
    本站用户可以分享自己的资源,但是必须保证资源没有侵权行为。点击个人中心,根据操作填写并上传即可。资源所获收益完全归属上传者,每周可申请提现一次。
    如果您发现了本资源有侵权行为怎么办?
    及时联系客服QQ:2580505920,核实予以删除。

    参与讨论

    • 176会员总数(位)
    • 3737资源总数(个)
    • 0本周发布(个)
    • 0 今日发布(个)
    • 542稳定运行(天)

    欢迎加入「极客文库」,成为原创作者从这里开始!

    立即加入 了解更多
    成为赞助用户享有更多特权立即升级