JSON格式解析和libjson使用簡介

在閱讀本文之前，請先閱讀下《Rss Reader例項開發之系統設計》一文。

Rss Reader例項開發中，進行網路資料交換時主要使用到了兩種資料格式：JSON與XML。本文主要介紹JSON格式的簡單概念及JSON在Rss Reader中的應用，XML格式的使用將在下一篇文章做介紹。
 

JSON簡介：

JSON(JavaScript Object Notation) 是一種輕量級的資料交換格式，可以把JSON的結構理解成無序的、可巢狀的key-value鍵值對集合，這些key-value鍵值對是以結構體或陣列的形式來組織的。同一級的key-value鍵值對之間是用一個“,”（逗號）隔開，每個key-value鍵值對是由一個key後面緊接一個“:”（冒號），冒號後面是這個key對應的value。Key是一個word，由大小寫字母、下劃線及數字組成，可以由雙引號封閉，也可以不加雙引號；而value的取值集為：Number、Boolean(true或false)、null、String、Object及Array，如圖一：

 
（圖一）
 

1、Number：數值，包括整形數與浮點數，如：123、0.83、-2.7e10。其結構如圖二：

（圖二）

2、String：字串，是以雙引號封閉起來的一串字元，使用反斜槓來轉義，如：\\、\n等，JSON中字串的概念與C/C++或者JAVA語言裡的字串概念差不多，如：”abc”。其結構如圖三：

（圖三）

3、Object：物件，也可理解成一個結構體，是以一對大括號封閉起來的無序的key-value鍵值對集合，例如：{name:"Susan", age:27, birthday:{year:1984, month:2, day:11}}；也可以寫成：{"name":"Susan", "age":27, "birthday":{"year":1984, "month":2, "day":11}}；其結構如圖四：

（圖四）

4、Array：陣列，JSON的陣列是一個以中括號封閉起來的value的集合，即陣列內的各個成員的資料型別可以不一樣，這一點就跟C/JAVA的陣列概念不同了。每個value之間是由一個“,”(逗號)隔開，例如：[123, abc, false, {name:mj}]；其結構如圖五：

 
（圖五）

關於JSON的詳細說明與教程請自行到網路上搜索，有很多。
 

下面我們就來動手寫一個例子：

1. {
2.     result:true,
3.     root:{
4.         version:"201007091640",
5.         channels:[
6.         {
7.             name:
   "新聞中心",
8.             subchnls:[
9.             {
10.                 title:"焦點新聞",
11.                 link:"http://news.mtc.sohu.com/news/channel/1/news.rss",
12.                 desc:"家事、國事、天下事"
13.             },
14.             {
15.                 title:"新聞頻道",
16.                 link:"http://news.mtc.sohu.com/news/channel/2/news.rss",
17.                 desc:"讓您實時掌握國際動態"
18.             },
19.             {
20.                 title:"軍事頻道",
21.                 link:"http://news.mtc.sohu.com/news/channel/3/news.rss",
22.                 desc:"軍事"
23.             }
24.             ]
25.         },
26.         {
27.             name:"體育新聞",
28.             subchnls:[
29.             {
30.                 title:"體育要聞彙總",
31.                 link:"http://news.mtc.sohu.com/news/channel/4/news.rss",
32.                 desc:"erewr"
33.             },
34.             {
35.                 title:"國際足壇",
36.                 link:"http://news.mtc.sohu.com/news/channel/5/news.rss",
37.                 desc:"werewr"
38.             }
39.             ]
40.         }
41.         ]
42.     }
43. }

這段JSON描述了一個物件（最外層大括號包圍的部分），為了方便區分，我們就將其稱為物件A吧。物件A有兩個Item（即key-value鍵值對），一個是result，其值為true；一個是root，其值為一個物件，稱為物件B。物件B也有兩個Item，一個是version，其值為一個字串” 201007091640”；一個是channels，其值是一個數組，而陣列的成員都是一個物件，每個物件又包含兩個Item，一個是name，值分別為字串"新聞中心"和"體育新聞"；一個是subchnls，值都是陣列，每個陣列又分別有若干個成員，每個subchnls成員也都是一個物件，每個物件都有三個Item：title、link和desc。也許你看到這，已經是一頭大汗了，不過沒關係，我們來帖張這段JSON文字對應的結構圖，有圖就有真相，請看圖六：

（圖六：黑色實線為物件，虛線為值，橙色實線為陣列）

在RssReader中使用cJSON：

在RssReader中使用了開源庫cJSON來解析JSON，所以在此就介紹下cJSON的使用：

在CJSON中，一個key-value鍵值對被解析並存放在一個cJSON結構體變數中，其value取值集為：FALSE，TRUE，NULL，NUMBER，STRING，OBJECT，ARRAY。它們分別被存放在CJSON物件的child、valuestring、valueint、valuedouble變數中，而用於判斷某個CJSON物件value的資料型別則是CJSON物件的type變數，其取值範圍與CJSON物件的value集是一一對應的，如：cJSON_False對應FALSE。
cJSON Types:  

1. #define     cJSON_False     0
2. #define     cJSON_True      1
3. #define     cJSON_NULL  2
4. #define     cJSON_Number    3
5. #define     cJSON_String    4
6. #define     cJSON_Array     5
7. #define     cJSON_Object    6

cJSON 結構體:

1. typedef struct cJSON
2. {
3. struct cJSON *next,*prev; //指向上一項/下一項
4. struct cJSON *child; //指向下一級，也就是當type為cJSON_Object或cJSON_Array時，此指標不為空。
5. int type;
6. char *valuestring; // 當type為cJSON_String時
7. int valueint; // 當 type為cJSON_Number時
8. double valuedouble; //當type為cJSON_Number時
9. char *string; // 當前項的名稱，也就是key-value鍵值對的key
10. } cJSON;

在解析JSON過程中，從JSON格式描述的value資料到CJSON物件中存放的變數的一個對映關係如圖七：

（圖七）

對CJSON格式的解析是使用cJSON_Parse()方法，其傳入的引數是一個CJSON的Object/Array結構的字串，解析成功則返回一個cJSON結構體變數的指標，在使用完成後需要呼叫cJSON_Delete()將該指標銷燬。CJSON是以樹狀結構來組織內部的各個cJSON結構體變數的，一般地，要使用某個cJSON結構體變數，需要呼叫cJSON_GetObjectItem()方法並根據其父節點的cJSON結構體變數指標與該項的名稱來獲取其指標，舉個例子： 
 

1. bool bResult;
2. char jsonString[] = “{result:true}”;
3. //獲取result的值true
4. cJSON* pItem = NULL;
5. cJSON* pRoot = cJSON_Parse ( jsonString );
6. if ( pRoot )
7. {
8.     pItem = cJSON_GetObjectItem ( pRoot, “result” );
9. if ( pItem )
10.     {
11.         bResult = pItem->valueint;   //由於result的值type為cJSON_False或cJSON_True，所以其值被存放在valueint變數中
12.     }
13.     cJSON_Delete ( pRoot );
14. }

在上例中，不管result的值type為何型別，都是通過呼叫cJSON_GetObjectItem()方法獲取其對應的cJSON結構體變數的指標，只是在處理其對應的值時會有所不同。如果result的值type為cJSON_Object，則需要通過呼叫cJSON_GetObjectItem( pItem, “subItemKey”)來獲取其子Item的指標。在處理值type為cJSON_Array的Item時，就需要再用到另外兩個API：cJSON_GetArraySize ()和cJSON_GetArrayItem()。我們舉個獲取一個數組成員值的例子：

1. char* out;
2. char jsonString[] = “{colors:[\“red\”, \“green\”,\ “blue\”, \“yellow\”, \“white\”]}”;
3. cJSON* pArray = NULL;
4. cJSON* pRoot = cJSON_Parse ( jsonString );
5. if ( pRoot )
6. {
7.     pArray = cJSON_GetObjectItem ( pRoot, “colors” );
8. if ( pArray )
9.     {
10.         cJSON* pArrayItem = NULL;
11. int nCount = cJSON_GetArraySize ( pArray ); //獲取pArray陣列的大小
12. for( int i = 0; i < nCount; i++)
13.         {
14.             pArrayItem = cJSON_GetArrayItem(pArray, i);
15. out = cJSON_Print( pArrayItem ); //將pArrayItem的值以字串的形式列印到char型buffer上，cJSON_Print()會自動分配記憶體空間，用完需要釋放記憶體。
16.             SS_printf( “array item %d: %s\n”, i, out);
17.             Free( out );
18.         }
19.     }
20.     cJSON_Delete ( pRoot );
21. }

在提取一個複雜的JSON格式的資料時，也只是將以上兩個例子使用到的方法進行組合呼叫罷了。所以對CJSON提供的API的使用是很簡單有效的。有了以上知識的瞭解，我們就可以編寫一些程式碼將例一中的JSON解析並提取其中的資料，還是貼點程式碼才是硬道理，程式碼如下：   

TChannelsData.h:

1. /** 子頻道資訊結構體
2. *
3. */
4. struct SUBCHNL_DATA
5. {
6.     SUBCHNL_DATA();
7. void clear();
8.     TUChar * m_title;
9. char * m_link;
10.     TUChar * m_desc;
11. };
12. /** 大頻道資訊結構體
13. *
14. */
15. struct CHANNEL_DATA
16. {
17.     CHANNEL_DATA();
18.     TUChar* m_pszTitle;
19.     vector m_aSubChnlList;
20. };
21. //………….
22. // TChannelsData 類成員變數：RSSReaderConfig 版本號
23. char m_pszVersion[32];
24. // TChannelsData 類成員變數：頻道資訊列表
25. vector m_aChnlsList;
26. //………….

TChannelsData.cpp:  

1. /** 解析JSON格式的內容
2. *
3. * \param pszJsonText 解析的JSON格式內容字串
4. *
5. * \return true:有更新資料; false:沒有更新資料
6. */
7. Boolean TChannelsData::ParseJson(char* pszJsonText)
8. {
9. //char* out;
10.     cJSON* objJson;
11.     objJson= cJSON_Parse(pszJsonText);
12. if (objJson)
13.     {
14. //out=cJSON_Print(objJson);
15.         cJSON* objRootItem = NULL;
16. //判斷是否需要更新
17.         objRootItem = cJSON_GetObjectItem(objJson, "result");
18. if (objRootItem)
19.         {
20. if (!objRootItem->valueint)
21.             {
22. return FALSE;
23.             }
24.         }
25. else
26.         {
27. return FALSE;
28.         }
29. //獲取更新資料，根節點root
30.         objRootItem = cJSON_GetObjectItem(objJson, "root");
31. if (objRootItem)
32.         {
33.             cJSON* objJsonItem = NULL;
34. //獲取版本號
35.             objJsonItem = cJSON_GetObjectItem(objRootItem, "version");
36. if (objJsonItem)
37.             {
38.                 Int32 nLen = strlen(objJsonItem->valuestring);
39.                 strncpy(m_pszVersion, objJsonItem->valuestring, (nLen < 32)? nLen : 31);
40.             }
41. //解析出大頻道
42.             _ParseChannels(objRootItem);
43.         }
44. //SS_printf("=======[parse json]%s\n",out);
45.         cJSON_Delete(objJson);
46. //free(out);
47.     }
48. return TRUE;
49. }
50. /** 解析出大頻道
51. *
52. * \param pCJson cJSON物件指標
53. *
54. * \return void
55. */
56. void TChannelsData::_ParseChannels(cJSON* pCJson)
57. {
58.     cJSON* pJsonArray = NULL;
59. if (!pCJson)
60.     {
61. return;
62.     }
63.     pJsonArray = cJSON_GetObjectItem(pCJson, "channels");
64. if(pJsonArray)
65.     {
66.         cJSON* pArrayItem = NULL;
67.         cJSON* pJsonTemp = NULL;
68.         Int32 nSize = cJSON_GetArraySize(pJsonArray);
69. for (Int32 i = 0; i < nSize; i++)
70.         {
71.             pArrayItem = cJSON_GetArrayItem(pJsonArray, i);
72. if (pArrayItem)
73.             {
74.                 CHANNEL_DATA tChannelData;
75.                 Int32 nLen = 0;
76. //獲取大頻道名稱
77.                 tChannelData.m_pszTitle = _JsonGetTUString(pArrayItem, "name");
78. //解析出子頻道
79.                 _ParseSubChnls(tChannelData.m_aSubChnlList, pArrayItem);
80. //將大頻道資訊物件壓入列表中
81.                 m_aChnlsList.push_back(tChannelData);
82.             }
83. else
84.             {
85. continue;
86.             }
87.         }
88.     }
89. }
90. /** 解析子頻道
91. *
92. * \param aSubChnlList 存放子頻道資料的vector物件
93. * \param pCJson cJSON物件指標
94. *
95. * \return void
96. */
97. void TChannelsData::_ParseSubChnls(vector& aSubChnlList, cJSON* pCJson)
98. {
99.     cJSON* pJsonArray = NULL;
100. if (!pCJson)
101.     {
102. return;
103.     }
104.     pJsonArray = cJSON_GetObjectItem(pCJson, "subchnls");
105. if (pJsonArray)
106.     {
107.         cJSON* pArrayItem = NULL;
108. //cJSON* pJsonTemp = NULL;
109.         Int32 nSize = cJSON_GetArraySize(pJsonArray);
110. for (Int32 i = 0; i < nSize; i++)
111.         {
112.             pArrayItem = cJSON_GetArrayItem(pJsonArray, i);
113. if (pArrayItem)
114.             {
115.                 SUBCHNL_DATA tSubChnlData;
116.                 Int32 nLen = 0;
117. //get title
118.                 tSubChnlData.m_title = _JsonGetTUString(pArrayItem, "title");
119. //get link
120.                 tSubChnlData.m_link = _JsonGetString(pArrayItem, "link");
121. //get desc
122.                 tSubChnlData.m_desc = _JsonGetTUString(pArrayItem, "desc");
123.                 aSubChnlList.push_back(tSubChnlData);
124.             }
125.         }
126.     }
127. }
128. /** 獲取指定的cJSON物件的指定屬性值
129. *
130. * \param pJsonItem cJSON物件指標
131. * \param pszKey cJSON物件屬性
132. *
133. * \return 返回JSON物件的值，以TUChar字串形式返回
134. */
135. TUChar* TChannelsData::_JsonGetTUString(cJSON* pJsonItem, char* pszKey)
136. {
137.     TUChar* pszValue = NULL;
138.     Int32 nLen;
139.     cJSON* pJsonTemp = NULL;
140.     pJsonTemp = cJSON_GetObjectItem(pJsonItem, pszKey);
141. if (pJsonTemp)
142.     {
143.         nLen = strlen(pJsonTemp->valuestring) + 1;
144.         pszValue = new TUChar[nLen];
145. if(pszValue)
146.         {
147.             MemSet(pszValue, 0, nLen * sizeof(TUChar));
148.             TUString::StrUtf8ToStrUnicode(pszValue, (const Char*)pJsonTemp->valuestring);
149.         }
150.     }
151. return pszValue;
152. }
153. /** 獲取指定的cJSON物件的指定屬性值
154. *
155. * \param pJsonItem cJSON物件指標
156. * \param pszKey cJSON物件屬性
157. *
158. * \return 返回JSON物件的值，以char字串形式返回
159. */
160. char* TChannelsData::_JsonGetString(cJSON* pJsonItem, char* pszKey)
161. {
162. char* pszValue = NULL;
163.     Int32 nLen;
164.     cJSON* pJsonTemp = NULL;
165.     pJsonTemp = cJSON_GetObjectItem(pJsonItem, pszKey);
166. if (pJsonTemp)
167.     {
168.         nLen = strlen(pJsonTemp->valuestring) + 1;
169.         pszValue = newchar[nLen];
170. if(pszValue)
171.         {
172.             MemSet(pszValue, 0, nLen);
173.             strncpy(pszValue, pJsonTemp->valuestring, nLen - 1);
174.         }
175.     }
176. return pszValue;
177. }
178. /** 獲取指定的cJSON物件的指定屬性值
179. *
180. * \param pJsonItem cJSON物件指標
181. * \param pszKey cJSON物件屬性
182. *
183. * \return 返回JSON物件的值，以int32形式返回
184. */
185. Int32 TChannelsData::_JsonGetInt(cJSON* pJsonItem, char* pszKey)
186. {
187.     Int32 nValue = 0;
188.     cJSON* pJsonTemp = NULL;
189.     pJsonTemp = cJSON_GetObjectItem(pJsonItem, pszKey);
190. if (pJsonTemp)
191.     {
192.         nValue = pJsonTemp->valueint;
193.     }
194. return nValue;
195. }
196. /** 獲取指定的cJSON物件的指定屬性值
197. *
198. * \param pJsonItem cJSON物件指標
199. * \param pszKey cJSON物件屬性
200. *
201. * \return 返回JSON物件的值，以Boolean形式返回
202. */
203. Boolean TChannelsData::_JsonGetBoolean(cJSON* pJsonItem, char* pszKey)
204. {
205.     Boolean bValue = FALSE;
206.     cJSON* pJsonTemp = NULL;
207.     pJsonTemp = cJSON_GetObjectItem(pJsonItem, pszKey);
208. if (pJsonTemp)
209.     {
210. if(pJsonTemp->valueint)
211.         {
212.             bValue = TRUE;
213.         }
214.     }
215. return bValue;
216. }

總結：

JSON的結構簡約，所以使得JSON的文件的資料量比較小，比較適合用於網路資料的交換，而且對JSON文件的解析和資料提取的方法也很簡單，方便程式設計師的使用，當然也正是因為JSON的結構簡約，使得JSON的可讀性與可編輯性會稍差於XML，所以JSON比較適合在較少有人工閱讀和編輯的情況下使用期。