JSON解析类库之Gson（1） --- 简单JavaBean对象、带泛型的Bean对象与JSON互转

来源：互联网发布：2k16mc亚洲人捏脸数据编辑：程序博客网时间：2024/06/05 02:37

JSON解析类库之Gson（1） --- 简单JavaBean对象、带泛型的Bean对象与JSON互转

---Gson类库学习, 生成与解析json数据，json字符串与Java对象互转

一、前言

JSON类库众多，个人使用过JSON-lib，Jackson，Fastjson，最终还是更喜欢Gson，Gson的功能可以说是最全的，而且api 也非常好用，Google出品品质保证。

二、Gson简介

Gson（又称Google Gson）是Google公司发布的一个开放源代码的Java库，主要用途为序列化Java对象为JSON字符串，或反序列化JSON字符串成Java对象。而JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成，广泛应用于各种数据的交互中，尤其是服务器与客户端的交互。

◆◆如何获取Gson

1、Jar包下载地址（最新2.8.0，截止到2017-5-3）：http://mvnrepository.com/artifact/com.google.code.gson/gson/2.8.0

在使用Gson API工作之前，你需要下载库(jar文件)，并将其包含到类路径中。

CSDN下载：http://download.csdn.net/detail/chenchunlin526/9831875 (包含jar包和源码、文档)

2、[推荐使用☺]对于那些偏好使用Maven管理依赖(JAR文件)的读者，添加如下依赖到pom.xml。

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

如果这个库用于web应用，请确保在WEB-INF/lib文件夹中保持一份拷贝。

◆◆Gson的优点

○提供一种像toString()和构造方法的很简单的机制(toJson()，fromJson())，来实现Java 对象和Json之间的互相转换。

○允许已经存在的无法改变的对象，转换成Json，或者Json转换成已存在的对象。

○允许自定义对象的表现形式

○支持任意的复杂对象

○能够生成可压缩和可读的Json的字符串输出。

○依赖包少，只有一个jar核心包，无其他依赖。

○Gson安全稳定，无漏洞。（Fastjson出现过漏洞）

三、基本概念

Serialization：序列化，Java对象转换成Json字符串的过程。生成JSON字符串的过程。

Deserialization：反序列化，字符串转换成Java对象。解析JSON字符串，生成Java对象的过程。

JSON数据中的JsonElement有下面这四种类型【这记几个概念在2.0以后很少用了】：

JsonPrimitive —— 例如一个字符串或整型

JsonObject —— 一个以 JsonElement 名字（类型为 String）作为索引的集合。也就是说可以把 JsonObject 看作值为 JsonElement 的键值对集合。

JsonArray —— JsonElement 的集合。注意数组的元素可以是四种类型中的任意一种，或者混合类型都支持。

JsonNull —— 值为null

四、主要使用入口与API

◆◆◆

GSON API提供一个类Gson，它的实例化对象被用来处理Java对象和JSON字符串的转换。可以调用默认构造器，或如下代码的形式，使用GsonBuilder类创建这个类的实例。GsonBuilder类是可定制化的，并且允许开发者按需实例化Gson。

Gson的两种实例化方式:

1：使用new Gson(); 普通实例化方式，不能配置定制化选项

Gson gson = new Gson();

2：☆通过GsonBuilder 可以配置多种选项

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();

两种实例化方式，推荐第二种，因为第一种是简单的默认实现，无法定制更多配置。

◆◆◆

Gson提供了toJson() 和 fromJson()两个直接用于生成和解析的方法，其中toJson()实现了序列化，fromJson()实现反序列化。同时每个方法都提供了重载方法，我常用的总共有5个。

Gson API入口类是com.google.gson.Gson，常用的序列化和反序列化操作都可以在Gson类的实例化对象上完成。

public String toJson(Object src) //序列化，①把Java对象序列化成JSON字符串，如果是泛型对象，该方法会调用方法②
public String toJson(Object src, Type typeOfSrc) //  ② 一般不用
public void toJson(Object src, Appendable writer)) // 比如将序列化后的JSON串写入文件流中保存起来
public <T> T fromJson(String json, Class<T> classOfT) // 反序列化，JavaBean对象
public <T> T fromJson(String json, Type typeOfT) // 反序列化Map<>/List<>等泛型类型，返回的也是泛型

API方法源码：

public String toJson(Object src) {
   if (src == null) {
     return toJson(JsonNull.INSTANCE);
    }
   return toJson(src, src.getClass()); //调用下面的方法
}
public String toJson(Object src, Type typeOfSrc) {
  StringWriter writer = new StringWriter();
  toJson(src, typeOfSrc, writer);
  return writer.toString();
}

更多方法之间的调用关系，请直接参考源码。

四、Gson的基本使用

◆◆◆基本数据类型的序列化与反序列化

-----------------------------------------------------

1、Java对象的序列化，生成字符串（序列化）

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

2、Java对象的生成（反序列化）

Gson gson = new GsonBuilder().create();
int i = gson.fromJson("100", int.class);              //100
double d = gson.fromJson("\"99.99\"", double.class);  //99.99
boolean b = gson.fromJson("true", boolean.class);     // true
String str = gson.fromJson("String", String.class);   // String

注：不知道你是否注意到了第2、3行有什么不一样没？（基本数据类型要小写）

◆◆◆简单JavaBean对象的序列化与反序列化

---------------------------------------------------------------------------------------------------

实体类：

public class User {
    private String id;
    private String name;
    private Date birthday;
    public User() {
        super();
    }
    public User(String id, String name, Date birthday) {
        super();
        this.id = id;
        this.name = name;
        this.birthday = birthday;
    }
    //为了代码简洁，这里移除了getter和setter方法等
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", birthday=" + birthday + "]";
    }
}

序列化： Java对象---》JSON字符串

反序列化： JSON字符串 ---》Java对象

package com.chunlynn.gson;
import java.util.Date;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
public class GsonTest7 {
    public static void main(String[] args) {
        Gson gson = new GsonBuilder().create();
        /**
         * [1] 简单JavaBean序列化成JSON字符串
         */
        User user = new User("1", "王重阳", new Date());
        String jsonStr = gson.toJson(user);
        System.out.println("简单JavaBean序列化 ==》 " + jsonStr);
        // [1]简单JavaBean序列化成JSON字符串 ==》 {"id":"1","name":"王重阳","birthday":"May 3, 2017 2:02:15 PM"}
        /**
         * [2] JSON字符串反序列化成简单JavaBean
         */
        User u = gson.fromJson(jsonStr, User.class);
        System.out.println("JSON字符串反序列化成简单JavaBean ==》" + u);
        // [2]JSON字符串反序列化成简单JavaBean ==》User [id=1, name=王重阳, birthday=Wed May 03 14:16:04 CST 2017]
    }
}

上面的序列化结果JSON字符串不美观，且日期不是我们想要的格式，那么我们可以使用GsonBuilder类创建的Gson实例的配置选项。GsonBuilder类是可定制化的，并且允许开发者按需实例化Gson。

定制化JSON输出：

package com.chunlynn.gson;
import java.util.Date;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
public class GsonTest7 {
    public static void main(String[] args) {
        Gson gson = new GsonBuilder()
                .setPrettyPrinting()//格式化输出（序列化）
                .setDateFormat("yyyy-MM-dd HH:mm:ss") //序列化日期格式化输出
                .create();
        /**
         * [1] 简单JavaBean序列化成JSON字符串
         */
        User user = new User("1", "王重阳", new Date());
        String jsonStr = gson.toJson(user);
        System.out.println("简单JavaBean序列化 ==》 " + jsonStr);
        /*简单JavaBean序列化 ==》 {
              "id": "1",
              "name": "王重阳",
              "birthday": "2017-05-03 14:24:32"
            }
        */
        /**
         * [2] JSON字符串反序列化成简单JavaBean
         */
        User u = gson.fromJson(jsonStr, User.class);
        System.out.println("JSON字符串反序列化成简单JavaBean ==》" + u);
        // [2]JSON字符串反序列化成简单JavaBean ==》User [id=1, name=王重阳, birthday=Wed May 03 14:16:04 CST 2017]
    }
}

从上面可以看出，在用用GsonBuilder类创建的Gson实例的时候，可以定制可以需要的配置，这些对我们的JSON序列化和反序列化非常有用。

◆◆◆稍微复杂一点的JavaBean对象的序列化与反序列化

---------------------------------------------------------------------------------------------------

◇情况1 ：实体类：

public class Dept {
    private String id;
    private String deptName;
    private List<User> users;
    //为了代码简洁，这里移除了getter和setter方法、toString方法等 }

序列化： Java对象---》JSON字符串

反序列化： JSON字符串 ---》Java对象

package com.chunlynn.gson;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
public class GsonTest8 {
    public static void main(String[] args) {
        Gson gson = new GsonBuilder()//
                .setPrettyPrinting()//格式化输出（序列化）
                .setDateFormat("yyyy-MM-dd HH:mm:ss") //序列化日期格式化输出
                .create();
        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);
        /**
         * [3] 包含其他对象的JavaBean序列化成JSON字符串
         */
        String jsonStr = gson.toJson(dept);
        System.out.println("包含其他对象的JavaBean序列化成JSON字符串 ==》 " + jsonStr);
        /*包含其他对象的JavaBean序列化成JSON字符串 ==》 {
          "id": "A001",
          "deptName": "研发部",
          "users": [
            {
              "id": "1",
              "name": "王重阳",
              "birthday": "2017-05-03 14:52:11"
            },
            {
              "id": "2",
              "name": "郭靖",
              "birthday": "2017-05-03 14:52:11"
            },
            {
              "id": "3",
              "name": "黄蓉",
              "birthday": "2017-05-03 14:52:11"
            }
          ]
        }
        */
        /**
         * [4] JSON字符串反序列化成包含其他对象的JavaBean
         */
        Dept d = gson.fromJson(jsonStr, Dept.class);
        List<User> deptUsers = d.getUsers();
        System.out.println("Dept对象的users属性  ==》 " + deptUsers);
        //Dept对象的users属性  ==》 [User [id=1, name=王重阳, birthday=Wed May 03 14:57:33 CST 2017], User [id=2, name=郭靖, birthday=Wed May 03 14:57:33 CST 2017], User [id=3, name=黄蓉, birthday=Wed May 03 14:57:33 CST 2017]]
        System.out.println("JSON字符串反序列化成简单JavaBean ==》" + d);
        //[4]JSON字符串反序列化成简单JavaBean ==》Dept [id=A001, deptName=研发部, users=[User [id=1, name=王重阳, birthday=Wed May 03 14:54:25 CST 2017], User [id=2, name=郭靖, birthday=Wed May 03 14:54:25 CST 2017], User [id=3, name=黄蓉, birthday=Wed May 03 14:54:25 CST 2017]]]
    }
}

◇情况2 ：实体类：

public class Dept2 {
    private String id;
    private String deptName;
    private User[] users;
    //为了代码简洁，这里移除了getter和setter方法、toString方法等 }

序列化： Java对象---》JSON字符串

反序列化： JSON字符串 ---》Java对象

package com.chunlynn.gson;
import java.util.Date;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
public class GsonTest9 {
    public static void main(String[] args) {
        Gson gson = new GsonBuilder()//
                .setPrettyPrinting()//格式化输出（序列化）
                .setDateFormat("yyyy-MM-dd HH:mm:ss") //序列化日期格式化输出
                .create();
        User user1 = new User("1", "王重阳", new Date());
        User user2 = new User("2", "郭靖", new Date());
        User user3 = new User("3", "黄蓉", new Date());
        User[] usersArray = { user1, user2, user3 };
        Dept2 dept = new Dept2();
        dept.setId("A001");
        dept.setDeptName("研发部");
        dept.setUsers(usersArray);
        /**
         * [5] 包含其他对象的JavaBean序列化成JSON字符串
         */
        String jsonStr = gson.toJson(dept);
        System.out.println("包含其他对象的JavaBean序列化成JSON字符串 ==》 " + jsonStr);
        /*包含其他对象的JavaBean序列化成JSON字符串 ==》 {
          "id": "A001",
          "deptName": "研发部",
          "users": [
            {
              "id": "1",
              "name": "王重阳",
              "birthday": "2017-05-03 15:22:14"
            },
            {
              "id": "2",
              "name": "郭靖",
              "birthday": "2017-05-03 15:22:14"
            },
            {
              "id": "3",
              "name": "黄蓉",
              "birthday": "2017-05-03 15:22:14"
            }
          ]
        }
        */
        /**
         * [6] JSON字符串反序列化成包含其他对象的JavaBean
         */
        Dept2 d = gson.fromJson(jsonStr, Dept2.class);
        User[] deptUsers = d.getUsers();
        for (int i = 0; i < deptUsers.length; i++) {
            User user = deptUsers[i];
            System.out.println("User对象 ==》 " + user);
            /*
             *  User对象 ==》 User [id=1, name=王重阳, birthday=Wed May 03 15:22:14 CST 2017]
                User对象 ==》 User [id=2, name=郭靖, birthday=Wed May 03 15:22:14 CST 2017]
                User对象 ==》 User [id=3, name=黄蓉, birthday=Wed May 03 15:22:14 CST 2017]
             */
        }
        System.out.println("Dept对象的users属性  ==》 " + deptUsers);
        //dept对象的users属性  ==》 [Lcom.chunlynn.gson.User;@5b37e0d2
        System.out.println("JSON字符串反序列化成简单JavaBean ==》" + d);
        //[4]JSON字符串反序列化成简单JavaBean ==》Dept [id=A001, deptName=研发部, users=[Lcom.chunlynn.gson.User;@4459eb14]
    }
}

接下来的第二篇文章，将讲解JSON与泛型Map、List对象的转换。

◆◆该系列的其他文章：

JSON解析类库之Gson（1） --- 简单JavaBean对象、带泛型的Bean对象与JSON互转

JSON解析类库之Gson（2） --- 泛型对象Map、List与JSON字符串互转

JSON解析类库之Gson（3） --- Gson注解

JSON解析类库之Gson（4）--- TypeAdapter接管序列化与反序列化（上）

---------------------------------------------------------------------------------------------------

2 0