Gson-序列化与反序列化基础操作

作者:聂勇 欢迎转载,请保留作者信息并说明文章来源!
2015-外伶仃岛山顶俯瞰大海起雾

Gson是众多开源JSON类库中的一个,使用非常简单,使用toJson和fromJson方法可将JSON字符串和Java对象相互转换,主要的特性有:

  • 全面支持泛型。
  • Java对象不需要在源代码中增加注解就可以进行转换。
  • 转换时使用Java对象的字段,而非setter和getter方法。
  • 可自定义序列化和反序列化满足个性化需求,甚至编写自己的TypeAdapter改变底层的解析。

下面,通过几段代码展示Gson如何将Java中常用的POJO、数组和集合序列化成JSON字符串,并反序列化。

一、普通对象(POJO)

1、一个POJO类:Person,有两个属性:name和age。
源代码文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/** **
* 简单的Java对象。
*
* @author <a href="mailto:aofengblog@163.com">聂勇</a>
*/
public class Person {
private String name;
private int age;
public Person() {
// nothing
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}

2、对Person进行序列化与反序列化。
源代码文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
* Java简单对象的序列化与反序列化。
*
* @author <a href="mailto:aofengblog@163.com">聂勇</a>
*/
public class SimpleObjectSerialize {
/**
* 序列化:将Java对象转换成JSON字符串。
*/
public void serialize(Person person) {
Gson gson = new Gson();
System.out.println( gson.toJson(person) );
}
/**
* 反序列化:将JSON字符串转换成Java对象。
*/
public void deserialize(String json) {
Gson gson = new Gson();
Person person = gson.fromJson(json, Person.class);
System.out.println( person );
}
public static void main(String[] args) {
SimpleObjectSerialize ss = new SimpleObjectSerialize();
Person person = new Person("NieYong", 33);
ss.serialize(person);
String json = " {\"name\":\"AoFeng\",\"age\":32}";
ss.deserialize(json);
}
}

运行SimpleObjectSerialize,控制台输出如下信息:

{“name”:”NieYong”,”age”:33}
Person [name=AoFeng, age=32]

二、数组

1、序列化

将整型对象数组、字符串数组和对象数组序列化成JSON字符串。
源代码文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/**
* 数组的序列化与反序列化。
*
* @author <a href="mailto:aofengblog@163.com">聂勇</a>
*/
public class ArraySerialize {
public void serialize(Object[] arr) {
Gson gson = new Gson();
System.out.println( gson.toJson(arr) );
}
public static void main(String[] args) {
ArraySerialize as = new ArraySerialize();
// 整型对象数组
Integer[] intArr = new Integer[3];
intArr[0] = 9;
intArr[1] = 7;
intArr[2] = 5;
as.serialize(intArr);
// 字符串数组
String[] names = new String[3];
names[0] = "张三";
names[1] = "李四";
names[2] = "王五";
as.serialize(names);
// 对象数组
Person[] persons = new Person[2];
persons[0] = new Person("小明", 10);
persons[1] = new Person("马丽", 9);
as.serialize(persons);
}
}

运行ArraySerialize,控制台输出如下信息:

[9,7,5]
[“张三”,”李四”,”王五”]
[{“name”:”小明”,”age”:10},{“name”:”马丽”,”age”:9}]

2、反序列化

将JSON字符串反序列化成整型对象数组、字符串数组和对象数组。
源代码文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/**
* 数组的反序列化。
*
* @author <a href="mailto:aofengblog@163.com">聂勇</a>
*/
public class ArrayDeserialize {
public <T> T deserialize(String json, Class<T> claz) {
Gson gson = new Gson();
return gson.fromJson(json, claz);
}
public static void main(String[] args) {
ArrayDeserialize ad = new ArrayDeserialize();
// 整型数组
String intArrJson = "[9,7,5]";
int[] intArr = ad.deserialize(intArrJson, int[].class);
System.out.println("---------- 整型数组 ----------");
for (int i : intArr) {
System.out.println(i);
}
// 字符串数组
String strArrJson = "[\"张三\",\"李四\",\"王五\"]";
String[] strArr = ad.deserialize(strArrJson, String[].class);
System.out.println("---------- 字符串数组 ----------");
for (String str : strArr) {
System.out.println(str);
}
// 对象数组
String objArrJson = "[{\"name\":\"小明\",\"age\":10},{\"name\":\"马丽\",\"age\":9}]";
Person[] objArr = ad.deserialize(objArrJson, Person[].class);
System.out.println("---------- 对象数组 ----------");
for (Person person : objArr) {
System.out.println(person);
}
}
}

运行ArrayDeserialize,控制台输出如下信息:

———- 整型数组 ———-
9
7
5
———- 字符串数组 ———-
张三
李四
王五
———- 对象数组 ———-
Person [name=小明, age=10]
Person [name=马丽, age=9]

三、集合类

1、序列化

将List、Set和Map序列化成JSON字符串。
源代码文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
* 集合的序列化。
*
* @author <a href="mailto:aofengblog@163.com">聂勇</a>
*/
public class CollectionsSerialize {
public void serialize(Collection<?> c) {
Gson gson = new Gson();
System.out.println( gson.toJson(c) );
}
public void serialize(Map<?, ?> map) {
Gson gson = new Gson();
System.out.println( gson.toJson(map) );
}
public static void main(String[] args) {
CollectionsSerialize cs = new CollectionsSerialize();
// 整型List
List<Integer> intList = new ArrayList<Integer>();
intList.add(9);
intList.add(8);
intList.add(0);
cs.serialize(intList);
// 字符串Set
Set<String> strSet = new HashSet<String>();
strSet.add("Hello");
strSet.add("World");
strSet.add("Best");
cs.serialize(strSet);
// Map
Map<String, Person> objMap = new HashMap<String, Person>();
objMap.put("marry", new Person("马丽", 20));
objMap.put("xiaomin", new Person("小明", 21));
cs.serialize(objMap);
}
}

运行CollectionsSerialize,控制台输出如下信息:

[9,8,0]
[“Best”,”World”,”Hello”]
{“xiaomin”:{“name”:”小明”,”age”:21},”marry”:{“name”:”马丽”,”age”:20}}

2、反序列化

将JSON字符串反序列化成List、Set和Map对象。
源代码文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
* 集合的反序列化。
*
* @author <a href="mailto:aofengblog@163.com">聂勇</a>
*/
public class CollectionDeserialize {
public <T> T deserialize(String json, Type type) {
Gson gson = new Gson();
return gson.fromJson(json, type);
}
public static void main(String[] args) {
CollectionDeserialize cd = new CollectionDeserialize();
//整型List
String intListJson = "[9,8,0]";
List<Integer> intList = cd.deserialize( intListJson,
new TypeToken<List<Integer>>(){}.getType() );
System.out.println("---------- 整型List ----------");
for (Integer obj : intList) {
System.out.println(obj);
}
// 字符串Set
String strSetJson = "[\"Best\",\"World\",\"Hello\"]";
Set<String> strSet = cd.deserialize( strSetJson,
new TypeToken<Set<String>>(){}.getType() );
System.out.println("---------- 字符串Set ----------");
for (String str : strSet) {
System.out.println(str);
}
// Map
String objMapJson = "{\"xiaomin\":{\"name\":\"小明\",\"age\":21},\"marry\":{\"name\":\"马丽\",\"age\":20}}";
Map<String, Person> objMap = cd.deserialize( objMapJson,
new TypeToken<Map<String, Person>>(){}.getType() );
System.out.println("---------- Map ----------");
for (Entry<String, Person> entry : objMap.entrySet()) {
System.out.println(entry);
}
}
}

运行CollectionDeserialize,控制台输出如下信息:

———- 整型List ———-
9
8
0
———- 字符串Set ———-
Best
World
Hello
———- Map ———-
xiaomin=Person [name=小明, age=21]
marry=Person [name=马丽, age=20]

四、参考资料