Gson基本使用

已于 2022-07-09 12:48:45 修改
阅读量750 收藏 1
点赞数
分类专栏： 后端 文章标签： java json 开发语言
于 2022-07-09 12:39:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jirong5206/article/details/125690151
版权

gson创建规则以及相关对象的序列化反序列化使用方法。

主要介绍了 gson创建规则。
以及各种类型的序列化及反序列化的规则及用法，包括数组，列表，复合类等。
当json中的属性与类字段名不一样时候 @SerializedName() 注解

@SerializedName("money")
private String salary;

@SerializedName({"money", "salary"})  // 可以有多个备选值
private String salary;

@Expose()注解 如果想要让java类的某些字段不参加序列化或反序列化，可以显示来设置。如：

@Expose(serialize=false,deserialize=false)
private String name;


package jsontest;

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

import java.util.*;

public class GsonTest {
/**  查阅
 Gson gson = new GsonBuilder().setLenient() // json宽松
          .enableComplexMapKeySerialization() //支持Map的key为复杂对象的形式
          .serializeNulls() //智能null,支持输出值为null的属性
          .setPrettyPrinting()//格式化输出（序列化）
          .setDateFormat("yyyy-MM-dd HH:mm:ss") //序列化日期格式化输出
          .excludeFieldsWithoutExposeAnnotation() //不序列化与反序列化没有@Expose标注的字段
          .disableHtmlEscaping() //默认是Gson把HTML转义的
          .create();
*/


    public static void main(String[] args) {
        // Gson gson = new GsonBuilder().create();
        Gson gson = new GsonBuilder()
                //格式化输出（序列化）enableComplexMapKeySerialization() 支持Map的key为复杂对象的形式
                .setPrettyPrinting()
                //序列化日期格式化输出
                .setDateFormat("yyyy-MM-dd HH:mm:ss")
                .create();

        /**
         * 序列化
         */
        String jsonNumber = gson.toJson(100);
        String jsonBoolean = gson.toJson(false);
        String jsonString = gson.toJson("String");

        /**
         * 反序列化
         */
        int i = gson.fromJson("100", int.class);
        double d = gson.fromJson("99.99", double.class);
        double d1 = gson.fromJson("\"99.99\"", double.class);
        boolean b = gson.fromJson("true", boolean.class);
        String str = gson.fromJson("String", String.class);

        System.out.println(d1);
        System.out.println(d);

        User user = new User("1","wang",new Date());
        String jsonStr = gson.toJson(user);
        System.out.println(jsonStr);
        User userk = gson.fromJson(jsonStr, User.class);
        System.out.println(userk);

        //包含其他对象的序列化
        User user1 = new User("1", "王重阳", new Date());
        User user2 = new User("2", "郭靖", new Date());
        User user3 = new User("3", "黄蓉", new Date());
        List<User> userList = new ArrayList<User>();
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);

        Dept dept = new Dept();
        dept.setId("A001");
        dept.setDeptName("研发部");
        dept.setUsers(userList);


        System.out.println("类内有list 序列化");
        String deptstr = gson.toJson(dept);
        System.out.println("类内有list<> 序列化" + deptstr);
        Dept dept1 = gson.fromJson(deptstr, Dept.class);


        Dept2 dept2 = new Dept2();
        User[] usersArray = { user1, user2, user3 };
        dept2.setId("A001");
        dept2.setDeptName("研发部");
        dept2.setUsers(usersArray);

        //
        String deptstr2 = gson.toJson(dept2);
        System.out.println("类内有Array 序列化");
        System.out.println("类内有Array 序列化"+deptstr2);
        Dept2 dept3 = gson.fromJson(deptstr2, Dept2.class);

        //
        System.out.println("Array 序列化");
        String ArrayUser = gson.toJson(usersArray);
        System.out.println("Array 序列化"+ArrayUser);
        gson.fromJson(ArrayUser,User[].class);


        System.out.println("List 序列化");
        String ArrayList = gson.toJson(userList);
        System.out.println("List 序列化"+ArrayList);
        //有问题
        gson.fromJson(ArrayList,new TypeToken<List<User>>(){}.getType());

        System.out.println("结束");





    }
}

结果

99.99
99.99
{
  "id": "1",
  "name": "wang",
  "birthday": "2022-07-09 12:10:08"
}
User{id='1', name='wang', birthday=Sat Jul 09 12:10:08 CST 2022}
类内有list 序列化
类内有list<> 序列化{
  "id": "A001",
  "deptName": "研发部",
  "users": [
    {
      "id": "1",
      "name": "王重阳",
      "birthday": "2022-07-09 12:10:08"
    },
    {
      "id": "2",
      "name": "郭靖",
      "birthday": "2022-07-09 12:10:08"
    },
    {
      "id": "3",
      "name": "黄蓉",
      "birthday": "2022-07-09 12:10:08"
    }
  ]
}
类内有Array 序列化
类内有Array 序列化{
  "id": "A001",
  "deptName": "研发部",
  "users": [
    {
      "id": "1",
      "name": "王重阳",
      "birthday": "2022-07-09 12:10:08"
    },
    {
      "id": "2",
      "name": "郭靖",
      "birthday": "2022-07-09 12:10:08"
    },
    {
      "id": "3",
      "name": "黄蓉",
      "birthday": "2022-07-09 12:10:08"
    }
  ]
}
Array 序列化
Array 序列化[
  {
    "id": "1",
    "name": "王重阳",
    "birthday": "2022-07-09 12:10:08"
  },
  {
    "id": "2",
    "name": "郭靖",
    "birthday": "2022-07-09 12:10:08"
  },
  {
    "id": "3",
    "name": "黄蓉",
    "birthday": "2022-07-09 12:10:08"
  }
]
List 序列化
List 序列化[
  {
    "id": "1",
    "name": "王重阳",
    "birthday": "2022-07-09 12:10:08"
  },
  {
    "id": "2",
    "name": "郭靖",
    "birthday": "2022-07-09 12:10:08"
  },
  {
    "id": "3",
    "name": "黄蓉",
    "birthday": "2022-07-09 12:10:08"
  }
]
结束

复合对象

{
  "name": "tom",
  "age": 0,
  "money": 2999,
  "hobbies": [
    "basket",
    "tennis"
  ],
  "collections": {
    "2": "paint",
    "3": "mouse"
  }
}

举一反三，value 是数组时（hobbies），对应在java类中也是数组；value 是对象时，对应在java类中就是map（k-v对）了。

因此，我们可以很容易得到对应的java类：

private List<String> hobbies;
private Map<Integer, String> collections;

泛型

有的时候，传过来的json数据在格式上是很相近的，只不过某个字段的value不固定，如果为此生成多个相似的java类就十分多余了。

如：前端传过来的json数据主要是2类：

{"code":"0","message":"success","data":{}}
{"code":"0","message":"success","data":[]}

对于字段data ，有时候是对象，有时候是数组。

这里，我们将使用Result 来映射json数据，使用MyEntry 类来映射json 数据的data 部分。这意味着，对于不同的json数据，我们将不再生成多个java类，而是动态生成所需的java对象。

result对象

public class Result<T>{
    public int code;
    public String message;
    public T data;
    // getter、setter
}

data为对象的json1：

{
  "code": 0,
  "message": "success",
  "data": 
    {
      "name": "tom",
      "age": 32,
      "address": "street one",
      "salary": 4999
    }
}


String typeJson1 = "{\n" +
                        "  \"code\":0,\n" +
                        "  \"message\":\"success\",\n" +
                        "  \"data\":{\n" +
                        "    \"name\":\"tom\",\n" +
                        "    \"age\":32,\n" +
                        "    \"address\":\"street one\",\n" +
                        "    \"salary\":4999\n" +
                        "  }\n" +
                        "}";
Gson typeGson1 = new Gson();
// 动态生成所需的java类的类型
Type type1 = new TypeToken<Result<MyEntry>>(){}.getType();
// 动态生成java对象
Result<MyEntry> result1 = typeGson1.fromJson(typeJson1, type1);
System.out.println(result1);

data为数组的json2：

{
  "code": 0,
  "message": "success",
  "data": [
    {
      "name": "tom",
      "age": 32,
      "address": "street one",
      "salary": 4999
    },
    {
      "name": "lucy",
      "age": 24,
      "address": "street three",
      "salary": 2333
    }
  ]
}


String typeJson2 = "{\n" +
                        "  \"code\": 0,\n" +
                        "  \"message\": \"success\",\n" +
                        "  \"data\": [\n" +
                        "    {\n" +
                        "      \"name\": \"tom\",\n" +
                        "      \"age\": 32,\n" +
                        "      \"address\": \"street one\",\n" +
                        "      \"salary\": 4999\n" +
                        "    },\n" +
                        "    {\n" +
                        "      \"name\": \"lucy\",\n" +
                        "      \"age\": 24,\n" +
                        "      \"address\": \"street three\",\n" +
                        "      \"salary\": 2333\n" +
                        "    }\n" +
                        "  ]\n" +
                        "}";
Gson typeGson2 = new Gson();
// 再次动态生成java类型
Type type2 = new TypeToken<Result<List<MyEntry>>>(){}.getType();
// 再次动态生成java对象
Result<List<MyEntry>> result2 = typeGson2.fromJson(typeJson2, type2);
System.out.println(result2);

直接解析json

json 是对象类型

当ajax传过来的json数据属于对象时，不论这个对象简单还是复杂，都可以轻松地把它们给解析出来。

ajax传过来的json数据（是对象形式）：

var data_json =  {
        "sex": '男',
        "hobby":["baskte","tennis"],
        "introduce": {
            "name":"tom",
            "age":23
        }
    };

data: JSON.stringify(data_json),

GSON解析：

BufferedReader reader = request.getReader();
    // 读取json数据
    StringBuffer buffer = new StringBuffer();
    String s;
    while ((s = reader.readLine()) != null) {
        buffer.append(s);
    }
    String json = buffer.toString();
    System.out.println("json:" + json);  

    // json解析器，解析json数据
    JsonParser parser = new JsonParser();
    JsonElement element = parser.parse(json);
    // json属于对象类型时
    if (element.isJsonObject()) {  
        JsonObject object = element.getAsJsonObject();  // 转化为对象

        // 1. value为string时，取出string
        String sex = object.get("sex").getAsString();                         System.out.println("sex:" + sex);

        // 2. value为array时，取出array
        JsonArray hobbies = object.getAsJsonArray("hobby");  // 
        for (int i = 0; i < hobbies.size(); i++) {
            String hobby = hobbies.get(i).getAsString();
            System.out.println("hobby:" + hobby);
        }

        // 3. value为object时，取出object
        JsonObject introduce = object.getAsJsonObject("introduce");
        String name = introduce.get("name").getAsString();
        int age = introduce.get("age").getAsInt();
        System.out.println("name:" + name+";age:" + age);
    }

解读：

很明显，对于传过来的对象类型的json数据，使用GSON是很方便进行解析的，在得到了json数据对应的JsonObject 对象之后，我们就可以很简单地进行操作了。这种方法是直接获取json中的值，而没有进行java对象的还原（简单情况下，没有必要生成相应的javabean）。

json 是数组类型

ajax传过来的json数据（是数组形式）：

var data_json =  [
    "cake",
    2,
    {"brother":"tom","sister":"lucy"},
    ["red","orange"]
];

data: JSON.stringify(data_json),

GSON解析：

BufferedReader reader = request.getReader();
    StringBuffer buffer = new StringBuffer();
    String s;
    while ((s = reader.readLine()) != null) {
        buffer.append(s);
    }
    String json = buffer.toString();
    System.out.println("json:"+json);

    // json解析器，解析json数据
    JsonParser parser = new JsonParser();
    JsonElement element = parser.parse(json);
    // json属于数组类型
    if (element.isJsonArray()) {  
        JsonArray array = element.getAsJsonArray();

        // 1. value为string时，取出string
        String array_1 = array.get(0).getAsString();
        System.out.println("array_1:"+array_1);

        // 2. value为int时，取出int
        int array_2 = array.get(1).getAsInt();
        System.out.println("array_2:"+array_2);

        // 3. value为object时，取出object
        JsonObject array_3 = array.get(2).getAsJsonObject();
        String brother = array_3.get("brother").getAsString();
        String sister = array_3.get("sister").getAsString();
        System.out.println("brother:"+brother+";sister:"+sister);

        // 4. value为array时，取出array
        JsonArray array_4 = array.get(3).getAsJsonArray();
        for (int i = 0; i < array_4.size(); i++) {
        System.out.println(array_4.get(i).getAsString());
        }

    }

解读：

当json是数组类型的时候，使用GSON操作和上一小节几乎差不多，只不过是第一步生成的json对象是数组而已。上面2种方式解析json十分简单，在日常使用中足够了。

但是对于有规律的json数据，比如往往是可以映射成一个javabean对象，那么我们就没有必要一个个手工取值了，我们可以借助javabean配合GSON来更加快速地解析json数据。

D___
关注
专栏目录
Gson之基本用法
行云间
04-20 5036
项目中，解析json数据时，一直使用Gson解析。对于Gson的基本使用没有什么问题，但并没有Gson更深入的认识。json作为主流的数据传递方式，深入理解Gson的用法还是很有必要的，那么系统的了解下Gson到底可以做什么。 1.Gson的对象         Gson是google推出的的一个开源库，可以用来将Java对象转换为Json对象，当然，也可以用来将json对象转换为Java
Gson基本使用，数据容错处理
04-27
Gson基本使用，数据容错处理 适配boolean、Boolean、int、Integer、float、Float、double、Double、long、Long、String类型。 还包括服务器返回的restful规范数据。
Gson简要使用笔记
weixin_30920853的博客
05-01 296
哇，原来我已经潜水2年多了，还是需要养成习惯写写东西啊。 最近在做一个java web service项目，需要用到jason，本人对java不是特别精通，于是开始搜索一些java平台的json类库。 发现了google的gson，因为之前对于protocolbuf有一些了解，带着一些好奇心，我开始使用了gson。 经过比较，gson和其他现有java json类库最大的不同时gson需要序...
Gson快速上手（这一篇就够了！！）
最新发布
2303_77986104的博客
07-10 775
Gson是目前功能最强的JSON解析器之一，并且不需要依赖额外的Jar包，能够直接运行在JAVA平台。相对于FastJson，更能准确的转换复杂的Bean。
gson
weixin_34209851的博客
07-26 157
gson和其他现有java json类库最大的不同时gson需要序列化得实体类不需要使用annotation来标识需要序列化得字段，同时gson又可以通过使用annotation来灵活配置需要序列化的字段。 public class Person { private String name; private int age; /** * @return the name *...
Google Gson 使用简介
weixin_34362991的博客
05-20 165
如何将数组转化为 json 串？ 下面的例子中我们示例如何将一个数据转换成 json 串，并使用 Gson.toJson() 方法将数组序列化为 JSON，以及Gson.fromJson() 方法将 JSON 串反序列化为 java 数组。 import com.google.gson.Gson; public class ArrayToJson { publi...
Gson的使用
weixin_52120555的博客
10-13 736
1.Gson对象的创建 Gson gson = new GsonBuilder() .setDateFormat("yyyy-MM-dd HH:mm:ss") .setLenient()// json宽松 .enableComplexMapKeySerialization()//支持Map的key为复杂对象的形式 .serializeNulls() //智能null .setPrettyPrinting()// 调教格式 .disableHtmlEscaping() //默认是G
Gson基本使用方法
01-15
### Gson的基本使用方法 1. **添加依赖** 在项目中使用Gson，首先需要将其依赖引入到项目中。如果你使用的是Maven项目，可以在pom.xml文件中添加以下依赖： ```xml <groupId>com.google.code.gson</groupId> ...
Java中Gson的使用详解
08-25
"Java中Gson的使用详解" Gson是Google提供的一个用于将Java对象序列化和反序列化为JSON的库。它提供了fromJson()和toJson()两个方法，用于实现反序列化和序列化。下面将对Gson的基本用法和属性重命名进行详细介绍。...
Gson的基本使用
01-15
### Gson的基本使用 #### 序列化（对象转JSON） ```java import com.google.gson.Gson; public class User { private String name; private int age; // getters and setters... public static void main...
Java的JSON转换库GSON的基本使用方法示例
10-22
GSON的基本使用方法示例包括以下几个部分： 1. 创建一个实体类Person，其中包含name和age两个私有属性。这个实体类需要有一个默认的构造函数，且name和age的getter和setter方法。 ```java public class Person { ...
gson 的使用
11-14
gson 的常用语法使用， 包括： 1. 将ArrayList字符串转换为 JSON 2. 将JSON字符串转换为 ArrayList 3. 将HashMap字符串转换为 JSON 4. 将JSON字符串转换为 HashMap 5. 反序列化方法
gson的使用
maozhuxigood
06-08 89
一、导入gson.jar 二、Student.javapublic class Student { private String no; private String name; public String getNo() { return no; } public void setNo(String no) { this.no = no; } public String getName()...
Gson的用法详解
m0_64148419的博客
11-28 7495
关于gson的一些使用详解
gson工具类
weixin_33688840的博客
09-27 210
2019独角兽企业重金招聘Python工程师标准>>> ...
Gson基本用法
热门推荐
chenrenxiang的专栏
05-12 12万+
Gson是谷歌官方推出的支持 JSON -- Java Object 相互转换的 Java序列化/反序列化 库，之前由于没有用过，所以学习一下。 1. 导入Android Studio工程 dependencies { implementation 'com.google.code.gson:gson:2.8.4' } 2.简单的 Java Object 序列化/反序列化 ...
Gson简单使用
棍哥的博客
01-25 238
Gson是谷歌官方推出的支持 JSON -- Java Object 相互转换的 Java序列化/反序列化 库 本菜鸟用的是Android Studio 一：添加到项目中 app下build.gradle dependencies { implementation 'com.google.code.gson:gson:2.8.4' } 二：简单的序列化（***转为json数据）/...
谷歌Gson库在Java中的使用详解
"gson使用.doc" Gson是一个由Google开发的Java库，专门用于处理JSON数据的序列化和反序列化。它允许开发者轻松地将Java对象转换为JSON字符串，反之亦然。Gson库的强大之处在于其灵活性和深度解析能力，能够处理复杂...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值