devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

c环境下Json字符串的解析_cjson 解析 long

作者：2023面试高手 | 2024-03-20 11:02:02

赞

踩

cjson 解析 long

c环境下Json字符串的解析

对于Json字符串，最常见的方式就是一个一个的键值对被一个大的Obect包裹着，但是往往由于实际项目需要json字符串不可能保持最简单的形式来进行数据传输。

以最近一个小项目为例：

从手机客户端组织数据，形成Json字符串的主要形式有如下几种：

1. char *xjson = "[{\"TotalNum\":123},{\"Tvstate\":2},{\"ProgrameId\":014000789},{\"request\":1004}]";

2.char *xjson = "{\"TotalNum\":\"123\",\"name\":\"mao\",\"request\":1004}";

3.char *xjson = "{\"ToIndex\":\"99\",\"FromIndex\":\"0\",\"request\":\"0\"}";

4.char *xjson = "{\"array\":[{\"TotalNum\": 123,\"Tvstate\": \"2\"}],\"request\": 44}";

5.char *xjson = "{\"array\":[{\"TotalNum\": 123},{\"Tvstate\": \"2\"}],\"request\": \"44\"}";

6.char *xjson = "{\"TvSate\":0,\"FavMark\":64,\"FavGroupId\":\"\",\"array\":[{\"ProgrameId\": \"4334\"},{\"ProgrameId\":4334}],\"TotalNum\":3,\"request\":1004}";

7.char *xjson =  "{\"array\":[{\"data\":\"M040\"},{\"uuid\":\"860806027379485-38:BC:1A:87:E0:26\"}],\"request\":\"998\"}";

8.char *xjson = "{\"request\":1004}";

需要在机顶盒端接收到手机客户端发送过来的json字符串数据，并且将其解析出来存放到各自对应的已经实现定义好的结构体中。

大致的过程就是：

APK -------发送Json字符串给------>服务器端------解析json字符串到------>C结构体

那么具体的需求就是：

在服务器端的解析函数必须能够适配解析不同的json字符串。在不知道每一个json字符串的键值对的情况下，取出该json字符串的键值，存放在c结构体中，并且将这些结构体以链表的形式存放在内存中。

在c语言环境下有一个开源的cJSON库，其中封装好了一些列对json数据进行操作的函数。

cJSON结构体定义如下：

typedefstruct cJSON {

structcJSON *next,*prev;

struct cJSON *child;

int type;

char * valuestring;

int valueint;

double valuedouble;

char *string;

}cJSON;

其中type取值共有7中，分别是：

#define cJSON_False 0

#define cJSON_True 1

#define cJSON_NULL 2

#define cJSON_Number 3

#define cJSON_String 4

#define cJSON_Array 5

#define cJSON_Object 6

考虑到我们在客户端组织起来的json字符串主要由Number、String、Array、Object组成，因此采用多重嵌套swicth进行解析。当然也可以使用递归进行解析，但是由于递归在项目开发中特别是嵌入式开发中一般不建议使用，所以这次并没有采用递归的方法进行解析。

具体的解析代码

其中涉及到的主要函数为：

解析的入口函数:parse_cjson_to_json_root（）

解析子json结构体为Array的函数：parse_json_sub_type_array();

解析子json结构体为Object的函数：parse_json_sub_type_object();

解析子json结构体为Number和String的函数：parse_json_sub_type_others();


主要代码如下：

  1. <pre name="code" class="html">#include <stdio.h>
  2. #include <string.h>
  3. #include "usifext.h"
  4. #include "json_parser.h"
  5. #include "cJSON.h"
  6. #include "gs_os.h"
  7.  
  8. void parse_json_sub_type_others(cJSON** psub, json_node_info** tag_node, json_root_info** proot_node, json_node_info** tag_point,
  9.         json_attr_info** tag_attr_node, int type)
  10. {
  11.  
  12. 	int text_int = 0;
  13. 	char *text_string = "";
  14.  
  15. 	(*tag_node) = (json_node_info *)malloc(sizeof(json_node_info));
  16. 	memset((*tag_node)->tag_name, 0, sizeof((*tag_node)->tag_name));
  17. 	memset((*tag_node)->tag_text, 0, sizeof((*tag_node)->tag_text));
  18.  
  19. 	char *tag = (*psub)->string;
  20.  
  21. 	if (cJSON_Number == type)
  22. 	{
  23. 		text_int = (*psub)->valueint;
  24. 	}
  25. 	else
  26. 	{
  27. 		text_string = (*psub)->valuestring;
  28. 	}
  29.  
  30. 	if (strcmp(tag, JSON_HEADER_CONTROL_TAG) != 0)
  31. 	{
  32. 		strcpy((*tag_node)->tag_name, tag);
  33. 		if (cJSON_Number == type)
  34. 		{
  35. 			ITOA((*tag_node)->tag_text, text_int);
  36. 		}
  37. 		else
  38. 		{
  39. 			strcpy((*tag_node)->tag_text, text_string);
  40. 		}
  41. 		(*tag_node)->next = NULL;
  42.  
  43. 		if ((*proot_node)->next == NULL)
  44. 		{
  45. 			(*proot_node)->next = (*tag_node);
  46. 			(*tag_point) = (*tag_node);
  47. 		}
  48. 		else
  49. 		{
  50. 			(*tag_point)->next = (*tag_node);
  51. 			(*tag_point) = (*tag_node);
  52. 		}
  53. 	}
  54. 	else
  55. 	{
  56. 		(*tag_attr_node) = (json_attr_info*)malloc(sizeof(json_attr_info));
  57. 		memset((*tag_attr_node)->name, 0, sizeof((*tag_attr_node)->name));
  58. 		memset((*tag_attr_node)->value, 0, sizeof((*tag_attr_node)->value));
  59. 		strcpy((*tag_attr_node)->name, tag);
  60.  
  61. 		if (cJSON_Number == type)
  62. 		{
  63. 			ITOA((*tag_attr_node)->value, text_int);
  64. 		}
  65. 		else
  66. 		{
  67. 			strcpy((*tag_attr_node)->value, text_string);
  68. 		}
  69. 		(*proot_node)->attr_list = (*tag_attr_node);
  70.  
  71. 	}
  72.  
  73. }
  74.  
  75. void parse_json_sub_type_array(cJSON** psub, json_node_info** tag_node, json_root_info** proot_node, json_node_info** tag_point,
  76.         json_attr_info** tag_attr_node)
  77. {
  78.  
  79. 	int j = 0;
  80. 	for (j = 0; j < cJSON_GetArraySize((*psub)); j++)
  81. 	{
  82. 		cJSON *psub_sub = cJSON_GetArrayItem((*psub), j);
  83.  
  84. 		if (psub_sub->type == cJSON_Object)
  85. 		{
  86. 			parse_json_sub_type_obj(&psub_sub, tag_node, proot_node, tag_point, tag_attr_node);
  87. 		}
  88. 	}
  89.  
  90. }
  91.  
  92. void parse_json_sub_type_obj(cJSON** psub, json_node_info** tag_node, json_root_info** proot_node, json_node_info** tag_point,
  93.         json_attr_info** tag_attr_node)
  94. {
  95.  
  96. 	int j = 0;
  97. 	for (j = 0; j < cJSON_GetArraySize((*psub)); j++)
  98. 	{
  99. 		cJSON *psub_sub = cJSON_GetArrayItem((*psub), j);
  100. 		parse_json_sub_type_others(&psub_sub, tag_node, proot_node, tag_point, tag_attr_node, psub_sub->type);
  101. 	}
  102.  
  103. }
  104.  
  105. int parse_cjson_to_json_root(cJSON *pjson, json_root_info *proot_node)
  106. {
  107. 	int i = 0;
  108. 	int size = 0;
  109.  
  110. 	json_node_info* tag_node;
  111. 	json_attr_info* tag_attr_node;
  112. 	json_node_info* tag_point = NULL;
  113.  
  114. 	if (NULL == proot_node)
  115. 	{
  116. 		return -1;
  117. 	}
  118.  
  119. 	if (NULL == pjson)
  120. 	{
  121. 		return -1;
  122. 	}
  123.  
  124. 	(proot_node)->next = NULL;
  125. 	size = cJSON_GetArraySize(pjson);
  126. 	for (i = 0; i < size; i++)
  127. 	{
  128. 		cJSON *psub = cJSON_GetArrayItem(pjson, i);
  129. 		switch (psub->type)
  130. 		{
  131. 			case cJSON_Array:
  132. 				parse_json_sub_type_array(&psub, &tag_node, &proot_node, &tag_point, &tag_attr_node);
  133. 				break;
  134. 			case cJSON_Object:
  135. 				parse_json_sub_type_obj(&psub, &tag_node, &proot_node, &tag_point, &tag_attr_node);
  136. 				break;
  137. 			case cJSON_String:
  138. 			case cJSON_Number:
  139. 				parse_json_sub_type_others(&psub, &tag_node, &proot_node, &tag_point, &tag_attr_node, psub->type);
  140. 				break;
  141. 			default:
  142. 				return -1;
  143. 		}
  144.  
  145. 	}
  146. 	return 0;
  147. }
其中涉及到一些自定义的函数， ITOA、GSOS_MALLOC(). 

 

  1. int ITOA(char * str, unsigned long val)
  2. {
  3. 	char *p;
  4. 	char *first_dig;
  5. <span style="white-space:pre">	</span>char temp;
  6. unsigned t_val;
  7. int len = 0;
  8. p = str;
  9. first_dig = p;
  10.  
  11.  
  12. do
  13. {
  14. t_val = (unsigned)(val % 0x0a);
  15. val   /= 0x0a;
  16. *p++ = (char)(t_val + '0');
  17. len++;
  18. }
  19. while (val > 0);
  20. *p-- = '\0';
  21. do
  22. {
  23. temp = *p;
  24. *p   = *first_dig;
  25. *first_dig = temp;
  26. --p;
  27. ++first_dig;
  28. }
  29. while (first_dig < p);
  30. return len;
  31. }
  32.  
 

</pre><pre name="code" class="html">采用递归的方式更加简单，主要函数和代码如下：
 

  1. int parse_json(cJSON * pJson,xml_root_info *proot_node)
  2. {
  3.     xml_node_info* tag_node;
  4. xml_attr_info* tag_attr_node;
  5. xml_node_info* tag_point = NULL;
  6.  
  7.  
  8.     tag_node = (xml_node_info *) malloc(sizeof(xml_node_info));
  9.     memset(tag_node->tag_name,0,sizeof(tag_node->tag_name));
  10.     memset(tag_node->tag_text,0,sizeof(tag_node->tag_text));
  11.  
  12.  
  13.     tag_attr_node = (xml_attr_info*) malloc(sizeof(xml_attr_info));
  14.     memset(tag_attr_node->name,0,sizeof(tag_attr_node->name));
  15.     memset(tag_attr_node->value,0,sizeof(tag_attr_node->value));
  16.  
  17.  
  18.     tag_point = (xml_node_info *) malloc(sizeof(xml_node_info));
  19.  
  20.     if(NULL == pJson)
  21.     {
  22.         return -1;
  23.     }
  24.     printf(" pJson->type :%d\n", pJson->type);
  25.     switch(pJson->type)
  26.     {
  27.         case cJSON_False :
  28.             {
  29.                 char *value_string = pJson->string;
  30.                 int value_int = pJson->valueint;
  31.                 strcpy(tag_node->tag_name, value_string);
  32.  
  33.  
  34.                 //ITOA(tag_attr_node->value, value_int);
  35.             }
  36.             break;
  37.         case cJSON_True :
  38.             {
  39.                 char *value_string = pJson->string;
  40.                 int value_int = pJson->valueint;
  41.                 strcpy(tag_node->tag_name, value_string);
  42.                 //ITOA(tag_attr_node->value, value_int);
  43.             }
  44.             break;
  45.         case cJSON_NULL :
  46.             {
  47.                 printf("%s : NULL\n", pJson->string);
  48.             }
  49.             break;
  50.         case cJSON_Number :
  51.             {
  52.                 char *value_string = pJson->string;
  53.                 int value_int = pJson->valueint;
  54.  
  55.  
  56.                 if(strcmp(value_string, "request") != 0)
  57.                 {
  58. strcpy(tag_node->tag_name, value_string);
  59. itoa(value_int, tag_node->tag_text, 10);
  60. tag_node->next = NULL;
  61. if(count == 0)
  62. {
  63. proot_node->next = tag_node;
  64. tag_point = tag_node;
  65. count++;
  66. }
  67. else
  68. {
  69. tag_point = (proot_node)->next;
  70. while(NULL != tag_point->next)
  71. {
  72. printf("up循环遍历里面\n");
  73. tag_point = tag_point->next;
  74. printf("down循环遍历里面\n");
  75.  }
  76. tag_point->next = tag_node;
  77. tag_point = tag_node;
  78. }
  79.                 }
  80.                 else
  81.                 {
  82. strcpy(tag_attr_node->name, value_string);
  83. itoa(value_int, tag_attr_node->value, 10);
  84. proot_node->attr_list = tag_attr_node;
  85. //proot_node->next=NULL;
  86.                 }
  87.             }
  88.             break;
  89.         case cJSON_String :
  90.             {
  91.                 char *value_string = pJson->string;
  92.                 char *pJsonString = pJson->valuestring;
  93.                 if(strcmp(value_string, "request") != 0)
  94.                 {
  95. strcpy(tag_node->tag_name, value_string);
  96. strcpy(tag_node->tag_text, pJsonString);
  97. tag_node->next = NULL;
  98.  if(count == 0)
  99. {
  100. proot_node->next = tag_node;
  101. tag_point = tag_node;
  102. count++;
  103. printf("count_01:%d\n", count);
  104. }
  105. else
  106. {
  107. tag_point = (proot_node)->next;
  108. while(NULL != tag_point->next)
  109. {
  110. printf("up循环遍历里面\n");
  111. tag_point = tag_point->next;
  112. printf("down循环遍历里面\n");
  113.  }
  114. tag_point->next = tag_node;
  115. tag_point = tag_node;
  116. }
  117.                 }
  118.                 else
  119.                 {
  120. strcpy(tag_attr_node->name, value_string);
  121. strcpy(tag_attr_node->value, pJsonString);
  122.  
  123.  
  124. proot_node->attr_list = tag_attr_node;
  125.                 }
  126.             }
  127.             break;
  128.         case cJSON_Array  :
  129.         case cJSON_Object :
  130.             {
  131.                 int iSize = cJSON_GetArraySize(pJson);
  132.                 int i = 0;
  133.                 printf("%s\n", NULL == pJson->string ? "" : pJson->string);
  134.                 for(i = 0; i < iSize; i++)
  135.                 {
  136.                     cJSON * pSub = cJSON_GetArrayItem(pJson, i);
  137.                     parse_json(pSub, proot_node);
  138.                 }
  139.             }
  140.             break;
  141.         default :
  142.             return -1;
  143.             break;
  144.     }
  145. }
 

 

 


                

        
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/272838
推荐阅读
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。