登录
当前位置： 首页 > 工具软件 > Gson > 使用案例 >

Google Gson

阴迪
2023-12-01

JackSon简单用法        FastJson简单用法

一、Gson介绍

1、什么是Gson

    Gson 是 Google 开发的Java API，是一个简单基于Java的开源库，可以相互转换Java对象和Json字符串

2、Gson的特点

  • 易使用            ：Gson API提供了一个高级外观来简化常用的用例
  • 无须创建映射 ：Gson API为大部分要序列化的对象提供了默认映射
  • 性能优            ：Gson速度较快，内存占用量低。
  • 无依赖性        ：Gson不需要JDK以外的其他库

二、Maven 依赖

<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.8.6</version>
</dependency>

三、Gson 创建 

1、new 对象

// 使用new方法
Gson gson = new Gson();

2、 使用GsonBuilder

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

   声明对象的时候可以加规则管控

Gson gson = new GsonBuilder()
         .excludeFieldsWithoutExposeAnnotation() 	//序列化时排除没有@Expose注解的字段
         .enableComplexMapKeySerialization() 		//当Map的key为复杂对象时,需要开启该方法
         .serializeNulls() 							//字段值为空或null时，仍然进行转换
         .setDateFormat("yyyy-MM-dd HH:mm:ss:SSS") 	//时间转化为Pattern的特定格式
         .setPrettyPrinting() 						//对JSON美化
         .disableHtmlEscaping() 					//防止特殊字符出现乱码
         .create();

四、序列化和反序列化

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import lombok.Data;
import org.junit.Test;
import java.util.*;
public class GsonTest {
    //测试的实体类
    @Data
    public class TestEntity {
        private String name;
        private int age;
        private String sex;
        private Date birthday;
        private String email;
        private String address;
        public TestEntity() {}
        public TestEntity(String name, int age, String sex, Date birthday, String email, String address) {
            this.name = name;
            this.age = age;
            this.sex = sex;
            this.birthday = birthday;
            this.email = email;
            this.address = address;
        }
    }
    @Test
    public void gsonTset()  {
        //声明Gson对象
        Gson gson = new Gson();
        //声明Java对象，用于序列化
        TestEntity entity  = new TestEntity("盛夏 ",23,"未知",new Date(),"sx @xx.com",null);
        TestEntity entity1 = new TestEntity("盛夏1",23,"未知",new Date(),"sx1@xx.com",null);
        TestEntity entity2 = new TestEntity("盛夏2",23,"未知",new Date(),"sx2@xx.com",null);
        //序列化方法 toJson || 反序列化方法 fromJson


        /*-------序列化 对象 转化为 Json 字符串  -------*/
        String objectToJson = gson.toJson(entity);
        System.out.println(objectToJson);
        //{"name":"盛夏","age":23,"sex":"未知","birthday":"Apr 26, 2022 11:20:09 AM","email":"sx@xx.com"}
        /*-------反序列化 Json 转化为 Java 对象  -------*/
        TestEntity jsonToObject = gson.fromJson(objectToJson, TestEntity.class);
        System.out.println(jsonToObject);
        //GsonTest.TestEntity(name=盛夏 , age=23, sex=未知, birthday=Tue Apr 26 11:34:06 CST 2022, email=sx @xx.com, address=null)


        /*-------序列化 Map 转化为 Json 字符串  -------*/
        Map map = new HashMap();
        map.put("entity1",entity1);
        map.put("entity2",entity2);
        String mapToJson = gson.toJson(map);
        System.out.println(mapToJson);
        //{"entity1":{"name":"盛夏1","age":23,"sex":"未知","birthday":"Apr 26, 2022 11:28:49 AM","email":"sx1@xx.com"},
        // "entity2":{"name":"盛夏2","age":23,"sex":"未知","birthday":"Apr 26, 2022 11:28:49 AM","email":"sx2@xx.com"}}
        /*-------反序列化 Json 转化为 Map 集合  -------*/
        Map jsonToMap = gson.fromJson(mapToJson, new TypeToken<Map<String, TestEntity>>() {}.getType());
        System.out.println(jsonToMap);
        //{entity1=GsonTest.TestEntity(name=盛夏1, age=23, sex=未知, birthday=Tue Apr 26 11:38:38 CST 2022, email=sx1@xx.com, address=null),
        // entity2=GsonTest.TestEntity(name=盛夏2, age=23, sex=未知, birthday=Tue Apr 26 11:38:38 CST 2022, email=sx2@xx.com, address=null)}


        /*-------序列化 List 转化为 Json 字符串  -------*/
        List list = new ArrayList();
        list.add(entity1);
        list.add(entity2);
        String listToJson = gson.toJson(list);
        System.out.println(listToJson);
        //[{"name":"盛夏1","age":23,"sex":"未知","birthday":"Apr 26, 2022 11:31:37 AM","email":"sx1@xx.com"},
        // {"name":"盛夏2","age":23,"sex":"未知","birthday":"Apr 26, 2022 11:31:37 AM","email":"sx2@xx.com"}]
        /*-------反序列化 Json 转化为 List 集合  -------*/
        List jsonToList = gson.fromJson(listToJson, new TypeToken<List<TestEntity>>() {}.getType());
        System.out.println(jsonToList);
        // [GsonTest.TestEntity(name=盛夏1, age=23, sex=未知, birthday=Tue Apr 26 11:41:01 CST 2022, email=sx1@xx.com, address=null),
        //  GsonTest.TestEntity(name=盛夏2, age=23, sex=未知, birthday=Tue Apr 26 11:41:01 CST 2022, email=sx2@xx.com, address=null)]
    }
}

五、常用注解

1、@SerializedName注解 用于序列化和反序列化 字段取别名

import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
import com.google.gson.reflect.TypeToken;
import lombok.Data;
import org.junit.Test;
import java.util.*;
public class GsonTest {
    //测试的实体类
    @Data
    public class TestEntity {
        /*---注解SerializedName使用---*/
        // value = "userName" 给实体类字段取别名 ； name --> userName
        // alternate = {"alterName","uName"} 可用于反序列化,{"alterName","uName"}都可给name赋值
        @SerializedName(value = "userName",alternate = {"alterName","uName"})
        private String name;
        private int age;
        private String sex;
        private Date birthday;
        private String email;
        private String address;
        public TestEntity() {}
        public TestEntity(String name, int age, String sex, Date birthday, String email, String address) {
            this.name = name;
            this.age = age;
            this.sex = sex;
            this.birthday = birthday;
            this.email = email;
            this.address = address;
        }
    }
    @Test
    public void gsonTset()  {
        //声明Gson对象
        Gson gson = new Gson();
        //声明Java对象，用于序列化
        TestEntity entity  = new TestEntity("盛夏 ",23,"未知",new Date(),"sx @xx.com",null);
        
        // name 序列化为 userName
        String toJson = gson.toJson(entity);
        System.out.println(toJson);
        //{"userName":"盛夏 ","age":23,"sex":"未知","birthday":"Apr 27, 2022 5:15:57 PM","email":"sx @xx.com"}

        // 用 name 反序列化来给 name 赋值 ；会出现赋值不上
        String nameJsonToObject = "{\"name\":\"盛夏 \",\"age\":23,\"sex\":\"未知\",\"birthday\":\"Apr 27, 2022 5:15:57 PM\",\"email\":\"sx @xx.com\"}";
        TestEntity entity1 = gson.fromJson(nameJsonToObject, TestEntity.class);
        System.out.println(entity1);
        //GsonTest.TestEntity(name=null, age=23, sex=未知, birthday=Wed Apr 27 17:15:57 CST 2022, email=sx @xx.com, address=null)

        // 用 alterName 反序列化来给 name 赋值 ，可赋值成功
        String alterNameJsonToObject = "{\"alterName\":\"盛夏 \",\"age\":23,\"sex\":\"未知\",\"birthday\":\"Apr 27, 2022 5:15:57 PM\",\"email\":\"sx @xx.com\"}";
        TestEntity entity2 = gson.fromJson(alterNameJsonToObject, TestEntity.class);
        System.out.println(entity2);
        //GsonTest.TestEntity(name=盛夏 , age=23, sex=未知, birthday=Wed Apr 27 17:15:57 CST 2022, email=sx @xx.com, address=null)

        // 用 uName 反序列化来给 name 赋值 ，可赋值成功
        String uNameJsonToObject = "{\"uName\":\"盛夏 \",\"age\":23,\"sex\":\"未知\",\"birthday\":\"Apr 27, 2022 5:15:57 PM\",\"email\":\"sx @xx.com\"}";
        TestEntity entity3 = gson.fromJson(uNameJsonToObject, TestEntity.class);
        System.out.println(entity3);
        //GsonTest.TestEntity(name=盛夏 , age=23, sex=未知, birthday=Wed Apr 27 17:15:57 CST 2022, email=sx @xx.com, address=null)


        // 用 userName 反序列化来给 name 赋值 ，可赋值成功
        String newJsonToObject = toJson ;
        TestEntity entity4 = gson.fromJson(newJsonToObject, TestEntity.class);
        System.out.println(entity4);
        //GsonTest.TestEntity(name=盛夏 , age=23, sex=未知, birthday=Wed Apr 27 17:20:11 CST 2022, email=sx @xx.com, address=null)
    }

}

2、@Expose注解 是否序列化和反序列化【注意Gson声明和不加注解情况】

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;
import com.google.gson.reflect.TypeToken;
import lombok.Data;
import org.apache.poi.ss.formula.functions.T;
import org.junit.Test;
import java.util.*;
public class GsonTest {
    //测试的实体类
    @Data
    public class TestEntity {
        /*---Expose ---*/
        // @Expose(serialize=true) : 序列化的时候是否 序列化该字段 【true：序列化 ；false：不序列化】
        // @Expose(deserialize=true) : 反序列化的时候是否 反序列化该字段 【true：反序列化 ；false：不反序列化】
        @Expose(serialize = true)
        private String name;
        @Expose(deserialize = true)
        private int age;
        @Expose(serialize = false)
        private String sex;
        @Expose(deserialize = false)
        private Date birthday;
        
        private String email;      
        private String address;
        public TestEntity() {}
        public TestEntity(String name, int age, String sex, Date birthday, String email, String address) {
            this.name = name;
            this.age = age;
            this.sex = sex;
            this.birthday = birthday;
            this.email = email;
            this.address = address;
        }
    }
    @Test
    public void gsonTset()  {
        //声明Gson对象
        Gson gson = new Gson();

        //声明Gson对象
        // 不加 @Expose 注解 等于 @Expose(serialize = false , deserialize = false)
        Gson buildGson  = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();

        //声明Java对象，用于序列化
        TestEntity entity  = new TestEntity("盛夏 ",23,"未知",new Date(),"sx @xx.com",null);

        // 用 gson 序列化 会毫无反映
        String objectToJson = gson.toJson(entity);
        System.out.println(objectToJson);
        // {"name":"盛夏 ","age":23,"sex":"未知","birthday":"Apr 27, 2022 5:42:21 PM","email":"sx @xx.com"}

        // 用 buildGson 序列化
        String objectToBuildJson = buildGson.toJson(entity);
        // name 字段会被序列化 ；sex 字段不会被序列化
        System.out.println(objectToBuildJson);
        //{"name":"盛夏 ","age":23,"birthday":"Apr 27, 2022 5:47:20 PM"}

        // 用 buildGson 反序列化
        TestEntity buildEntity = buildGson.fromJson(objectToBuildJson, TestEntity.class);
        // age字段 会被反序列化 ； birthday字段 不会被序列化
        System.out.println(buildEntity);
        //GsonTest.TestEntity(name=盛夏 , age=23, sex=null, birthday=null, email=null, address=null)
    }
}

3、@Since(double v) 与 @Until(double v) 注解 【版本控制】

不怎么用

4、@JsonAdapter 注解 【一般用于时间转换】

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.TypeAdapter;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.JsonAdapter;
import com.google.gson.annotations.SerializedName;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import com.nisco.common.core.util.DateUtil;
import lombok.Data;
import lombok.SneakyThrows;
import org.apache.poi.ss.formula.functions.T;
import org.junit.Test;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
public class GsonTest {
    //测试的实体类
    @Data
    public class TestEntity {

        private String name;
        private int age;
        private String sex;
        // 这注解不咋会用 参数是个类 这个类要继承TypeAdapter，重写read和write方法，用于序列化和反序列化
        @JsonAdapter(FormatDate.class)
        private Date birthday;
        private String email;
        private String address;
        public TestEntity() {}
        public TestEntity(String name, int age, String sex, Date birthday, String email, String address) {
            this.name = name;
            this.age = age;
            this.sex = sex;
            this.birthday = birthday;
            this.email = email;
            this.address = address;
        }
    }
    @Test
    public void gsonTset()  {
        //声明Gson对象
        Gson gson = new Gson();      

        //声明Java对象，用于序列化
        TestEntity entity  = new TestEntity("盛夏 ",23,"未知",new Date(),"sx @xx.com",null);
        
        String objectToJson = gson.toJson(entity);
        System.out.println(objectToJson);
        //{"name":"盛夏 ","age":23,"sex":"未知","birthday":2022-04-27-18-25-16,"email":"sx @xx.com"}

        TestEntity entity1 = gson.fromJson(objectToJson, entity.getClass());
        System.out.println(entity1);
        //GsonTest.TestEntity(name=盛夏 , age=23, sex=未知, birthday=Wed Apr 27 18:25:16 CST 2022, email=sx @xx.com, address=null)


    }

    class FormatDate extends TypeAdapter {
        public static final String DATE_FORMAT_DASH_TIME = "yyyy-MM-dd-HH-mm-ss"; // 对格式化有要求，不太会用

        public  FormatDate(){ }

        @Override
        public void write(JsonWriter out, Object value) throws IOException {
            if (value == null) {
                out.nullValue();
            } else {
                out.jsonValue(new SimpleDateFormat(DATE_FORMAT_DASH_TIME).format(value));
            }
        }

        @SneakyThrows
        @Override
        public Object read(JsonReader in) throws IOException {
            return new SimpleDateFormat(DATE_FORMAT_DASH_TIME,Locale.CHINA).parse(in.nextString());
        }
    }
}

  另外：可以直接用这个进行日期格式化

​Gson gson = new GsonBuilder().setDateFormat("yyyyMMdd").create();

 

 类似资料：

相关阅读

相关文章

相关问答

快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.