Gson Summary
Java 解析 Json 最常用的类库有：google 的 Gson、阿里巴巴的 FastJson、以及 Jackson。这些都是非常优秀而且常用的库。
GSON 是 Google提供的用来在 Java 对象和 JSON 数据之间进行映射的 Java 类库，可以快速的将一个 Json 字符转成一个 Java 对象，或者将一个 Java 对象转化为 Json 字符串。
gson 在 github 上开源地址：https://github.com/google/gson
二进制开发包下载
所有版本下载地址： gson 二进制开发包下载地址：https://search.maven.org/artifact/com.google.code.gson/gson/2.8.5/jar
gson-2.8.4.jar下载、gson-2.8.5.jar下载
Maven 依赖
gson 在 Maven 仓库地址：https://mvnrepository.com/artifact/com.google.code.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>
<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.4</version>
</dependency>
编码示例
Gson toJson 与 fromJson
Gson 提供了 fromJson() 和 toJson() 两个直接用于解析和生成的方法，前者实现反序列化，后者实现了序列化。同时每个方法都提供了重载方法.。
Gson 对象的 toJson 方法可以将基本数据类型、以及 POJO 对象、List、Map 等转为 json 格式的字符串
Gson 对象的 fromJson 方法做与 toJson 相反的操作，将 json 格式的字符串转为基本数据类型、 POJO 对象、List、Map 等
package com.lct.other;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.lct.domain.Person;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* Created by Administrator on 2018/11/23 0023.
*/
public class GsonUtils {
/**
* json 字符串 -> 转为基本数据类型
*/
public static void parserJsonToBasicData() {
Gson gson = new Gson();
/**
* <T> T fromJson(String json, Class<T> classOfT)
* json：被解析的 json 字符串
* classOfT：解析结果的类型，可以是基本类型，也可以是 POJO 对象类型
*/
int i = gson.fromJson("100", int.class);
double d = gson.fromJson("100.99", Double.class);
boolean b = gson.fromJson("true", boolean.class);
String s = gson.fromJson("爱你", String.class);
System.out.print(i + "\t" + d + "\t" + b + "\t" + s);
//输出：100 100.99 true 爱你
}
/**
* 基本类型 -> 转为 Json 字符串
*/
public static void parserBasicDataToJson() {
Gson gson = new Gson();
/**
* String toJson(Object src)
* 将对象转为 json，如 基本数据、POJO 对象、以及 Map、List 等
*/
String jsonNumber = gson.toJson(100);
String jsonDouble = gson.toJson(100.99);
String jsonBoolean = gson.toJson(false);
String jsonString = gson.toJson("Tiger");
System.out.println(jsonNumber + "\t" + jsonDouble + "\t" + jsonBoolean + "\t" + jsonString);
//输出：100 100.99 false "Tiger"
}
/**
* 数组格式的 Json 字符串 - > 转为 数组
*/
public static void parserJsonStrToArray() {
String jsonArrayStr = "[\"Java\",\"Android\",\"IOS\"]";
Gson gson = new Gson();
String[] strings = gson.fromJson(jsonArrayStr, String[].class);
for (int i = 0; i < strings.length; i++) {
System.out.print((i + 1) + ":" + strings[i] + "\t");
}
//输出：1:Java 2:Android 3:IOS
}
/**
* 数组格式的 Json 字符串 - > 转为 List 列表
*/
public static void parserJsonStrToList() {
String jsonArray = "[\"Java1\",\"Android2\",\"IOS3\"]";
Gson gson = new Gson();
/**
* 如果解析结果是普通对象，如 单纯的 POJO，则可以使用 fromJson(String json, Class<T> classOfT)
* 如果解析结果是复杂类型，如 List<T> 这种，则应该使用 fromJson(String json, Type typeOfT)
* json：被转换的 json 格式的字符串
* typeOfT：解析结果类型
*/
List<String> stringList = gson.fromJson(jsonArray, new TypeToken<List<String>>() {
}.getType());
for (int i = 0; i < stringList.size(); i++) {
System.out.print((i + 1) + ":" + stringList.get(i) + "\t");
}
//输出：1:Java1 2:Android2 3:IOS3
}
/**
* Java POJO 对象 -> 转为 json 字符串
*/
public static void parserPOJOToJson() {
Person person = new Person();
person.setpId(9527);
person.setpName("华安");
person.setBirthday(new Date());
person.setIsMarry(true);
Gson gson = new Gson();
/**
* String toJson(Object src)
* 将对象转为 json，如 基本数据、POJO 对象、以及 Map、List 等
* 注意：如果 POJO 对象某个属性的值为 null，则 toJson(Object src) 默认不会对它进行转化
* 结果字符串中不会出现此属性
*/
String jsonUser = gson.toJson(person);
System.out.println(jsonUser);
//输出：{"pId":9527,"pName":"华安","birthday":"Nov 23, 2018 1:50:56 PM","isMarry":true}
}
/**
* Json 字符串 -> 转为 POJO 对象
*/
public static void parserJsonToPOJO() {
/**符合 json 格式的字符串*/
String personJson = "{\"pId\":9527,\"pName\":\"华安\",\"birthday\":\"Nov 23, 2018 1:50:56 PM\",\"isMarry\":true}";
Gson gson = new Gson();
/**
* <T> T fromJson(String json, Class<T> classOfT)
* json：被解析的 json 字符串
* classOfT：解析结果的类型，可以是基本类型，也可以是 POJO 对象类型，gson 会自动转换
*/
Person person = gson.fromJson(personJson, Person.class);
System.out.println(person);
//输出：Person{birthday=Fri Nov 23 13:50:56 CST 2018, pId=null, pName='华安', isMarry=true}
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String personBirthday = dateFormat.format(person.getBirthday());
System.out.println("用户生日：" + personBirthday);
//输出：用户生日：2018-11-23 13:50:56
//可见日期字符串也能完美转换
}
/**
* List 集合 -> 转为 json 字符串
* list 会被解析成 Json 数组，List 中的元素被解析成 json
*/
public static void parserPOJOListToJson() {
Person person = new Person();
person.setpId(9527);
person.setpName("华安");
person.setBirthday(new Date());
person.setIsMarry(true);
Person person2 = new Person();
person2.setpId(8866);
person2.setpName("宁王");
List<Person> personList = new ArrayList<>();
personList.add(person);
personList.add(person2);
Gson gson = new Gson();
/**
* String toJson(Object src)
* 将对象转为 json，如 基本数据、POJO 对象、以及 Map、List 等
* 注意：如果 POJO 对象某个属性的值为 null，则 toJson(Object src) 默认不会对它进行转化
* 结果字符串中不会出现此属性
*/
String personListJson = gson.toJson(personList);
System.out.println(personListJson);
//输出：[{"pId":9527,"pName":"华安","birthday":"Nov 23, 2018 2:05:58 PM","isMarry":true},{"pId":8866,"pName":"宁王","isMarry":false}]
}
}JsonObject、JsonArray、JsonParser
JsonObject 表示 json 对象、JsonArray 表示 json 对象数组、JsonParser 表示 json 解析，将 json 格式的字符串解析为 JsonObject、JsonArray 对象。
package com.lct.other;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
/**
* Created by Administrator on 2018/11/23 0023.
*/
public class JsonUtils {
/**
* Json 格式字符串 -> 解析为 JSON 对象
*/
public static void parserJsonStrToJsonObj() {
String jsonStr = "{\"pId\":9527,\"pName\":\"华安\",\"birthday\":\"Nov 23, 2018 1:50:56 PM\",\"isMarry\":true}";
JsonParser jsonParser = new JsonParser();
/**JsonElement parse(String json)
* 如果被解析的字符串不符合 json 格式，则抛出异常*/
JsonObject jsonObject = jsonParser.parse(jsonStr).getAsJsonObject();
/**JsonElement get(String memberName)
* 注意：如果 get 的 key 不存在，则返回 null，如果不加判断而进行取值的话，会抛：java.lang.NullPointerException
* */
Integer pId = jsonObject.get("pId").getAsInt();
String pName = jsonObject.get("pName").getAsString();
System.out.println(jsonObject);
//输出：{"pId":9527,"pName":"华安","birthday":"Nov 23, 2018 1:50:56 PM","isMarry":true}
System.out.println(pId + "\t" + pName);
//输出：9527 华安
}
/**
* Json 数组字符串 -> 解析为 JSON 数组对象
*/
public static void parserJsonStrToJsonArray() {
String jsonArrayStr = "[{\"pId\":9527,\"pName\":\"华安\",\"isMarry\":true},{\"pId\":8866,\"pName\":\"宁王\",\"isMarry\":false}]";
JsonParser jsonParser = new JsonParser();
JsonArray jsonArray = jsonParser.parse(jsonArrayStr).getAsJsonArray();
for (int i = 0; i < jsonArray.size(); i++) {
JsonObject jsonObject = jsonArray.get(i).getAsJsonObject();
System.out.println((i + 1) + ":" + jsonObject + "\t\t" + jsonObject.get("pName").getAsString());
}
//输出：1:{"pId":9527,"pName":"华安","isMarry":true} 华安
//输出：2:{"pId":8866,"pName":"宁王","isMarry":false} 宁王
}
/**
* 手动 创建 JSON对象 并添加基本类型属性
*/
public static void createJsonObj() {
/**
* JsonObject 添加基本类型属性使用 addProperty(String property, Number value)、 addProperty(String property, String value) 等
* JsonObject 添加复杂类型属性使用 add(String property, JsonElement value)
* JsonObject 与 JsonArray 都是 JsonElement 类的子类
* 提示：如果添加的 key 已经存在，则后面的会覆盖前面的
*/
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("pId", 9527);
jsonObject.addProperty("pName", "华安");
jsonObject.addProperty("isMarry", true);
/**
* JsonObject 取值使用 JsonElement get(String memberName)，根据 JsonElement 可以获取任意类型
* JsonObject 可以直接获取 JsonArray：JsonArray getAsJsonArray(String memberName)
* JsonObject 可以直接获取 JsonObject：JsonObject getAsJsonObject(String memberName)
*/
System.out.println(jsonObject + "\t" + jsonObject.get("pName").getAsString());
//输出：{"pId":9527,"pName":"华安","isMarry":true} 华安
}
/**
* 创建 JSON 数组
*/
public static void createJsonArray() {
String json1 = "{\"pId\":9527,\"pName\":\"华安\",\"isMarry\":true}";
String json2 = "{\"pId\":1200,\"pName\":\"安禄山\",\"isMarry\":false}";
JsonObject jsonObject1 = new JsonParser().parse(json1).getAsJsonObject();
JsonObject jsonObject2 = new JsonParser().parse(json2).getAsJsonObject();
JsonArray jsonArray = new JsonArray();
jsonArray.add(jsonObject1);
jsonArray.add(jsonObject2);
System.out.println(jsonArray);
//输出：[{"pId":9527,"pName":"华安","isMarry":true},{"pId":1200,"pName":"安禄山","isMarry":false}]
}
/**
* 删除 JsonObject 的某个属性
*/
public static void delJsonObjproperty() {
String json = "{\"pId\":9527,\"pName\":\"华安\",\"isMarry\":true}";
JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();
System.out.println("删除前：" + jsonObject);
//输出：删除前：{"pId":9527,"pName":"华安","isMarry":true}
/**
* JsonElement remove(String property)
* 用于删除 JsonObject 的属性，返回被删除的属性的值，原 JsonObject 会改变
* 与get取值同理，如果 remove 的属性值不存在，则返回 null
*/
String delProperty = jsonObject.remove("pName").getAsString();
System.out.println("删除 " + delProperty + " 后：" + jsonObject);
//输出：删除 华安 后：{"pId":9527,"isMarry":true}
}
/**
* 修改 JsonObject 属性，与添加一样使用 addProperty，当 key 已经存在时，会覆盖旧值
*/
public static void updateJsonObjproperty() {
String json = "{\"currentOnlineNumber\":\"101\",\"name\":\"汪茂雄\"}";
JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();
System.out.println("修改前：" + jsonObject);
jsonObject.addProperty("name", "赵丽颖");
System.out.println("修改后：" + jsonObject);
}
/**
* 获取 JsonObject 属性值
*/
public static void getJsonObjproperty() {
String json = "{\"pId\":9527,\"pName\":\"华安\",\"Dog\":{\"dName\":\"小黄\",\"color\":\"yellow\"}}";
JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();
System.out.println("操作对象：" + jsonObject);
/**
* JsonElement get(String memberName)：如果 memberName 不存在，则返回 null
* 所以除非应用中明确知道key存在，否则应该加以判断
*/
Integer pId = jsonObject.get("pId").getAsInt();
System.out.println("pId=" + pId);
/** boolean has(String memberName)
* 判断 JsonObject 中是否存在某个 key*/
if (!jsonObject.has("name")) {
System.out.println("name 属性不存在...");
}
/**
* JsonObject 取值使用 JsonElement get(String memberName)，根据 JsonElement 可以获取任意类型
* JsonObject 可以直接获取 JsonArray：JsonArray getAsJsonArray(String memberName)
* JsonObject 可以直接获取 JsonObject：JsonObject getAsJsonObject(String memberName)
*/
JsonObject dogJson = jsonObject.getAsJsonObject("Dog");
System.out.println(dogJson);
}
/**
* 实际应用中，如果业务比较复杂，则通常都会嵌套 json，如下所示：
* [{"pId":110,"pName":"华安","Dog":{"dName":"小黄","color":"yellow"}},{"pId":120,"pName":"安禄山","Dog":{"dName":"阿毛","color":"red"}}]
*/
public static void complexParsen() {
/**两只小狗 json 字符串*/
String dog1JsonStr = "{\"dName\":\"小黄\",\"color\":\"yellow\"}";
String dog2JsonStr = "{\"dName\":\"阿毛\",\"color\":\"red\"}";
/**将 json 字符串解析为 JsonObject 对象*/
JsonObject dog1Json = new JsonParser().parse(dog1JsonStr).getAsJsonObject();
JsonObject dog2Json = new JsonParser().parse(dog2JsonStr).getAsJsonObject();
/**创建两个用户的 JsonObject 对象*/
JsonObject user1Json = new JsonObject();
JsonObject user2Json = new JsonObject();
/**添加普通值*/
user1Json.addProperty("pId", 110);
user1Json.addProperty("pName", "华安");
/**添加JsonObject对象
* 注意：添加的对象，而不应该是符合 json 格式的字符串*/
user1Json.add("Dog", dog1Json);
user2Json.addProperty("pId", 120);
user2Json.addProperty("pName", "阿毛");
user2Json.add("Dog", dog2Json);
/**创建 JsonArray 用于存放 JsonObject
* 同样添加的应该是对象，而不应该是符合格式的字符串*/
JsonArray jsonArray = new JsonArray();
jsonArray.add(user1Json);
jsonArray.add(user2Json);
System.out.println(jsonArray);
//输出：[{"pId":110,"pName":"华安","Dog":{"dName":"小黄","color":"yellow"}},{"pId":120,"pName":"阿毛","Dog":{"dName":"阿毛","color":"red"}}]
}
public static void main(String[] args) {
getJsonObjproperty();
}
}字段值为 null 时是否序列化
Gson 在 toJson 的时候，默认是不会对属性值为 null 的字段进行序列化的，即结果中不会包含它，可以使用 GsonBuild 的 serializeNulls 方法构建 Gson，这样就会对属性值为 null 的字段进行序列化。
实际应用中，是否对属性值为 null 的字段进行序列化，根据需求定即可，建议进行序列化。
/**
* 对象中为 null 的字段，是否实行序列化，为了降低 bug，应该保持一致
* 实际应用中，前后台数据交互，系统之间数据传递时，如果接收端在获取某个值的时候不存在，而发送端以为自己以及发送了，
* 其实就是字段值可能为 null，发送端发送的时候，导致没有进行序列化
*/
public static void parserPOJOToJsonContainNull() {
/**
* Person 实体一共4个字段：Integer pId、String pName、Date birthday、Boolean isMarry
* 现在它的属性全部不进行赋值
*/
Person person = new Person();
/** 不对属性值为 null 的字段进行序列化，转换结果会为空*/
String personStr = new Gson().toJson(person);
/** 对属性值为 null 的字段进行序列化*/
String personStrFinal = new GsonBuilder().serializeNulls().create().toJson(person);
System.out.println(personStr);
//输出：{}
System.out.println(personStrFinal);
//输出：{"pId":null,"pName":null,"birthday":null,"isMarry":null}
/** 对于字段值为 null 的字符串，解析的时候也需要注意
* JsonElement get(String memberName) 的时候返回的就是 null
*/
JsonObject jsonObject = new JsonParser().parse(personStrFinal).getAsJsonObject();
System.out.println(jsonObject.get("pName"));//输出：null
/**判断元素是否为 null*/
System.out.println(jsonObject.get("pName").isJsonNull());
//输出：true
}