Bootstrap
Gson是一个Java库,可用于将Java对象转换为其JSON表示。它还可用于将JSON字符串转换为等效的Java对象。Gson可以处理任意Java对象,包括您没有源代码的预先存在的对象。本文主要介绍Java中使用Gson(com.google.code.gson)解析处理Json数据,通过Gradle或Maven方式引用,Json数据的序列化和反序化及使用的示例代码。

1、Gson的安装引用

下载地址https://github.com/google/gson/releases

1)通过Gradle引用

dependencies {
implementation 'com.google.code.gson:gson:2.8.5'
}

2)通过Maven引用

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

2、Gson使用示例代码

1)基本数据类型示例

// 序列化
Gson gson = new Gson();
gson.toJson(1);            // ==> 1
gson.toJson("abcd");       // ==> "abcd"
gson.toJson(new Long(10)); // ==> 10
int[] values = { 1 };
gson.toJson(values);       // ==> [1]
// 反序列化
int one = gson.fromJson("1", int.class);
Integer one = gson.fromJson("1", Integer.class);
Long one = gson.fromJson("1", Long.class);
Boolean false = gson.fromJson("false", Boolean.class);
String str = gson.fromJson("\"abc\"", String.class);
String[] anotherStr = gson.fromJson("[\"abc\"]", String[].class);

2)对象类型示例

class BagOfPrimitives {
  private int value1 = 1;
  private String value2 = "abc";
  private transient int value3 = 3;
  BagOfPrimitives() {
    // no-args constructor
  }
}
// 序列化
BagOfPrimitives obj = new BagOfPrimitives();
Gson gson = new Gson();
String json = gson.toJson(obj);  
// ==> json is {"value1":1,"value2":"abc"}

注意:不能使用循环引用序列化对象,因为这会导致无限递归。

// 反序列化
BagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class);
// ==> obj2 is just like obj

3)嵌套类(包括内部类)

Gson可以很容易地序列化静态嵌套类。
Gson还可以反序列化静态嵌套类。但是,Gson 不能自动反序列化纯内部类,
因为它们的no-args构造函数还需要对反序列化时不可用的包含Object的引用。

您可以通过使内部类静态或为其提供自定义InstanceCreator来解决此问题。示例代码:

public class A { 
  public String a; 
  class B { 
    public String b; 
    public B() {
      // No args constructor for B
    }
  } 
}

注意:上述class B不能(默认情况下)使用Gson序列化。
{"b":"abc"}由于B类是一个内部类,Gson不能反序列化为B的实例。
如果它被定义为静态类B,那么Gson就能够反序列化字符串。

另一种解决方案是为B编写自定义实例创建器。

public class InstanceCreatorForB implements InstanceCreator<A.B> {
  private final A a;
  public InstanceCreatorForB(A a)  {
    this.a = a;
  }
  public A.B createInstance(Type type) {
    return a.new B();
  }
}

以上是可能的,但不推荐

4)数组示例

Gson gson = new Gson();
int[] ints = {1, 2, 3, 4, 5};
String[] strings = {"abc", "def", "ghi"};
// 序列化
gson.toJson(ints);     // ==> [1,2,3,4,5]
gson.toJson(strings);  // ==> ["abc", "def", "ghi"]
// 反序列化
int[] ints2 = gson.fromJson("[1,2,3,4,5]", int[].class); 
// ==> ints2 will be same as ints

支持具有任意复杂元素类型的多维数组。

5)Collections示例

Gson gson = new Gson();
Collection<Integer> ints = Lists.immutableList(1,2,3,4,5);
// 序列化
String json = gson.toJson(ints);  // ==> json is [1,2,3,4,5]
// 反序列化
Type collectionType = new TypeToken<Collection<Integer>>(){}.getType();
Collection<Integer> ints2 = gson.fromJson(json, collectionType);
// ==> ints2 is same as ints

6)序列化和反序列化泛型类型示例

class Foo<T> {
  T value;
}
Gson gson = new Gson();
Foo<Bar> foo = new Foo<Bar>();
gson.toJson(foo); // May not serialize foo.value correctly
gson.fromJson(json, foo.getClass()); // Fails to deserialize foo.value as Bar

上面的代码无法将值解释为类型Bar,因为Gson调用list.getClass()获取其类信息,但此方法返回一个原始类,Foo.class。这意味着Gson无法知道这是一个类型的对象Foo<Bar>,而不仅仅是普通的Foo。

您可以通过为泛型类型指定正确的参数化类型来解决此问题。您可以使用TypeToken该类来完成此操作;

Type fooType = new TypeToken<Foo<Bar>>() {}.getType();
gson.toJson(foo, fooType);
gson.fromJson(json, fooType);

参考文档https://github.com/google/gson/blob/master/UserGuide.md