Gson的使用

待我称王封你为后i 2022-06-02 10:35 155阅读 0赞

转自：http://blog.csdn.net/IO\_Field/article/details/51204517

项目中，解析json数据时，一直使用Gson解析。对于Gson的基本使用没有什么问题，但并没有Gson更深入的认识。json作为主流的数据传递方式，深入理解Gson的用法还是很有必要的，那么系统的了解下Gson到底可以做什么。

# 1.Gson的对象 #

Gson是google推出的的一个开源库，可以用来将Java对象转换为Json对象，当然，也可以用来将json对象转换为Java对象。

## 2.Gson的目标 ##

1.提供简单易用的方法比如 toString() ，构造方法来转化JAVA为JSON以及反转化。  
        2.提供已存在的不可修改对象转化为JSON以及反转化。  
        3.提供对象的惯例表示  
        4.支持任意复杂对象  
        5.生成健壮、可读的JSON输出

# 3.JsonElement #

该类是一个抽象类，代表着json串的某一个元素。这个元素可以是一个Json(JsonObject)、可以是 一个数组(JsonArray)、可以是一个Java的基本类型(JsonPrimitive)、当然也可以为null(JsonNull); JsonObject,JsonArray,JsonPrimitive，JsonNull都是JsonElement这个抽象类的子类。JsonElement提供了一系列的方法来判断当前的JsonElement是否是上述子类的一种：比如isJsonObject()用来判断当 前的json元素是否是一个数组类型

# 4.基本用法 #

1. Gson提供了toJson()和fromJson()两个直接用于解析和生成的方法，前者实现序列化，后者实现反序列化。

**\[java\]**  [view plain][]   [copy][view plain]

1.  <span style="font-size:14px;">        **public** **class** User \{  
2.              **private** String userName;  
3.              **private** **int** userAge;  
4.              **private** String userEmail;  
5.          \}  
6.    
7.          Gson gson = **new** Gson();  
8.          // 序列化  
9.          User user = **new** User("张三", 23, "男");  
10.         String jsonUser = gson.toJson(user, User.**class**);  
11.         System.out.println("jsonUser = \[" + jsonUser + "\]"); // jsonUser = \[\{"userName":"张三","userAge":23,"userEmail":"男"\}\]  
12.         // 反序列化  
13.         User user\_ = gson.fromJson(jsonUser, User.**class**);  
14.         System.out.println(user\_.toString()); // User\{userName='张三', userAge=23, userEmail='男'\}  
15.   
16.         // 序列化数组  
17.         String names\[\] = **new** String\[\]\{ "Teaphy", "Job", "Lous", "Flosd"\};  
18.         String jsonNames = gson.toJson(names);  
19.         System.out.println(jsonNames); // \["Teaphy","Job","Lous","Flosd"\]  
20.         // 反序列化  
21.         String\[\] strings = gson.fromJson(jsonNames, String\[\].**class**);  
22.         System.out.println(strings.toString()); //\[Teaphy, Job, Lous, Flosd\]  
23.   
24.         // 序列话集合  
25.         Type type = **new** TypeToken<ArrayList<User>>() \{  
26.         \}.getType();  
27.         List<User> lists = **new** ArrayList<>();  
28.         lists.add(**new** User("Jso", 23, "M"));  
29.         lists.add(**new** User("Taad", 45, "W"));  
30.         lists.add(**new** User("Goos", 23, "M"));  
31.         String jsonList = gson.toJson(lists, type);  
32.         System.out.println(jsonList);  // \[\{"userName":"Jso","userAge":23,"userEmail":"M"\},  
33.                                         // \{"userName":"Taad","userAge":45,"userEmail":"W"\},  
34.                                         // \{"userName":"Goos","userAge":23,"userEmail":"M"\}\]  
35.   
36.         // 反序列化集合  
37.         List<User> lists\_ = gson.fromJson(jsonList, type);  
38.         System.out.println(lists\_.toString()); // \[User\{userName='Jso', userAge=23, userEmail='M'\},  
39.                                                 // User\{userName='Taad', userAge=45, userEmail='W'\},  
40.                                                 // User\{userName='Goos', userAge=23, userEmail='M'\}\]</span>

2. 泛型的引用

**\[java\]**  [view plain][]   [copy][view plain]

1.  <span style="font-size:14px;">        \{  
2.              "retCode": "0000"，  
3.              "resInfo": "成功"，  
4.              "User":\{  
5.                  "userName":"张三"，  
6.                  "userAge":23,  
7.                  "userEmail":"xxx@xx.com"  
8.              \}  
9.          \}</span>

该如何解析上面的Json呢？个人而言，有两种思路，第一种是创建一个包含retCode、retInfo、User等字段的类， 另外一种是通过getJsonObject("User"),获取到User的json对象进行解析。第一种方法对于封装处理不好，显得繁琐，对于第二种方法，虽然封装好了，但是代码冗余。不得不承认，我习惯了第二张解析方式。偶尔翻看博客时，发现Gson解析，还可以使用泛型封装，简单粗爆啊，果断学习在案。

**\[java\]**  [view plain][]   [copy][view plain]

1.  <span style="font-size:14px;">        2.1 封装Result<>泛型类  
2.          **public** **class** Result<T> \{  
3.              **public** **int** code;  
4.              **public** String message;  
5.              **public** T data;  
6.          \}  
7.          2. 解析  
8.          \{ "retCode": "0000"，"resInfo": "成功"，"User":\{ ...\}\}  
9.          \{ "retCode": "0000"，"resInfo": "成功"，"Users":\{ \{...\}...\}\}  
10.           
11.         \* 没有引入泛型以前  
12.         **public** **class** UserResult \{  
13.             **public** **int** code;  
14.             **public** String message;  
15.             **public** User data;  
16.         \}  
17.         //=========  
18.         **public** **class** UserListResult \{  
19.             **public** **int** code;  
20.             **public** String message;  
21.             **public** List<User> data;  
22.         \}  
23.         //=========  
24.         String json = "\{..........\}";  
25.         Gson gson = **new** Gson();  
26.         UserResult userResult = gson.fromJson(json,UserResult.**class**);  
27.         User user = userResult.data;  
28.   
29.         UserListResult userListResult = gson.fromJson(json,UserListResult.**class**);  
30.         List<User> users = userListResult.data;  
31.         解析时，针对不同的情况，总是要写一不同的接口。  
32.         \* 引入泛型以后  
33.         //不再重复定义Result类  
34.         Type userType = **new** TypeToken<Result<User>>()\{\}.getType();  
35.         Result<User> userResult = gson.fromJson(json,userType);  
36.         User user = userResult.data;  
37.   
38.         Type userListType = **new** TypeToken<Result<List<User>>>()\{\}.getType();  
39.         Result<List<User>> userListResult = gson.fromJson(json,userListType);  
40.         List<User> users = userListResult.data;</span>

引入泛型以后，只需要一个接口，即可解析。

[view plain]: http://blog.csdn.net/IO_Field/article/details/51204517#