现在的位置: 首页 > 综合 > 正文

JSON格式解析和libjson使用简介(cJSON)

2014年09月05日 ⁄ 综合 ⁄ 共 10652字 ⁄ 字号 小 中 大 ⁄ 评论关闭
JSON格式解析和libjson使用简介
摘 要：
Rss Reader实例开发中，进行网络数据交换时主要使用到了两种数据格式：JSON与XML。本文主要介绍JSON格式的简单概念及JSON在Rss Reader中的应用。

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.  
  4.     root:{
  5.         version:"201007091640",
  6.         channels:[
  7.         {
  8.             name:"新闻中心",
  9.             subchnls:[
  10.             {
  11.                 title:"焦点新闻",
  12.                 link:"http://news.mtc.sohu.com/news/channel/1/news.rss",
  13.                 desc:"家事、国事、天下事"
  14.             },
  15.             {
  16.                 title:"新闻频道",
  17.                 link:"http://news.mtc.sohu.com/news/channel/2/news.rss",
  18.                 desc:"让您实时掌握国际动态"
  19.             },
  20.             {
  21.                 title:"军事频道",
  22.                 link:"http://news.mtc.sohu.com/news/channel/3/news.rss",
  23.                 desc:"军事"
  24.             }
  25.             ]
  26.         },
  27.         
  28.         {
  29.             name:"体育新闻",
  30.             subchnls:[
  31.             {
  32.                 title:"体育要闻汇总",
  33.                 link:"http://news.mtc.sohu.com/news/channel/4/news.rss",
  34.                 desc:"erewr"
  35.             },
  36.             {
  37.                 title:"国际足坛",
  38.                 link:"http://news.mtc.sohu.com/news/channel/5/news.rss",
  39.                 desc:"werewr"
  40.             }
  41.             ]
  42.         }
  43.         
  44.         ]
  45.     }
  46. }

这段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.  
  10.     char *string;
    // 当前项的名称，也就是key-value键值对的key
  11. } 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.  
  9.     TUChar * m_title;
  10.     char * m_link;
  11.     TUChar * m_desc;
  12. };
  13.  
  14. /** 大频道信息结构体
  15. *
  16. */
  17. struct CHANNEL_DATA
  18. {
  19.     CHANNEL_DATA();
  20.  
  21.     TUChar* m_pszTitle;
  22.     vector m_aSubChnlList;
  23. };
  24.  
  25. //………….
  26. // TChannelsData 类成员变量：RSSReaderConfig 版本号
  27. char m_pszVersion[32];
  28. // TChannelsData 类成员变量：频道信息列表
  29. vector m_aChnlsList;
  30. //………….

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.  
  12.     objJson= cJSON_Parse(pszJsonText);
  13.  
  14.     if (objJson)
  15.     {
  16.         //out=cJSON_Print(objJson);
  17.         cJSON* objRootItem = NULL;
  18.  
  19.         //判断是否需要更新
  20.         objRootItem = cJSON_GetObjectItem(objJson, "result");
  21.         if (objRootItem)
  22.         {
  23.             if (!objRootItem->valueint)
  24.             {
  25.                 return FALSE;
  26.             }
  27.         }
  28.         else
  29.         {
  30.             return FALSE;
  31.         }
  32.  
  33.         //获取更新数据，根节点root
  34.         objRootItem = cJSON_GetObjectItem(objJson, "root");
  35.         if (objRootItem)
  36.         {
  37.             cJSON* objJsonItem = NULL;
  38.  
  39.             //获取版本号
  40.             objJsonItem = cJSON_GetObjectItem(objRootItem, "version");
  41.             if (objJsonItem)
  42.             {
  43.                 Int32 nLen = strlen(objJsonItem->valuestring);
  44.                 strncpy(m_pszVersion, objJsonItem->valuestring, (nLen < 32)? nLen : 31);
  45.             }
  46.  
  47.             //解析出大频道
  48.             _ParseChannels(objRootItem);
  49.         }
  50.         
  51.         //SS_printf("=======[parse json]%s\n",out);
  52.         cJSON_Delete(objJson);
  53.         //free(out);
  54.     }
  55.  
  56.     return TRUE;
  57. }
  58.  
  59. /** 解析出大频道
  60. *
  61. * \param pCJson cJSON对象指针
  62. *
  63. * \return void
  64. */
  65. void TChannelsData::_ParseChannels(cJSON* pCJson)
  66. {
  67.     cJSON* pJsonArray = NULL;
  68.  
  69.     if (!pCJson)
  70.     {
  71.         return;
  72.     }
  73.  
  74.     pJsonArray = cJSON_GetObjectItem(pCJson, "channels");
  75.     if(pJsonArray)
  76.     {
  77.         cJSON* pArrayItem = NULL;
  78.         cJSON* pJsonTemp = NULL;
  79.  
  80.         Int32 nSize = cJSON_GetArraySize(pJsonArray);
  81.         for (Int32 i = 0; i < nSize; i++)
  82.         {
  83.             pArrayItem = cJSON_GetArrayItem(pJsonArray, i);
  84.             if (pArrayItem)
  85.             {
  86.                 CHANNEL_DATA tChannelData;
  87.                 Int32 nLen = 0;
  88.  
  89.                 //获取大频道名称
  90.                 tChannelData.m_pszTitle = _JsonGetTUString(pArrayItem,
    "name");
  91.                 
  92.                 //解析出子频道
  93.                 _ParseSubChnls(tChannelData.m_aSubChnlList, pArrayItem);
  94.  
  95.                 //将大频道信息对象压入列表中
  96.                 m_aChnlsList.push_back(tChannelData);
  97.             }
  98.             else
  99.             {
  100.                 continue;
  101.             }
  102.         }
  103.     }
  104. }
  105.  
  106. /** 解析子频道
  107. *
  108. * \param aSubChnlList 存放子频道数据的vector对象
  109. * \param pCJson cJSON对象指针
  110. *
  111. * \return void
  112. */
  113. void TChannelsData::_ParseSubChnls(vector& aSubChnlList, cJSON* pCJson)
  114. {
  115.     cJSON* pJsonArray = NULL;
  116.  
  117.     if (!pCJson)
  118.     {
  119.         return;
  120.     }
  121.  
  122.     pJsonArray = cJSON_GetObjectItem(pCJson, "subchnls");
  123.     if (pJsonArray)
  124.     {
  125.         cJSON* pArrayItem = NULL;
  126.         //cJSON* pJsonTemp = NULL;
  127.  
  128.         Int32 nSize = cJSON_GetArraySize(pJsonArray);
  129.         for (Int32 i = 0; i < nSize; i++)
  130.         {
  131.             pArrayItem = cJSON_GetArrayItem(pJsonArray, i);
  132.             if (pArrayItem)
  133.             {
  134.                 SUBCHNL_DATA tSubChnlData;
  135.                 Int32 nLen = 0;
  136.  
  137.                 //get title
  138.                 tSubChnlData.m_title = _JsonGetTUString(pArrayItem,
    "title");
  139.  
  140.                 //get link
  141.                 tSubChnlData.m_link = _JsonGetString(pArrayItem,
    "link");
  142.  
  143.                 //get desc
  144.                 tSubChnlData.m_desc = _JsonGetTUString(pArrayItem,
    "desc");
  145.  
  146.                 aSubChnlList.push_back(tSubChnlData);
  147.             }
  148.         }
  149.     }
  150. }
  151.  
  152. /** 获取指定的cJSON对象的指定属性值
  153. *
  154. * \param pJsonItem cJSON对象指针
  155. * \param pszKey cJSON对象属性
  156. *
  157. * \return 返回JSON对象的值，以TUChar字串形式返回
  158. */
  159. TUChar* TChannelsData::_JsonGetTUString(cJSON* pJsonItem,
    char* pszKey)
  160. {
  161.     TUChar* pszValue = NULL;
  162.     Int32 nLen;
  163.     cJSON* pJsonTemp = NULL;
  164.  
  165.     pJsonTemp = cJSON_GetObjectItem(pJsonItem, pszKey);
  166.     if (pJsonTemp)
  167.     {
  168.         nLen = strlen(pJsonTemp->valuestring) + 1;
  169.         pszValue = new TUChar[nLen];
  170.         if(pszValue)
  171.         {
  172.             MemSet(pszValue, 0, nLen * sizeof(TUChar));
  173.             TUString::StrUtf8ToStrUnicode(pszValue, (const Char*)pJsonTemp->valuestring);
  174.         }
  175.     }
  176.  
  177.     return pszValue;
  178. }
  179.  
  180. /** 获取指定的cJSON对象的指定属性值
  181. *
  182. * \param pJsonItem cJSON对象指针
  183. * \param pszKey cJSON对象属性
  184. *
  185. * \return 返回JSON对象的值，以char字串形式返回
  186. */
  187. char* TChannelsData::_JsonGetString(cJSON* pJsonItem,
    char* pszKey)
  188. {
  189.     char* pszValue = NULL;
  190.     Int32 nLen;
  191.     cJSON* pJsonTemp = NULL;
  192.  
  193.     pJsonTemp = cJSON_GetObjectItem(pJsonItem, pszKey);
  194.     if (pJsonTemp)
  195.     {
  196.         nLen = strlen(pJsonTemp->valuestring) + 1;
  197.         pszValue = new char[nLen];
  198.         if(pszValue)
  199.         {
  200.             MemSet(pszValue, 0, nLen);
  201.             strncpy(pszValue, pJsonTemp->valuestring, nLen - 1);
  202.         }
  203.     }
  204.  
  205.     return pszValue;
  206. }
  207.  
  208. /** 获取指定的cJSON对象的指定属性值
  209. *
  210. * \param pJsonItem cJSON对象指针
  211. * \param pszKey cJSON对象属性
  212. *
  213. * \return 返回JSON对象的值，以int32形式返回
  214. */
  215. Int32 TChannelsData::_JsonGetInt(cJSON* pJsonItem, char* pszKey)
  216. {
  217.     Int32 nValue = 0;
  218.     cJSON* pJsonTemp = NULL;
  219.  
  220.     pJsonTemp = cJSON_GetObjectItem(pJsonItem, pszKey);
  221.     if (pJsonTemp)
  222.     {
  223.         nValue = pJsonTemp->valueint;
  224.     }
  225.  
  226.     return nValue;
  227. }
  228.  
  229. /** 获取指定的cJSON对象的指定属性值
  230. *
  231. * \param pJsonItem cJSON对象指针
  232. * \param pszKey cJSON对象属性
  233. *
  234. * \return 返回JSON对象的值，以Boolean形式返回
  235. */
  236. Boolean TChannelsData::_JsonGetBoolean(cJSON* pJsonItem, char* pszKey)
  237. {
  238.     Boolean bValue = FALSE;
  239.     cJSON* pJsonTemp = NULL;
  240.  
  241.     pJsonTemp = cJSON_GetObjectItem(pJsonItem, pszKey);
  242.     if (pJsonTemp)
  243.     {
  244.         if(pJsonTemp->valueint)
  245.         {
  246.             bValue = TRUE;
  247.         }
  248.     }
  249.  
  250.     return bValue;
  251. }

 

总结：

JSON的结构简约，所以使得JSON的文档的数据量比较小，比较适合用于网络数据的交换，而且对JSON文档的解析和数据提取的方法也很简单，方便程序员的使用，当然也正是因为JSON的结构简约，使得JSON的可读性与可编辑性会稍差于XML，所以JSON比较适合在较少有人工阅读和编辑的情况下使用期。

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞