最全Gson使用介绍，通俗易懂。

最新推荐文章于 2024-04-23 09:00:12 发布
最新推荐文章于 2024-04-23 09:00:12 发布
阅读量7.9k 收藏 69
点赞数 7
分类专栏： 学习记录 文章标签： java json 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55051386/article/details/122231773
版权

Gson介绍

GSON是Google提供的用来在Java对象和JSON数据之间进行映射的Java类库。可以将一个Json字符转成一个Java对象，或者将一个Java转化为Json字符串

在使用Gson时需要先引入Gson依赖

    <!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.5</version>
    </dependency>

Gson使用

1. 简单对象 序列化/反序列化

序列化：

    /**
     * 简单对象转Json
     *
     * @param obj
     * @return
     */
    public static String simpleObjToJson(Object obj) {
        if (Objects.isNull(obj)) return "";
        try {
            Gson gson = new Gson();
            return gson.toJson(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

测试：

    @Test
    void GsonUtilTest() {
        // 简单对象转json
        User user = new User(1, "张三", 18);
        String json = GsonUtil.simpleObjToJson(user);
        System.out.println(json);
    }

结果：

{"id":1,"name":"张三","age":18}

如果对象中存在空值：

先看一下user对象中的数据类型

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private Integer age;

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public User(String name) {
        this.name = name;
    }
}

测试：

@Test
void GsonUtilTest() {
    // 简单对象转json
    User user = new User("张三");
    String json = GsonUtil.simpleObjToJson(user);
    System.out.println(json);
}

结果：

{"id":0,"name":"张三"}

可以看出基本类型有默认值，包装类不解析

反序列化：

    /**
     * 简单Json转对象
     *
     * @param json
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> T simpleJsonToObj(String json, Class<T> cls) {
        Gson gson = new Gson();
        if (Objects.isNull(json)) return null;
        T obj = gson.fromJson(json, cls);
        if (Objects.isNull(obj)) {
            return null;
        } else {
            return obj;
        }
    }

测试：

@Test
void test2() {
    String json = "{\"id\":1,\"name\":\"张三\",\"age\":18}";
    User user = GsonUtil.simpleJsonToObj(json, User.class);
    System.out.println(user);
}

结果：

User(id=1, name=张三, age=18)

2. 复杂对象 序列化/反序列化（对象中嵌套对象）

同简单对象一样

序列化：

复杂对象：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private Integer age;
    private Job job;
    private List<String> nickName;

    public User(int id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
}


@Data
public class Job {
    private String jobName;
    private String company;
}

    /**
     * 复杂对象转Json
     * 
     * @param obj
     * @return
     */
    public static String complexObjToJson(Object obj) {
        if (Objects.isNull(obj)) return "";
        try {
            Gson gson = new Gson();
            return gson.toJson(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

测试：

    @Test
    void test3() {
        User user = new User();
        user.setId(1);
        user.setName("张三");
        user.setAge(18);
        Job job = new Job();
        job.setJobName("Java开发");
        job.setCompany("某知名大厂");
        user.setJob(job);
        List<String> list = Arrays.asList("张三", "法外狂徒", "传奇人物");
        user.setNickName(list);
        String json = GsonUtil.complexObjToJson(user);
        System.out.println(json);
    }

结果：

{
    "id":1,
    "name":"张三",
    "age":18,
    "job":{
        "jobName":"Java开发",
        "company":"某知名大厂"
    },
    "nickName":[
        "张三",
        "法外狂徒",
        "传奇人物"
    ]
}

反序列化：

    /**
     * 复杂Json转对象
     *
     * @param json
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> T complexJsonToObj(String json, Class<T> cls) {
        Gson gson = new Gson();
        if (Objects.isNull(json)) return null;
        T obj = gson.fromJson(json, cls);
        if (Objects.isNull(obj)) {
            return null;
        } else {
            return obj;
        }
    }

测试：

@Test
void test4() {
    String json = "{\"id\":1,\"name\":\"张三\",\"age\":18,\"job\":{\"jobName\":\"Java开发\",\"company\":\"某知名大厂\"},\"nickName\":[\"张三\",\"法外狂徒\",\"传奇人物\"]}";
    User user = GsonUtil.complexJsonToObj(json, User.class);
    System.out.println(user);
}

结果：

User(id=1, name=张三, age=18, job=Job(jobName=Java开发, company=某知名大厂), nickName=[张三, 法外狂徒, 传奇人物])

3. 数组 序列化/反序列化

这里数据序列化和上面一样，

反序列化又=有一点区别String[] nameArray = gson.fromJson(namesJson, String[].class);

工作中不常用，就不再详细介绍

4. Map和List 序列化反序列化

Map和List是工作中比较常用的，而且这两个操作比较相似：

  • List序列化和反序列化
    序列化：

        /**
     * list To Json
     *
     * @param list
     * @return
     */
    public static String listToJson(List list) {
        if (Objects.isNull(list)) return "";
        try {
            Gson gson = new Gson();
            return gson.toJson(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    测试：

        @Test
    void test6() {
        List<String> list = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        String json = GsonUtil.listToJson(list);
        System.out.println(json);
    }

    结果：

    ["zhangsan","lisi","wangwu"]

    反序列化：
    这里反序列化时需要提供Type，通过Gson提供的TypeToken<T>.getType()方法可以定义当前List的Type

        /**
     * json to list
     * 
     * @param json
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> T jsonToList(String json,Class<T> cls) {
        if (Objects.isNull(json)) return null;
        try {
            Gson gson = new Gson();
          	// 需要注意这里的type
            Type type = new TypeToken<ArrayList<T>>(){}.getType();
            return gson.fromJson(json, type);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    测试：

        @Test
    void test7() {
        String json = "[{\"id\":1,\"name\":\"zhangsan\",\"age\":18},{\"id\":2,\"name\":\"sili\",\"age\":28}]";
        System.out.println(GsonUtil.jsonToList(json, User.class));
    }

    结果：

    [{id=1.0, name=zhangsan, age=18.0}, {id=2.0, name=sili, age=28.0}]

  • Map 序列化和反序列化

    和List一样

Gson进阶用法

**1. 指定序列化和反序列化 字段名称 **

这个用法是常用的，尤其在解析第三方接口返回数据时，可以指定字段名称解析

实体类加@SerializedName注解

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    @SerializedName("login_name")
    private String name;
    private Integer age;
    private Job job;
    private List<String> nickName;

    public User(int id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
}

反序列化测试：

    @Test
    void test8() {
        String json = "{\"id\":1,\"login_name\":\"张三\",\"age\":18}";
        User user = GsonUtil.complexJsonToObj(json, User.class);
        System.out.println(user);
    }

结果：

User(id=1, name=张三, age=18, job=null, nickName=null)

Gson 解析时会将 login_name 解析出的数据封装到 name 属性中

序列化测试：

    @Test
    void test9() {
        User user = new User(1, "张三", 18);
        System.out.println(GsonUtil.complexObjToJson(user));
    }

结果：

{"id":1,"login_name":"张三","age":18}

实际工作中用到场景：

我们工作中经常会需要调用第三方提供的接口，第三方接口数据有些字段命名不符合我们习惯，不如字段用下滑线而我们习惯驼峰命名，这是便可以用@SerializedName注解，这个注解还有一个属性alternate，@SerializedName(value = "login_name", alternate = "name")，此时这个注解意思是如果Json中是login_name就用login_name的值，如果是name就用name值。

2. 忽略解析某个值

有两种方式可以在解析是忽略某个值

  • @Expose注解

    @Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    @Expose()
    private int id; // 参与序列化/反序列化
    @SerializedName("login_name")
    @Expose(serialize = false,deserialize = false)
    private String name; // 不参与序列化，也不参与反序列化
    @Expose(serialize = false, deserialize = true)
    private Integer age; // 只参与反序列化
    @Expose(serialize = true, deserialize = false)
    private Job job; // 只参与序列化
    
    private List<String> nickName;

    public User(int id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
}

    在使用这个注解时，就不能使用之前gson对象了，必须使用下面方式构建gson对象，该对象会排除没有注解的字段。

        public static String exposeObjToJson(Object obj) {
        if (Objects.isNull(obj)) return "";
        try {
            GsonBuilder gsonBuilder = new GsonBuilder();
            gsonBuilder.excludeFieldsWithoutExposeAnnotation();
            Gson gson = gsonBuilder.create();
            return gson.toJson(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }
    public static <T> T exposeJsonToObj(String json, Class<T> cls) {
        if (Objects.isNull(json)) return null;
        try {
            GsonBuilder gsonBuilder = new GsonBuilder();
            gsonBuilder.excludeFieldsWithoutExposeAnnotation();
            Gson gson = gsonBuilder.create();
            return gson.fromJson(json, cls);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

  • transient关键字

    使用这个关键字，可以直接让变量不参与序列化/反序列化

    @Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    @Expose()
    private int id; // 参与序列化/反序列化
    @SerializedName(value = "login_name",alternate = "name")
    @Expose(serialize = false,deserialize = false)
    private String name; // 不参与序列化，也不参与反序列化
    @Expose(serialize = false)
    private Integer age; // 只参与反序列化
    @Expose(deserialize = false)
    private Job job; // 只参与序列化

    private transient List<String> nickName; // transient 关键字

    public User(int id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
}

    使用该关键字时，直接用普通new的gson对象即可。
    ———————————————————————————————————————
    下面是完整的Gson工具类：

package com.zlp.demo.util;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;

import java.lang.reflect.Array;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class GsonUtil {

    /**
     * 简单对象转Json
     *
     * @param obj
     * @return
     */
    public static String simpleObjToJson(Object obj) {
        if (Objects.isNull(obj)) return "";
        try {
            Gson gson = new Gson();
            return gson.toJson(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 简单Json转对象
     *
     * @param json
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> T simpleJsonToObj(String json, Class<T> cls) {
        Gson gson = new Gson();
        if (Objects.isNull(json)) return null;
        T obj = gson.fromJson(json, cls);
        if (Objects.isNull(obj)) {
            return null;
        } else {
            return obj;
        }
    }

    /**
     * 复杂对象转Json
     *
     * @param obj
     * @return
     */
    public static String complexObjToJson(Object obj) {
        Gson gson = new Gson();
        if (Objects.isNull(obj)) return "";
        String json = gson.toJson(obj);
        if (Objects.isNull(json)) {
            return "";
        } else {
            return json;
        }
    }
    /**
     * 复杂Json转对象
     *
     * @param json
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> T complexJsonToObj(String json, Class<T> cls) {
        Gson gson = new Gson();
        if (Objects.isNull(json)) return null;
        T obj = gson.fromJson(json, cls);
        if (Objects.isNull(obj)) {
            return null;
        } else {
            return obj;
        }
    }

    /**
     * 数组转Json
     *
     * @param array
     * @return
     */
    public static String arrayToJson(Object array) {
        if (Objects.isNull(array)) return "";
        Gson gson = new Gson();
        String json = gson.toJson(array);
        if (Objects.isNull(json)) {
            return "";
        } else {
            return json;
        }
    }

    /**
     * list To Json
     *
     * @param list
     * @return
     */
    public static String listToJson(List list) {
        if (Objects.isNull(list)) return "";
        try {
            Gson gson = new Gson();
            return gson.toJson(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * json to list
     *
     * @param json
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> T jsonToList(String json,Class<T> cls) {
        if (Objects.isNull(json)) return null;
        try {
            Gson gson = new Gson();
            Type type = new TypeToken<ArrayList<T>>(){}.getType();
            return gson.fromJson(json, type);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
	
	 /**
     * 使用expose注解 obj to json
     *
     * @param obj
     * @return
     */
    public static String exposeObjToJson(Object obj) {
        if (Objects.isNull(obj)) return "";
        try {
            GsonBuilder gsonBuilder = new GsonBuilder();
            gsonBuilder.excludeFieldsWithoutExposeAnnotation();
            Gson gson = gsonBuilder.create();
            return gson.toJson(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }
    
    /**
     * 使用expose注解 json to obj
     * @param json
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> T exposeJsonToObj(String json, Class<T> cls) {
        if (Objects.isNull(json)) return null;
        try {
            GsonBuilder gsonBuilder = new GsonBuilder();
            gsonBuilder.excludeFieldsWithoutExposeAnnotation();
            Gson gson = gsonBuilder.create();
            return gson.fromJson(json, cls);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
1个凡夫俗子
关注
  • 7
    点赞
  • 踩
  • 69
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java 中 Gson的使用
hengdeveloper
12-07 1119
JSON 是一种文本形式的数据交换格式，它比XML更轻量、比二进制容易阅读和编写，调式也更加方便;解析和生成的方式很多，Java中最常用的类库有：JSON-Java、Gson、Jackson、FastJson等 一、Gson的基本用法 Gson提供了fromJson() 和toJson() 两个直接用于解析和生成的方法，前者实现反序列化，后者实现了序列化；同时每个方法都提供了重载方法 1）基本数据...
Gson的用法详解
m0_64148419的博客
11-28 4555
关于gson的一些使用详解
在Android Studio中添加Gson库的依赖项非常简单，你可以按照以下步骤进行操作
最新发布
BLOG域名:programb.blog.csdn.net
04-23 460
这是一个简单的Android Studio中使用Gson库进行JSON解析的示例。你可以根据你的实际需求进行相应的修改和扩展。这样就成功添加了Gson库的依赖项。你可以在你的项目中使用Gson库来进行JSON数据的解析和序列化操作。这样，你就成功添加了第三方库的依赖项。Android Studio会自动下载并导入所需的库文件。
Gson详解(一）
lw的博客
11-26 2750
Gson（又称Google Gson）是Google公司发布的一个开放源代码的Java库，主要用途为序列化Java对象为JSON字符串，或反序列化JSON字符串成Java对象。而JSON(JavaScriptObject Notation) 是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成，广泛应用于各种数据的交互中，尤其是服务器与客户端的交互。引入依赖：</</</</二.Gson使用2.1Gson的创建Gson的创建方式一：直接new Gson对象。
Google Gson用法详解
Goals1989的博客
07-25 1415
Gson（又称GoogleGson）是Google公司发布的一个开放源代码的Java库，主要用途为序列化Java对象为JSON字符串，或反序列化JSON字符串成Java对象。gsonGson在默认序列化和反序列化方面提供了非常出色的功能。不过，我们可能会遇到默认和内置自定义选项无法解决我们问题的情况。在这种情况下，我们可以通过两个接口JsonSerializer和JsonDeserializer使用自定义序列化和反序列化。{}}{}}}{{{"id"{...
Json解析框架 Gson
Lbsssss的博客
10-31 469
1.Java Object 序列化/反序列化 1.1GSON简介 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。 Gson 是 Google 提供的用来在 Java 对象和 JSON 数据之间进行映射的 Java 类库。可以将一个 JSON 字符串转成一个 Java 对象（反序列化），或者反过来（序列化）。 GSON github地址：https://github.com/google/gson 依赖： Gradle
Java中Gson的使用详解
08-25
下面将对Gson的基本用法和属性重命名进行详细介绍。 一、Gson的基本用法 Gson提供了fromJson()和toJson()两个方法，用于实现反序列化和序列化。fromJson()方法用于将JSON字符串反序列化为Java对象，而toJson()方法...
Gson基本使用，数据容错处理
04-27
Gson基本使用，数据容错处理 适配boolean、Boolean、int、Integer、float、Float、double、Double、long、Long、String类型。 还包括服务器返回的restful规范数据。
FastJson 和 Gson的使用简单方便
08-25
Java处理JSON数据有三个比较流行的类库FastJSON、Gson和Jackson。本文将测试这三个类库在JSON序列化和反序列化的方面表现，主要测试JSON序列化和反序列化的速度。为了防止由于内存导致测试结果出现偏差，测试中对JVM...
maven项目中gson使用方法.pdf
10-25
本篇将详细介绍在Maven项目中如何使用Gson库。 首先，要在Maven项目中引入Gson库，我们需要在项目的`pom.xml`文件中添加对应的依赖。打开`pom.xml`，在`<dependencies>`标签内加入以下代码： ```xml <groupId>...
JAVA使用Gson解析json数据实例解析
10-22
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于阅读和编写，同时也易于机器解析和生成。接下来通过本文给大家介绍JAVA使用Gson解析json数据实例解析，需要的朋友参考下吧
Gson基本使用
D_XQY_的博客
07-09 729
Gson使用
Gson使用转
dmz1989的博客
04-24 487
基本概念 Serialization:序列化，使Java对象到Json字符串的过程。Deserialization：反序列化，字符串转换成Java对象。JSON数据中的JsonElement有下面这四种类型： JsonPrimitive —— 例如一个字符串或整型 JsonObject—— 一个以 JsonElement 名字（类型为 String）作为索引的集合。也就是说可以把 Jso
Android JSON：Gson,FastJson解析库的使用和对比分析(1)，金三银四Android高级工程师面试题整理
2401_84149213的博客
04-06 438
分享一份工作1到5年以上的Android程序员架构进阶学习路线体系，希望能对那些还在从事Android开发却还不知道如何去提升自己的，还处于迷茫的朋友！阿里P7级Android架构师技术脑图；查漏补缺，体系化深入学习提升**全套体系化高级架构视频；**七大主流技术模块，视频+源码+笔记有任何问题，欢迎广大网友一起来交流《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
java使用Gson教程
小张的博客
11-01 1326
Gson是一个功能强大、易于使用的库，能够大大简化Java和JSON之间的转换工作
Gson使用方法
Handsome_BoyIT的博客
07-09 2266
一、概述 Gson是google提供的用来操作json数据的一个非常好用的类库。其使用范围非常的广泛，所以非常有必要对其进行系统的学习。 json是一种数据格式，确切的说是一种文本数据格式。其在网络通讯过程中的作用非常的明显。 目前大多数的网络通讯格式已经从xml替换为json格式。 其提供了序列化和反序列化的功能。在我们进行网络开发的过程中通常会把参数封装成json格式传给后台，后台解析后的返回结果也会封装成json格式返回给调用者。 1.如何创建一个Gson对象 /** * 创建Gson对象的
Gson的使用
zj 的笔记本
09-20 207
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
Google Gson用法详解，手把手教你写
2401_84264096的博客
04-17 802
如果我们使用 new Gson() 创建Gson并执行toJson() 和 fromJson() 方法，则@Expose将不会对序列化和反序列化产生任何影响。为了进行反序列化，我们需要使用Gson对象调用fromJson()函数，并在解析完成后传递两个参数，即JSON字符串和所需的Java类型。但是，如果打算自定义Gson的行为，则可以使用GsonBuilder自定义的配置来创建新的Gson实例。如果我们将lenient设置为true，则它将忽视某些违规行为，并尝试读取格式不正确的JSON。
GSON使用
06-01
GSON是一个Java库，用于将Java对象序列化为JSON格式，或将JSON格式反序列化为Java对象。以下是使用GSON的步骤： 1. 导入GSON库：可以从GSON的官方网站下载GSON库，也可以使用Maven或Gradle等构建工具导入。 2. 创建Java对象：创建一个Java对象，该对象将被序列化为JSON格式或从JSON格式反序列化。 3. 序列化Java对象：使用GSON的toJson()方法将Java对象序列化为JSON格式的字符串。 4. 反序列化JSON字符串：使用GSON的fromJson()方法将JSON格式的字符串反序列化为Java对象。 以下是一个使用GSON的示例代码： ```java import com.google.gson.Gson; class Person { private String name; private int age; // getters and setters public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } public class GsonExample { public static void main(String[] args) { Gson gson = new Gson(); // serialize Java object to JSON Person person = new Person(); person.setName("John"); person.setAge(30); String json = gson.toJson(person); System.out.println(json); // output: {"name":"John","age":30} // deserialize JSON to Java object Person deserializedPerson = gson.fromJson(json, Person.class); System.out.println(deserializedPerson.getName()); // output: John System.out.println(deserializedPerson.getAge()); // output: 30 } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

1个凡夫俗子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值