使用Gson解析Json

1.Json介紹

      JSON的全稱是"JavaScript Object Notation",即JavaScript對象表示法，它是一種基於文本，獨立於語言的輕量級數據交換格式。XML也是一種數據交換格式。二者的區別：由於XML雖然能夠做爲跨平臺的數據交換格式，可是在JS中處理XML很是不方便，同時XML標記比數據多，增長了交換產生的流量，而JSON沒有附加的任何標記，在JS中可做爲對象處理，因此咱們傾向於選擇JSON來交換數據。

2.Json的兩種結構

    JSON有兩種表示結構，對象和數組。

    對象結構：以{}爲閉合，中間部分由","來分割的"key/value"對構成，關鍵字和值之間以"："分隔。其中關鍵字是字符串，而值可使字符串，數值，true,false,null,對象或數組。語法結構以下：
　　{key1:value1,key2:value2,key3:value3,key4:value4......}
　　舉例：{"UserID":11, "Name":"Truly", "Email":"zhuleipro@hotmail.com"};
　 數組結構：以[]閉合，中間由","來分割的值列表組成，語法結構以下：
　　[
　　{
　　key1:value1,
　　key2:value2
　　},
　　{
　　key3:value3,
　　key4:value4
　　}]

3.區分JSON字符串和JSON對象

 

     JSON字符串：使用""(雙引號)或''(單引號)包括的符合JSON格式的字符串。例如：
var str = "{StudentID:'101',Name:‘mike',Age:15}";
     JSON對象：指符合JSON格式的js對象，例如：

var jsonObj = {StudentID:'101',Name:‘mike',Age:15};

     下面咱們就Java使用Gson解析json數據舉例說明，首先咱們要導入Gson.jar包。網上能夠下載，我這裏用的是Gson-2.3.jar。

 4.實例

實現：

使用Gson的API實現Json和javaBean的相互轉換

使用Gson的API實現Map和Json字符串相互轉換
List<Object>或List<JavaBean>與Json字符串相互轉換

目錄結構：

這裏，咱們主要對json字符串和各類對象之間轉換進行了舉例，實現方法在JsonUtil.java中，同時，針對config.properties配置文件中沒有的字段信息，咱們會進行更新。

代碼清單【1】People.java

 1 package com.lxf.json;
 2 /**
 3  * javaBean
 4  * @author Administrator
 5  * 
 6  * 20170107
 7  */
 8 public class People
 9 {
10     //編號
11     private String id;
12     //姓名
13     private String name;
14     //郵箱地址
15     private String email;
16     //是不是vip  true:是  false:不是
17     private boolean vip;
18     
19     public People()
20     {
21         
22     }
23     public People(String id, String name, String email, boolean vip) {
24         super();
25         this.id = id;
26         this.name = name;
27         this.email = email;
28         this.vip = vip;
29     }
30     
31     public String getId()
32     {
33         return id;
34     }
35     public void setId(String id)
36     {
37         this.id = id;
38     }
39     public String getName() 
40     {
41         return name;
42     }
43     public void setName(String name) 
44     {
45         this.name = name;
46     }
47     public String getEmail() 
48     {
49         return email;
50     }
51     public void setEmail(String email) 
52     {
53         this.email = email;
54     }
55     public boolean isVip() 
56     {
57         return vip;
58     }
59     public void setVip(boolean vip)
60     {
61         this.vip = vip;
62     }
63     
64     @Override
65     public String toString() {
66         StringBuilder builder = new StringBuilder();
67         builder.append("People [id=");
68         builder.append(id);
69         builder.append(", name=");
70         builder.append(name);
71         builder.append(", email=");
72         builder.append(email);
73         builder.append(", vip=");
74         builder.append(vip);
75         builder.append("]");
76         return builder.toString();
77     }    
78 
79 }

 

代碼清單【2】JsonUtil.java

  1 package com.lxf.json;
  2 
  3 import java.io.FileInputStream;
  4 import java.io.FileOutputStream;
  5 import java.io.OutputStream;
  6 import java.lang.reflect.Type;
  7 import java.util.ArrayList;
  8 import java.util.HashMap;
  9 import java.util.Iterator;
 10 import java.util.LinkedHashMap;
 11 import java.util.List;
 12 import java.util.Map;
 13 import java.util.Properties;
 14 import java.util.Set;
 15 
 16 import com.google.gson.Gson;
 17 import com.google.gson.JsonElement;
 18 import com.google.gson.JsonObject;
 19 import com.google.gson.JsonPrimitive;
 20 import com.google.gson.internal.LinkedHashTreeMap;
 21 import com.google.gson.internal.LinkedTreeMap;
 22 import com.google.gson.reflect.TypeToken;
 23 
 24 /**
 25  * Json工具類
 26  * @author Administrator
 27  *
 28  */
 29 public class JsonUtil 
 30 {
 31     private static String propertiesPath = "src/config.properties";
 32     
 33     private static Properties prop = new Properties(); 
 34     
 35     static 
 36     {
 37         try 
 38         {
 39             prop.load(new FileInputStream(propertiesPath));
 40         }
 41         catch (Exception e) 
 42         {
 43             e.printStackTrace();
 44         }
 45     }
 46     
 47     /**
 48      * 0.0讀取配置文件的相應鍵的值
 49      * @param str  主鍵
 50      * @return
 51      */
 52     public static String readConfig(String str)
 53     {
 54     
 55         if(prop.containsKey(str))
 56         {
 57             return prop.getProperty(str);
 58         }
 59         else
 60         {
 61             throw new RuntimeException("the properties file don't contains "+ str + " key");
 62         }
 63         
 64     }
 65     
 66     /**
 67      * 0.1 更新（或插入）一對properties信息(主鍵及其鍵值)  
 68      * 若是該主鍵已經存在，更新該主鍵的值；  
 69      * 若是該主鍵不存在，則插件一對鍵值。 
 70      * @param str  鍵名
 71      * @param value  鍵值
 72      */
 73     public static void updateConfig(String str,String value) 
 74     {
 75         try
 76         {
 77             OutputStream fos = new FileOutputStream(propertiesPath);
 78             //若是該主鍵已經存在，更新該主鍵的值；  
 79             prop.setProperty(str, value);
 80             if(prop.containsKey(str))
 81             {
 82                 prop.store(fos, "Update ：" + str + "=" + value);
 83             }
 84             else
 85             {
 86                 prop.store(fos, "Insert : " + str + "=" + value);
 87             }
 88         } 
 89         catch (Exception e) 
 90         {
 91             System.out.println();
 92         }
 93         
 94     }
 95     /*
 96      * 1.1 json字符串--->JavaBean
 97      */
 98     public static void jsonToJavaBean()
 99     {
100         
101         String jsonStr = readConfig("huawei");
102         Gson gson = new Gson();
103         People people = gson.fromJson(jsonStr, People.class);
104         System.out.println(people.toString());
105     }
106     
107     /*
108      * 1.2 JavaBean--->json字符串
109      */
110     public static void javaBeanToJson() 
111     {
112         //建立javaBean
113         People p = new People();
114         p.setId("99");
115         p.setName("apple");
116         p.setEmail("110@163.com");
117         p.setVip(false);
118         //把javaBean轉換爲json字符串
119         Gson gson = new Gson();
120         String json = gson.toJson(p);
121         System.out.println(json);
122         
123         //查看配置文件中是否有該配置項，若是沒有，添加到配置文件中，若是有，更新value值
124         String configKey = p.getName();
125         updateConfig(configKey,json);
126     }
127     
128     /*
129      * 1.3 json字符串---->Json對象 
130      */
131     public static void jsonToJsonObj()
132     {
133         String jsonStr = readConfig("huawei");
134         Gson gson = new Gson();
135         //json字符串轉換爲JsonObject
136         JsonObject jsonObject = (JsonObject) gson.fromJson(jsonStr, JsonElement.class);
137         System.out.println(jsonObject);
138         System.out.println(jsonObject.toString().equals(jsonStr));
139         //獲得JsonObject的某個字段的值
140         JsonPrimitive namePrimitive = (JsonPrimitive) jsonObject.get("name");
141         //JsonPrimitive namePrimitive =  jsonObject.getAsJsonPrimitive("name");
142         System.out.println(namePrimitive);
143         String name = namePrimitive.getAsString();
144         System.out.println(name);
145     }
146     /**
147      * 總結:
148      *     --在json字符串轉成JavaBean時，fromJson傳入的第二個參數是Entity.class;
149      *     --在json字符串轉成JsonObject時，fromJson傳入的第二個參數是JsonElement.class,不能傳入JsonObject.class,
150      *  不然返回的JsonObject是空的對象。
151      *  --若是想獲得某個JsonObject對象的某個屬性值，可使用.get(String str).getAsString().
152      * 
153      */
154 
155 
156     /**
157      * 2.1Map--->json轉換
158      */
159     public static void mapToJson()
160     {
161         Gson gson = new Gson();
162         Map<String, Object> map = new HashMap<String, Object>();
163         map.put("id", 1);
164         map.put("name", "xiaomi");
165         map.put("vip", true);
166         String json = gson.toJson(map);
167         System.out.println(json);
168         
169         //查看配置文件中是否有該配置項，若是沒有，添加到配置文件中，若是有，更新value值
170         String configKey = (String) map.get("name");
171         updateConfig(configKey,json);
172     }
173     
174     /**
175      * 2.2 json---->Map轉換
176      */
177     
178     public static void jsonToMap()
179     {
180         Gson gson = new Gson();
181         String json = prop.getProperty("xiaomi");
182         Map<String, Object> map = gson.fromJson(json, Map.class);
183         //這裏原來map中id鍵對應的值類型是int，可是轉成json字符串再轉回來後，int類型變爲Double類型了，這值得重視。
184         //若是須要int型，還須要利用double.intValue()方法轉爲int型。
185         System.out.println(map);
186         System.out.println(map.get("name"));
187         System.out.println(map.get("name").getClass());
188         System.out.println(map.get("name").getClass().getName());
189     }
190     
191     
192     /*
193      * 3.List與Json相互轉換
194      */
195     /**
196      * 3.1 List<Object>與json字符串互換
197      */
198     public static void listObjectToJson()
199     {
200         List<Object> list = new ArrayList<Object>();
201         for(int i = 0; i < 2; i++ )
202         {
203             list.add(i);
204             list.add("element" + i);
205         }
206         System.out.println(list);
207         Gson gson = new Gson();
208         String json = gson.toJson(list);
209         System.out.println(json);
210         
211         list = gson.fromJson(json, List.class);
212         System.out.println(list);
213         for(int i = 0 ; i < list.size(); i++)
214         {
215             Object o = list.get(i);
216             System.out.println(o);
217             System.out.println(o.getClass().getName());
218         }
219     }
220     
221     /**
222      * List<Bean> 轉化爲json字符串
223      * 
224      * 1.無論是轉換List<Object>,仍是List<JavaBean>,當把字符串反序列化爲list時，gson.fromJson(String json, Class<T> classOfT)
225      * 的第2個參數必須傳入List.class.
226      * 2.轉換List<JavaBean>，有2中方法：
227      * (1).gson.fromJson(String json, Class<T> classOfT)的第二個參數傳入List.class.此時返回的額list中的元素不是JavaBean，而是Map
228      * 若是想獲得一個個javaBean，還須要從map總去除鍵值對，而後利用構造器封裝成javaBean.
229      * (2).gson.fromJson(String json, Class<T> classOfT)的第二個參數傳入Type對象（Type type = new TypeToken<List<People>>(){}.getType();），
230      * 此時返回的list對象的元素就是一個個的javaBean對象。
231      */
232     public static void listBeanTojson()
233     {
234         List<People> personList = new ArrayList<People>();
235         People p1 = new People("1001", "三星", "1001@163.com", false);
236         People p2 = new People("1002", "諾基亞", "1002@163.com", false);
237         People p3 = new People("1003", "中興", "1003@163.com", true);
238         personList.add(p1);
239         personList.add(p2);
240         personList.add(p3);
241         
242         //利用List.class與json字符串轉換
243         Gson gson = new Gson();
244         String json = gson.toJson(personList) ;
245         System.out.println(json);
246         
247         //寫入到配置文件中
248         String configKey = "info";
249         updateConfig(configKey,json);
250     }
251     
252     /**
253      * 使用List.class將json轉換爲List<JavaBean>
254      */
255     public static void jsonToListJavaBean()
256     {
257         System.out.println("*********");
258         Gson gson = new Gson();
259         String json = prop.getProperty("info");
260         List<LinkedTreeMap<String, Object>> list = gson.fromJson(json,List.class);
261         System.out.println(list);
262         for(LinkedTreeMap<String, Object> map : list)
263         {
264             System.out.println(map.getClass().getName());
265             System.out.println(map.toString());
266             Set<Map.Entry<String, Object>> set = map.entrySet();
267             for(Iterator<Map.Entry<String, Object>> it = set.iterator();it.hasNext();)
268             {
269                 Map.Entry<String, Object> entry = it.next();
270                 System.out.println(entry.getKey() + "--->" + entry.getValue());
271             }
272         }
273         
274     }
275     
276     /**
277      * 使用Type將json字符串轉化爲List<JavaBean>
278      */
279     public static void jsonToListJavaByType()
280     {    
281         Gson gson = new Gson();
282         String json = prop.getProperty("info");
283         List<People> personList = new ArrayList<People>();
284         People p1 = new People("1001", "三星", "1001@163.com", false);
285         People p2 = new People("1002", "諾基亞", "1002@163.com", false);
286         People p3 = new People("1003", "中興", "1003@163.com", true);
287         personList.add(p1);
288         personList.add(p2);
289         personList.add(p3);
290         
291         //利用TypeToken,List<JavaBean>與Json互換
292         Type type = new TypeToken<List<People>>(){}.getType();
293         System.out.println("type :" + type);
294         String json2 = gson.toJson(personList, type);
295                 
296         System.out.println(json2.equals(json));
297         List<People> userList = gson.fromJson(json2, type);
298         
299         System.out.println(userList);
300         for(int i = 0; i < userList.size(); i++)
301         {
302             System.out.println(userList.get(i).getEmail());
303         }
304     }
305     
306 
307 }

 

代碼清單【3】JsonMain.java

 1 package com.lxf.json;
 2 
 3 import org.junit.Test;
 4 
 5 import com.google.gson.Gson;
 6 
 7 public class JsonMain 
 8 {
 9     /**
10      * 1.1 json字符串--->JavaBean測試
11      */
12     @Test
13     public void testJsonToJavaBean()
14     {
15         JsonUtil.jsonToJavaBean(); 
16     }
17     
18     /**
19      * 1.2 JavaBean--->json字符串測試
20      */
21     @Test
22     public void testJavaBeanToJson() 
23     {
24         JsonUtil.javaBeanToJson();
25         
26     }
27     /**
28      * 1.3 json字符串---->JsonObject
29      */
30     @Test
31     public void testJsonToJsonObject()
32     {
33         JsonUtil.jsonToJsonObj();
34     }
35     
36     /**
37      * 2.1Map--->Json測試
38      */
39     @Test
40     public void testMapToJson()
41     {
42         JsonUtil.mapToJson();
43     }
44     
45     /**
46      *  json---->Map轉換
47      */
48     @Test
49     public void testJsonToMap()
50     {
51         JsonUtil.jsonToMap();
52     }
53     
54     /**
55      * list<Object> <----> json測試
56      */
57     @Test
58     public void testListObjectToJson()
59     {
60         JsonUtil.listObjectToJson();
61     }
62     
63     /**
64      * List<Bean> 轉化爲json字符串 測試
65      */
66     @Test
67     public void testlistBeanTojson()
68     {
69         JsonUtil.listBeanTojson();
70     }
71 
72     /**
73      * 使用List.class將json轉換爲List<JavaBean> 測試
74      */
75     @Test
76     public void testJsonToListJavaBean()
77     {
78         JsonUtil.jsonToListJavaBean();
79     }
80     /**
81      * 使用Type將json字符串轉化爲List<JavaBean>
82      */
83     @Test
84     public void testJsonToListJavaByType()
85     {
86         JsonUtil.jsonToListJavaByType();
87     }
88 }

 

運行結果：

 

config.properties文件：

 

1 #Update \uFF1Ainfo=[{"id":"1001","name":"\u4E09\u661F","email":"1001@163.com","vip":false},{"id":"1002","name":"\u8BFA\u57FA\u4E9A","email":"1002@163.com","vip":false},{"id":"1003","name":"\u4E2D\u5174","email":"1003@163.com","vip":true}]
2 #Mon Jan 09 23:54:36 CST 2017
3 apple={"id"\:"99","name"\:"apple","email"\:"110@163.com","vip"\:false}
4 huawei={"id"\:101,"name"\:"huawei","email"\:"2582376681@qq.com","vip"\:true}
5 info=[{"id"\:"1001","name"\:"\u4E09\u661F","email"\:"1001@163.com","vip"\:false},{"id"\:"1002","name"\:"\u8BFA\u57FA\u4E9A","email"\:"1002@163.com","vip"\:false},{"id"\:"1003","name"\:"\u4E2D\u5174","email"\:"1003@163.com","vip"\:true}]
6 xiaomi={"id"\:1,"vip"\:true,"name"\:"xiaomi"}

 

 5.拓展補充