Java對象的序列化與反序列化-Json篇

說到Java對象的序列化與反序列化，我們首先想到的應該是Java的Serializable接口，這玩意在兩個系統之間的DTO對象裡面可能會用到，用于系統之間的資料傳輸。或者在RPC（遠端方法調用）時可能會用到。 

但其實若是用于資料傳輸，xml和json兩種資料格式用得更多一些。但是為什麼不用XStream呢，XStream确實好用，但是在Applet環境下可以使用的xml類庫也就隻有jdom了，連dom4j在Applet環境下都沒有權限使用（Java反射的某些特性是需要權限的，Applet的安全機制不允許）。 

扯遠了，本文要說的是Java對象與Json的互相轉換。目前Java常用的Json類庫有3種，即fastjson、jackson和gson，分别介紹如何将一個Java對象轉換成Json和将一個Json字元串轉換成Java對象，其實它們的用法大同小異。 

一、首先看Maven依賴 

二、需要序列化的POJO和初始化代碼 

三、fastjson的使用 

四、jackson的使用 

五、gson的使用 

若不會maven，請參考Maven的基本用法：http://jisonami.iteye.com/blog/2300036 

1 <!-- json -->  
 2 <!-- 引入fastjson依賴 -->  
 3 <dependency>  
 4     <groupId>com.alibaba</groupId>  
 5     <artifactId>fastjson</artifactId>  
 6     <version>1.2.12</version>  
 7 </dependency>  
 8 <!-- 引jackson依賴 -->  
 9 <!-- jackson核心包，必選，提供基于“流模式”解析的API -->  
10 <dependency>  
11     <groupId>com.fasterxml.jackson.core</groupId>  
12     <artifactId>jackson-core</artifactId>  
13     <version>2.7.4</version>  
14 </dependency>  
15 <!-- jackson注解包，可選，提供注解功能 -->  
16 <dependency>  
17     <groupId>com.fasterxml.jackson.core</groupId>  
18     <artifactId>jackson-annotations</artifactId>  
19     <version>2.7.4</version>  
20 </dependency>  
21 <!-- jackson資料綁定包，可選，提供基于“對象綁定”和“樹模型”相關API -->  
22 <dependency>  
23     <groupId>com.fasterxml.jackson.core</groupId>  
24     <artifactId>jackson-databind</artifactId>  
25     <version>2.7.4</version>  
26 </dependency>  
27 <!-- 引入gson依賴 -->  
28 <dependency>  
29     <groupId>com.google.code.gson</groupId>  
30     <artifactId>gson</artifactId>  
31     <version>2.6.2</version>  
32 </dependency>        

以下3種類庫的使用均使用下面這個POJO 

1 public class User {  
 2     public User(){}  
 3     private String id;  
 4     private String name;  
 5     private String password;  
 6     public String getId() {  
 7         return id;  
 8     }  
 9     public void setId(String id) {  
10         this.id = id;  
11     }  
12     public String getName() {  
13         return name;  
14     }  
15     public void setName(String name) {  
16         this.name = name;  
17     }  
18     public String getPassword() {  
19         return password;  
20     }  
21     public void setPassword(String password) {  
22         this.password = password;  
23     }  
24     @Override  
25     public String toString() {  
26         return "User [id=" + id + ", name=" + name + ", password=" + password  
27                 + "]";  
28     }     
29 }        

1 /** 
 2  * 初始化User對象 
 3  * @return user 
 4  */  
 5 private static User initUser(){  
 6     User user = new User();  
 7     user.setId("1");  
 8     user.setName("jison");  
 9     user.setPassword("jison");  
10     return user;  
11 }        

fastjson的主要工具類是JSON，以下代碼實作Java對象的序列化與反序列化 

1 // 将Java對象序列化為Json字元串  
2     String objectToJson = JSON.toJSONString(initUser());  
3     System.out.println(objectToJson);  
4     // 将Json字元串反序列化為Java對象  
5     User user = JSON.parseObject(objectToJson, User.class);  
6     System.out.println(user);        

jackson我們經常用到的是它的資料綁定包下的ObjectMapper類，以下代碼實作Java對象的序列化與反序列化 

ObjectMapper objectMapper = new ObjectMapper();  
    // 将Java對象序列化為Json字元串  
    String objectToJson = objectMapper.writeValueAsString(initUser());  
    System.out.println(objectToJson);  
    // 将Json字元串反序列化為Java對象  
    User user = objectMapper.readValue(objectToJson, User.class);  
    System.out.println(user);        

gson的主要工具類是Gson，使用GsonBuilder構造，以下代碼實作Java對象的序列化與反序列化 

1 Gson gson = new GsonBuilder().create();  
2     // 将Java對象序列化為Json字元串  
3     String objectToJson = gson.toJson(initUser());  
4     System.out.println(objectToJson);  
5     // 将Json字元串反序列化為Java對象  
6     User user = gson.fromJson(objectToJson, User.class);  
7     System.out.println(user);        

1 public class JsonUtils {  
 2   
 3     /** 
 4      * 初始化User對象 
 5      * @return user 
 6      */  
 7     private static User initUser(){  
 8         User user = new User();  
 9         user.setId("1");  
10         user.setName("jison");  
11         user.setPassword("jison");  
12         return user;  
13     }  
14       
15     public static void main(String[] args) throws Exception {  
16         // fastjson用法  
17         fastjson();  
18         // jackson用法  
19         jackson();  
20         // gson用法  
21         gson();  
22     }  
23       
24     private static void fastjson(){  
25         // 将Java對象序列化為Json字元串  
26         String objectToJson = JSON.toJSONString(initUser());  
27         System.out.println(objectToJson);  
28         // 将Json字元串反序列化為Java對象  
29         User user = JSON.parseObject(objectToJson, User.class);  
30         System.out.println(user);  
31     }  
32       
33     private static void jackson() throws Exception{  
34         ObjectMapper objectMapper = new ObjectMapper();  
35         // 将Java對象序列化為Json字元串  
36         String objectToJson = objectMapper.writeValueAsString(initUser());  
37         System.out.println(objectToJson);  
38         // 将Json字元串反序列化為Java對象  
39         User user = objectMapper.readValue(objectToJson, User.class);  
40         System.out.println(user);  
41     }  
42       
43     private static void gson(){  
44         Gson gson = new GsonBuilder().create();  
45         // 将Java對象序列化為Json字元串  
46         String objectToJson = gson.toJson(initUser());  
47         System.out.println(objectToJson);  
48         // 将Json字元串反序列化為Java對象  
49         User user = gson.fromJson(objectToJson, User.class);  
50         System.out.println(user);  
51     }  
52 }