简单封装cJSON方便使用

最新推荐文章于 2021-11-22 10:16:20 发布
置顶 最新推荐文章于 2021-11-22 10:16:20 发布
阅读量419 收藏 1
点赞数
分类专栏： Json cJSON C++ 文章标签： Json cJSON c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kenzhang1031/article/details/112506658
版权
Json 同时被 3 个专栏收录
1 篇文章 0 订阅
订阅专栏
cJSON
1 篇文章 0 订阅
订阅专栏
C++
1 篇文章 0 订阅
订阅专栏

文章目录

一、简介

一直使用cJSON来操作Json，感觉接口使用没那么方便。因为之前用过libconfig这个库，这个库使用很方便，于是萌生了封装一下的念头，封装成使用习惯和libconfig类似的。

封装过程不说了，增加了3个类Tree、Node、CException，都放到命名空间JsonTree中。

二、封装后使用方法

封装后可以很方便的操作增删改查了！

直接上使用的代码：

/* JsonTree解析Json，修改后更新Json
* 使用下面的Json字符串测试
{
	"node1": {
		"key1": null,
		"key2": "string1",
		"key3": [12, 34, 56, 78],
		"key4": [123, 456, 789],
		"sub1": {
			"key1": 94,
			"key2": "string2",
			"key3": [99, 88, 77, 66, 55, 44],
			"key4": [{
				"aaa": 111,
				"aaa2": "cow",
				"aaa3": ["a", "b", "c"]
			}, {
				"bbb": 222
			}, {
				"ccc": 333
			}, {
				"ddd": 444
			}],
			"sub1": {
				"key5": "Hello"
			}
		}
	}
}
*/

using namespace JsonTree;

static void JsonTreeDemo()
{
	std::string str = "{\n"
		"	\"node1\": {\n"
		"		\"key1\": null,\n"
		"		\"key2\": \"string1\",\n"
		"		\"key3\": [12, 34, 56, 78],\n"
		"		\"key4\": [123, 456, 789],\n"
		"		\"sub1\": {\n"
		"			\"key1\": 94,\n"
		"			\"key2\": \"string2\",\n"
		"			\"key3\": [99, 88, 77, 66, 55, 44],\n"
		"			\"key4\": [{\n"
		"				\"aaa\": 111,\n"
		"				\"aaa2\": \"cow\",\n"
		"				\"aaa3\": [\"a\", \"b\", \"c\"]\n"
		"			}, {\n"
		"				\"bbb\": 222\n"
		"			}, {\n"
		"				\"ccc\": 333\n"
		"			}, {\n"
		"				\"ddd\": 444\n"
		"			}],\n"
		"			\"sub1\": {\n"
		"				\"key5\": \"Hello\"\n"
		"			}\n"
		"		}\n"
		"	}\n"
		"}";

	try {
		// 通过Json转成Tree，可以方便的读取每项的值
		Tree tree(str);
		if (tree.IsValid())
		{
			Node& root = tree.Root();

			// 读取node1的keys,值是string1
			std::string strVal1 = root["node1"]["key2"];    // string1

			// 读取node1的sub1里面的key2
			std::string strVal2 = root["node1"]["sub1"]["key2"];  // string2

			// 数组访问
			// 比如读取node1->sub1->key4->aaa3, key4是数组, aaa3也是数组, aaa3是在数组key4的[0]中的，注意写法
			// 这个写法错误，会引发异常“NodeNoExistException: 'root.node1.sub1.key4.aaa3'  does not exist!”
			// std::string strVal3 = root["node1"]["sub1"]["key4"]["aaa3"][0];   
			// 正确写法
			std::string strVal3 = root["node1"]["sub1"]["key4"][0]["aaa3"][0];   // "a"
			std::string strVal4 = root["node1"]["sub1"]["key4"][0]["aaa3"][1];   // "b"
			std::string strVal5 = root["node1"]["sub1"]["key4"][0]["aaa3"][2];   // "c"
			// 支持数组长度
			size_t size = root["node1"]["sub1"]["key4"][0]["aaa3"].Lengeh();		// 3

			// 读取整个数组，比如：node1->key3
			size = root["node1"]["key3"].Lengeh();      // 先读取长度
			// 读取数组所有值
			for (size_t i = 0; i < size; ++i)
			{
				int nVal = root["node1"]["key3"][i];    // 分别是12，34，56，78
				std::cout << nVal << std::endl;
			}

			// Tree可以转换回Json对像，再使用cJSON_Print转回字符串
			// cJSON_Parse解析str, 再使用cJSON_Print转回字符串
			// 比较这两个字符串是相等的，确认Tree转回的Json也是正确的
			cJSON* refJson = tree.ToCJson();
			cJSON* json_root = cJSON_Parse(str.c_str());
			if (strcmp(cJSON_Print(refJson), cJSON_Print(json_root)) == 0)
			{
				std::cout << "Test Tree OK" << std::endl;
			}
			else
			{
				std::cout << "Test Tree error" << std::endl;
			}
			cJSON_Delete(json_root);

			// Tree可以删除某个项，比如删除node1->sub1->key3
			// 两种写法
			// 写法1
			Node& node1 = root["node1"]["sub1"];
			node1.remove_son("key3");
			// 写法2，比如删除node1->sub1->key2
			root["node1"]["sub1"]["key2"].remove();

			// 删除数组的某项，比如node1->key4是数组[123, 456, 789], 删除数组下标是[1]的456
			root["node1"]["key4"].remove_son(1);

			// 修改值，比如node1->sub1->key1值94,改成字符串值"I am a test"
			root["node1"]["sub1"]["key1"] = "I am a test";

			// 修改数组值，比如node1->key4是数组,上面删除456之后，是[123, 789]，把123改成987
			root["node1"]["key4"][0] = 987;

			// 可以增加项，比如增加node1->here, 值是okok
			root["node1"].add_son("here");
			root["node1"]["here"] = "okok";

			// 打印出来看看结果是不是和希望的一样，打印还是转回Json，使用cJSON_Print转字符串打印
			refJson = tree.ToCJson();
			std::cout << "**************** new Json string *****************" << std::endl;
			std::cout << cJSON_Print(refJson) << std::endl;
			//printf("%s\n", cJSON_Print(refJson));

			// 析构函数会自动释放资源，这里的Tree是局部变量，函数返回后会自动析构
		}
	}
	catch (std::exception& e) {			// 可以捕捉异常
		std::cerr << e.what() << std::endl;
	}
}

最后结果：

12
34
56
78
Test Tree OK
**************** new Json string *****************
{
        "node1":        {
                "key1": null,
                "key2": "string1",
                "key3": [12, 34, 56, 78],
                "key4": [987, 789],
                "sub1": {
                        "key1": "I am a test",
                        "key4": [{
                                        "aaa":  111,
                                        "aaa2": "cow",
                                        "aaa3": ["a", "b", "c"]
                                }, {
                                        "bbb":  222
                                }, {
                                        "ccc":  333
                                }, {
                                        "ddd":  444
                                }],
                        "sub1": {
                                "key5": "Hello"
                        }
                },
                "here": "okok"
        }
}

从例子中发现，接口使用比原来使用简单容易了，使用上接近libconfig。

这个简单封装用法，在实际项目中使用了一段比较长的时间了(本文是vs2019使用写的，但是在海思的ARM平台使用较长时间了，也能用于Linux平台的)，常见的Json暂未发现问题。

三、速度对比

后来，因为要在服务器中使用Json，因为服务器高并发，需要考虑速度因素，几经查找，看到号称速度很快的RapidJson，然后了解了一下接口的用法，还是觉得接口比较难使用，和cJSON差不多，而且有人说某些情况下会有内存泄漏，所以放弃了。

之后查到有[JSON for Modern C++，nlohmann写的json，这个接口非常的好用，是用过的最好用的，用法上和自己封装之后的用法类似，但是是大牛写的，肯定更符合标准化，使用上更放心，于是打算测试一下cJSON、JSON for Modern C++、自己封装的JsonTree三者的速度，可以肯定Json在cJSON上封装的，速度肯定是慢于cJSON，如果JSON for Modern C++速度优于或者接近cJSON，那就可以放心使用了。

测试方式是跑10万个Json字符串解析，读取出里面每个key的值，测试执行时间，因为仿造10万个Json比较困难，只是测试速度，所以用一个统一的Json字符串，按照每次Json都不同的流程那样的执行来测试。

测试代码如下：

/*
* 以下Json，解释10万次，分别测试测试cJSON、JsonTree、Json for Modern C++所用时间
{
	"name": "server",
	"id": 123456,
	"sql_ip": "192.168.1.100",
	"database": "shops",
	"user": "root",
	"pwd": "user@test.com",
	"param1": 111,
	"param2": 222,
	"param3": "333",
	"array": [{
		"ip": "192.168.1.200",
		"port": 7000
	}, {
		"ip": "192.168.1.200",
		"port": 7000
	}, {
		"ip": "192.168.1.200",
		"port": 7000
	}]
}
*/

typedef struct
{
	std::string ip;
	int port;
}Network;

// 测试cJSON的时间
static void TestcJSON()
{
	clock_t start_time = clock();
	for (int i = 0; i < 100000; ++i)   // 10万次
	{
		std::string str = "{\n"
			"	\"name\": \"server\",\n"
			"	\"id\": 123456,\n"
			"	\"sql_ip\": \"192.168.1.100\",\n"
			"	\"database\": \"shops\",\n"
			"	\"user\": \"root\",\n"
			"	\"pwd\": \"user@test.com\",\n"
			"	\"param1\": 111,\n"
			"	\"param2\": 222,\n"
			"	\"param3\": \"333\",\n"
			"	\"array\": [{\n"
			"		\"ip\": \"192.168.1.200\",\n"
			"		\"port\": 7000\n"
			"	}, {\n"
			"		\"ip\": \"192.168.1.200\",\n"
			"		\"port\": 7001\n"
			"	}, {\n"
			"		\"ip\": \"192.168.1.200\",\n"
			"		\"port\": 7002\n"
			"	}]\n"
			"}";

		std::string name;
		int id;
		std::string sql_ip;
		std::string database;
		std::string user;
		std::string pwd;
		int param1 = 0;
		int param2 = 0;
		std::string param3;
		std::vector<Network> vecNetwork;
		cJSON * json_root = cJSON_Parse(str.c_str());
		if (json_root != NULL)
		{
			name = cJSON_GetObjectItem(json_root, "name")->valuestring;
			id = cJSON_GetObjectItem(json_root, "id")->valueint;
			sql_ip = cJSON_GetObjectItem(json_root, "sql_ip")->valuestring;
			database = cJSON_GetObjectItem(json_root, "database")->valuestring;
			user = cJSON_GetObjectItem(json_root, "user")->valuestring;
			pwd = cJSON_GetObjectItem(json_root, "pwd")->valuestring;
			param1 = cJSON_GetObjectItem(json_root, "param1")->valueint;
			param2 = cJSON_GetObjectItem(json_root, "param2")->valueint;
			param3 = cJSON_GetObjectItem(json_root, "param3")->valuestring;

			cJSON* json_arry = cJSON_GetObjectItem(json_root, "array");
			if (json_arry != NULL)
			{
				cJSON* json_child = json_arry->child;
				while (json_child != NULL) {
					std::string strip = cJSON_GetObjectItem(json_child, "ip")->valuestring;
					int port = cJSON_GetObjectItem(json_child, "port")->valueint;
					vecNetwork.push_back({ strip, port });
					json_child = json_child->next;
				}
			}
		}
		cJSON_Delete(json_root);
	}
	clock_t end_time = clock();
	std::cout << "cJSON Running time is: " << static_cast<double>(end_time - start_time) / CLOCKS_PER_SEC * 1000 << "ms" << std::endl;
}

// 测试JsonTree的时间
using namespace JsonTree;
static void TestJsonTree()
{
	clock_t start_time = clock();
	for (int i = 0; i < 100000; ++i)
	{
		std::string str = "{\n"
			"	\"name\": \"server\",\n"
			"	\"id\": 123456,\n"
			"	\"sql_ip\": \"192.168.1.100\",\n"
			"	\"database\": \"shops\",\n"
			"	\"user\": \"root\",\n"
			"	\"pwd\": \"user@test.com\",\n"
			"	\"param1\": 111,\n"
			"	\"param2\": 222,\n"
			"	\"param3\": \"333\",\n"
			"	\"array\": [{\n"
			"		\"ip\": \"192.168.1.200\",\n"
			"		\"port\": 7000\n"
			"	}, {\n"
			"		\"ip\": \"192.168.1.200\",\n"
			"		\"port\": 7001\n"
			"	}, {\n"
			"		\"ip\": \"192.168.1.200\",\n"
			"		\"port\": 7002\n"
			"	}]\n"
			"}";

		JsonTree::Tree tree(str);
		if (tree.IsValid())
		{
			JsonTree::Node& root = tree.Root();
			std::string name = root["name"];
			int id = root["id"];
			std::string sql_ip = root["sql_ip"];
			std::string database = root["database"];
			std::string user = root["user"];
			std::string pwd = root["pwd"];
			int param1 = root["param1"];
			int param2 = root["param2"];
			std::string param3 = root["param3"];
			size_t len = root["array"].Lengeh();
			std::vector<Network> vecNetwork;
			for (size_t j = 0; j < len; ++j)
			{
				std::string strip = root["array"][j]["ip"];
				int port = root["array"][j]["port"];
				vecNetwork.push_back({ strip, port });
			}
		}
	}
	clock_t end_time = clock();
	std::cout << "JsonTree Running time is: " << static_cast<double>(end_time - start_time) / CLOCKS_PER_SEC * 1000 << "ms" << std::endl;
}

// 测试nlohmann Json 的时间
#include "nlohmann/json.hpp"   // 要使用nlohmann json 必须把文件夹nlohmann放到工程，以及包含里面的头文件json.hpp

using json = nlohmann::json;

static void TestNlohmannJson()
{
	clock_t start_time = clock();
	for (int i = 0; i < 100000; ++i)
	{
		json root = R"(
			{
				"name": "server",
				"id": 123456,
				"sql_ip": "192.168.1.100",
				"database": "shops",
				"user": "root",
				"pwd": "user@test.com",
				"param1": 111,
				"param2": 222,
				"param3": "333",
				"array": [{
					"ip": "192.168.1.200",
					"port": 7000
				}, {
					"ip": "192.168.1.200",
					"port": 7001
				}, {
					"ip": "192.168.1.200",
					"port": 7002
				}]
			}		
		)"_json;

		std::string name = root["name"];
		int id = root["id"];
		std::string sql_ip = root["sql_ip"];
		std::string database = root["database"];
		std::string user = root["user"];
		std::string pwd = root["pwd"];
		int param1 = root["param1"];
		int param2 = root["param2"];
		std::string param3 = root["param3"];
		size_t len = root["array"].size();
		std::vector<Network> vecNetwork;
		for (size_t j = 0; j < len; ++j)
		{
			std::string strip = root["array"][j]["ip"];
			int port = root["array"][j]["port"];
			vecNetwork.push_back({ strip, port });
		}
	}
	clock_t end_time = clock();
	std::cout << "NlohmannJson Running time is: " << static_cast<double>(end_time - start_time) / CLOCKS_PER_SEC * 1000 << "ms" << std::endl;
}


static void TestSpeed()
{
	TestcJSON();
	TestJsonTree();
	TestNlohmannJson();

	/* 为了表示测试和调用顺序无关，顺序反过来再测试1次 */
	TestNlohmannJson();
	TestJsonTree();
	TestcJSON();
}

测试两次，第2次把测试顺序反过来。每个测试都是10万次。

结果是：

cJSON Running time is: 4317ms
JsonTree Running time is: 29087ms
NlohmannJson Running time is: 54067ms
NlohmannJson Running time is: 54109ms
JsonTree Running time is: 29295ms
cJSON Running time is: 4008ms

可见JSON for Modern C++的接口使用最好，JsonTree用法和它比较相似。

然而，封装的代价是巨大的，cJSON只用4秒多点，封装之后29秒多点，时间多了约7倍，JSON for Modern C++最慢，54秒多点，是cJSON的12倍多，是JsonTree的1.8倍左右。

高并发服务器，最后我只能选择cJSON，毕竟速度还是最重要的。

如果哪位程序员朋友有又好用又快速的程序，请给我介绍。最后附上整个源程序项目供有兴趣的朋友下载。

四、源码下载

源码下载，VS2019编译测试通过。

Mr. Code
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于linux C实现的JSon源代码封装
08-15
C语言实现的Json封装，通用性好，占用资源少，速度快，可靠性高，经过实际项目使用考验。
Json数据解析和生成（C/C++， 使用CJson）
生命在于折腾
06-17 5616
由于工作需要，需要对Json数据进行解析。查阅了很多资料，发现相比于boost和jsoncpp，CJson更加小巧好用，不需要太多的准备工作，只需要把CJson.c和CJson.h导入工程，即可使用。 CJson源代码和示例工程可在此处下载 CJson源码和示例1 使用CJson解析Json数据如果要解析以下的Json数据：{ "programmers": [{ "fir
cJSON_Delete调用时segmentfault
sliver.chen的博客
01-20 6925
cJSON_Delete cJSON_Delete释放cJSON构造object时申请的内存资源 通常用法 cJSON *json = cJSON_CreateObject(); ... ... cJSON_Delete(json); 调用cJSON_Delete时产生segmentfault 错误段代码: cJSON *json = cJSON_
推荐下cJSON的高级封装版本CJsonObject，真的很好用
HW140701的博客
02-02 6369
1 CJsonObject简介 CJsonObject是Bwar基于cJSON全新开发一个C++版的JSON库，CJsonObject的最大优势是轻量、简单好用，开发效率极高，尤其对多层嵌套json的读取和生成、修改极为方便。CJsonObject比cJSON简单易用得多，且只要不是有意不释放内存就不会发生内存泄漏。用CJsonObject的好处在于完全不用专门的文档，头文件即文档，看完Demo...
linux 编写c语言程序需要cjson库,arm-linux下交叉编译json-c-0.9库遇到的编译问题
weixin_39992199的博客
05-01 482
原标题：arm-linux下交叉编译json-c-0.9库遇到的编译问题在linux下比较成熟的json库要属json-c-0.9. 但是悲剧的是好多人编译不通过。编译json-c 版本 貌似可以顺利通过， 但是链接json-c动态库的时候会有提示: undefined reference to rpl_malloc[我的环境]虚拟机：vmware 7.1.3操作系统：ubuntu8.04-gcc...
arm交叉编译opencv 3.4.12 , log4cpp , cJSON
yxpandjay的博客
11-02 384
终端输入以下命令 cmake-gui 弹出以下界面 : 说明： Where is the source code对应opencv的文件夹， Where to build the binaries对应opencv存放编译好的配置文件等信息的文件夹（比如刚创建的build文件夹） -------------------------------------------------------------------------------------------- 点击Configur.
cjson的封装与解析
qq_44991159的博客
04-15 908
文章目录一、cJSON1.JSON格式的封装2.JSON格式的解析3.示例 一、cJSON JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写，同时也易于机器解析和生成。它基于JavaScript（Standard ECMA-262 3rd Edition - December 1999）的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl
cplus cjson 封装
HongDaYu的搬砖之路
11-22 427
内核开发中,大多是面向对象的思想 本来想仿照内核,抽象出一个驱动加载初始化,用C++ 实现,后来发现,底层逻辑还是有点乱, 读写二级制部分，设备树部分,使用json 文本替代, 分析节点描述使用,但是这个封装,还勉强可用，传参，分析都已解决.platform gpio char dev 这个的逻辑关系还得在顺一下 #include "cJSON.h" #include "cJSON_Utils.h" #include <iostream> #include <string> #.
CJSON的封装API
weixin_30791095的博客
05-06 163
为了更方便使用C的JSON库，对其进行了一层封装。 H文件： 1 #ifndef __JSONHELPER__ 2 #define __JSONHELPER__ 3 4 #ifdef __cplusplus 5 extern "C" 6 { 7 #endif 8 9 10 #define JSON_NAME_MAX_SIZE 128 11 ...
cJSON的数据封装
BFDX0017的博客
06-03 613
一、示例程序如下 /*cJSON封装：{} 对象, []数组 包含，被包含的关系 */ cJSON *obj = cJSON_CreateObject(); cJSON *subObj = cJSON_CreateObject(); cJSON_AddItemToObject(subObj, "factory", cJSON_CreateString("一汽大众")); cJSON_AddItemToObject(subObj...
C实现对JSON的封装，对json格式解析，封装等.
11-05
C实现对JSON的封装，对json格式解析，封装等.
cJSON类，C++封装对JSON格式字符串的操作，解析，组合字符串.zip
11-19
封装cJSON类，C++封装对JSON格式字符串的操作，解析，组合字符串
linux c语言封装的json使用
01-29
linux下的json格式数据打包与解析，可用于网络交互，比较容易上手。
cJSON源代码，轻巧方便，用于封装通信包非常合适
07-01
cJSON源代码，轻巧方便，用于封装通信包非常合适
json封装解析cjson
04-15
json的创建和是解析，是c语言的开源代码（cJSON），存储学习用的。关于cJSON网上资料太多，去下载还不用积分……
JsonTree: 进一步封装cJSON
01-11
封装cJSON成接口好用的JsonTree，包含了cJSON、JsonTree、Nlohman Json比较测试的代码。如果不使用Nlohman，可以删除这个目录。
cJSON简单使用例子
03-24
cJSON简单使用例子
cJSON_Transferto_cjson库使用_源码
10-04
cjson库文件的使用，方便c将数据以json格式传递，web前端解析json格式数据
STM32学习笔记之Cjson的使用
01-06
1、解析JSONJ结构得到cjson对象：cJSON * root=cJSON_Parse(char *buf); 2、获取无格式的json对象：cJSON_PrintUnformatted(cJSON *item) 3、根据键值获取对应的值：cJSON *cJSON_GetObjectItem(cJSON *object,const...
cjson 频繁使用malloc
最新发布
05-28
如果在使用cJSON库的过程中频繁地使用动态内存分配函数（如malloc()）来分配内存，则有可能导致内存碎片化的问题。因为频繁地进行内存分配和释放操作会导致内存块的大小不一，从而产生内存碎片。 为了避免这个问题...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值