Linux网络：序列化与反序列化
序列化与反序列化
在网络通信中，最重要的就是通过接口，将数据通过网络发送给另一台主机。那么另一台主机收到数据后，就可以对数据进行处理了。
但是网络通信中，数据不是简单的将所有的数据堆砌在一起，然后一起发送出去。相反的，数据应该以特定的形式组织起来，才能让接收方进行合理的解析。
比如以下数据：
你好2024.10.21cool boy
这是一个叫做cool boy的用户，在2024.10.21发送了一条"你好"的消息。对于人来说，这是很好理解的，但是对于计算机来说，这就很难处理了。比如说它也可以被解析为用户名是"你好"的用户发送了一条叫做cool boy的消息。用户名、时间、消息内容，这三个字段的分界符在哪里？如何区分这三个区域？
对于UDP来说，一个消息放在一个报文中一起发送。但是对于TCP来说，它是面向字节流的，那么就可以能出现多个消息的粘包问题：
你好2024.10.21cool boy我是一个程序员2024.10.21cool boy
比如收到这样一条TCP字节流消息，计算机又要如何区分两个报文的边界？
你会发现，简单的把数据堆在一起，这个数据就会难以解析。因此要把数据按照一定的规律合理组织在一起，并且约定好各个字段的含义，如果是TCP通信，还需要约定好一条消息的定界符，避免粘包问题。这种行为称为序列化。而从组织好的数据中还原出目标信息，称为反序列化。
当前流行的序列化协议：
- JSON
- XML
- 二进制格式
其中json全称JavaScript Object Notation，即JavaScript 对象 表示法，顾名思义它是由JavaScript提出的一种序列化规范，这是一种文本形式的协议，以字符串的形式存储与解析数据。
比如刚才的消息可以表示为：
{
"message": "你好",
"time": "2024.10.21",
"name": "cool boy"
}
这样整个消息就被分为了三个部分，并且每个字段都以键值对的形式表示。这样就可以很明确的表示"你好"是一条消息，而cool boy是用户名。而整条报文的最外层，有一个{}，这就可以起到TCP的定界符的作用。
除去json还有很多数据序列化格式，比如二进制格式可以使用protobuf等。接下来博客讲解json的序列化格式，以及它的C++接口。
json
json可以保存标量类型，数组，对象三种形式的数据，规则如下：
- 数据以键值对
key: value的形式存储 - 多条数据使用
,隔开 key的类型必须是字符串value的类型可以是标量类型，数组，对象- 数组用
[]表示 - 对象用
{}表示
对于整个json消息，它可以是数组或对象。
数组形式：
[
"hello",
"world",
true,
3.14
]
对象形式：
{
"name": "cool boy",
"age": 12,
"adult": false
}
首先，数组内部的数据，不需要以键值对的形式存储，而数组最外侧使用[]表示。在数组中，可以存储任何形式的数据，比如true是布尔类型，3.14是浮点型。
而在对象形式中，每个字段都要以key:value的形式存储，最外侧使用{}，对象中也可以存储任意标量类型。
另外的，数组与对象之间，还可以进行嵌套：
[
{
"name": "张三",
"age": 12,
"adult": false
},
{
"name": "李四",
"age": 20,
"adult": true
}
]
比如这是一个数组，内部有两个对象，这就是数组内嵌套对象。
{
"name": "张三",
"age": 12,
"friend": [
"李四",
"王五",
"赵六"
]
}
这是一个对象，在对象中，friend存储的是一个数组，数组内又存储了多个字符串。
想要处理json数据，还是比较麻烦的，比如说要考虑括号匹配问题，数据类型的转化问题。但是不用担心，目前的主流语言，都要专门支持json格式的库，其中C++可以使用jsoncpp库完成数据的序列化与反序列化。
jsoncpp
在Linux中，下载jsoncpp非常简单，以Ubuntu为例：
sudo apt install libjsoncpp-dev
执行完指令，就可以使用该库了，只需包含头文件：
#include <jsoncpp/json/json.h>
Value对象
jsoncpp的所有操作，都基于Json::Value类，该类用于保存一个json格式的对象。
基于C++的操作符重载特性，Json::Value类实现了operator[]，完成对元素的增删改，函数声明如下：
Value& operator[](const char* key);
Value& operator[](const String& key);
这两个接口，是对json对象的操作，[]内放key值，而key必须是一个字符串，此处支持char*和std::string两者格式的字符串。
与std::map用法一致，如果[]内的值存在，那么就返回该值，如果不存在，就添加该值：
Json::Value root;
root["name"] = "张三";
root["age"] = 12;
std::cout << root["age"] << std::endl;
以上代码中，创建了一个json对象root，并设置了“name”和"age"属性，最后又获取并输出"gae"。
如果Json::Value存储的是一个json数组，那么使用以下两个接口：
Value& operator[](ArrayIndex index);
Value& operator[](int index);
这两个接口根据下标index返回元素的引用，下标从0开始。
如果存储了json数组，那么就不能通过operator[key] = value的形式插入值了，因为数组不需要key值，此时使用以下接口：
void append(const Json::Value& value);
只需要append(value)即可在数组尾插一个元素。
Json::Value root;
root.append("张三");
root.append("李四");
root.append("王五");
root.append("赵六");
std::cout << root[2] << std::endl;
以上代码，往数组中插入了四个值，并输出下标为2的元素。
- 类型转化
如果仔细观察，你会发现上面所有接口，操作的都是Json::Value，比如append(const Json::Value& value)。
其实Json::Value可以转化为绝大部分的标量类型：
Json::Value& operator=(bool value);
Json::Value& operator=(int value);
Json::Value& operator=(unsigned int value);
Json::Value& operator=(Int64 value);
Json::Value& operator=(UInt64 value);
Json::Value& operator=(double value);
Json::Value& operator=(const char* value);
Json::Value& operator=(const std::string value);
也就是说之前的所有接口，其实Json::Value这个参数可以表达所有的标量类型，因此不论是数组的appent还是对象的operator[]，都可以插入任意标量类型的数据，这些标量数据最后会转化为Json::Value。
- 数组和对象操作
再补充一些数组和对象的通用接口：
size_t size();
bool empty();
void clear();
size：返回数组或对象中元素数量empty：检查数组或对象是否为空clear：清空数组或对象的所有元素
序列化反序列化
了解如何往Json::Value中填写数据后，接下来就要考虑如何进行序列化与反序列化了。
Writer
jsoncpp通过Json::Writer类进行序列化操作，但是该类是一个抽象类，无法实例化出对象。它有两个派生类StyledWriter和FastWriter，这两个类的对象完成具体的序列化操作。
在Json::Writer类中，有一个writer函数，声明如下：
virtual String write(const Value& root) = 0;
这是最核心的序列化函数，= 0表示这个函数由子类重写，也就是StyledWriter和FastWriter对这两个函数进行了重写。
函数输入一个Json::Value对象，随后会把这个对象进行序列化，将序列化好的数据作为返回值。
构造并序列化以下json：
[
"hello",
"world",
12,
false,
[
"abc",
"def"
],
{
"gender": "boy",
"age": 12
}
]
这是一个数组，内部包含了六个元素，其中第五个元素是另一个数组，第六个元素是一个对象。
构造对象：
Json::Value root;
root.append("hello");
root.append("world");
root.append(12);
root.append(false);
Json::Value arr;
arr.append("abc");
arr.append("def");
root.append(arr);
Json::Value obj;
obj["gender"] = "boy";
obj["age"] = 12;
root.append(obj);
对于前四个标量数据，直接通过append添加到root结尾即可。而对于嵌套的数组和对象，要创建另一个Json::Value，先进行数据填充，在添加到root结尾。
序列化：
Json::StyledWriter swriter;
std::string style = swriter.write(root);
std::cout << "StyledWriter:" << std::endl;
std::cout << style << std::endl;
Json::FastWriter fwriter;
std::string fast = fwriter.write(root);
std::cout << "FastWriter:" << std::endl;
std::cout << fast << std::endl;
此处的序列化分别实验了StyledWriter 和FastWriter，它们都可以完成序列化。通过write(root)接口完成序列化后，将序列化的结果输出，结果：
StyledWriter:
[
"hello",
"world",
12,
false,
[ "abc", "def" ],
{
"age" : 12,
"gender" : "boy"
}
]
FastWriter:
["hello","world",12,false,["abc","def"],{"age":12,"gender":"boy"}]
可以看出，其实两种序列化形式的数据内容是一样的，区别在于格式：
StyledWriter：会给json数据添加换行格式，让数据更加可视化FastWriter：去除所有的换行格式，整个json就是一行数据
在实际中，选用哪一种都可以，两者区别其实不大。
现在将以上对象序列化到test.json文件中：
Json::StyledWriter swriter;
std::string str = swriter.write(root);
std::ofstream ofs("test.json");
ofs << str;
ofs.close();
使用std::string接收到write返回值后，直接通过文件流对象输出到文件即可。
Reader
当需要反序列化数据时，就要用到Json::Reader类，核心反序列化函数如下：
bool parse(const std::string& document, Value& root,
bool collectComments = true);
bool parse(IStream& is, Value& root, bool collectComments = true);
与Writer不同，Reader可以直接使用，无需使用它的派生类。不论是通过StyledWriter 还是FastWriter序列化的数据，Reader都可以直接反序列化。
第一个函数接收一个std::string和一个Json::Value root对象的引用，parse直接反序列化字符串内的数据给root对象，第三个参数不用管，默认为true即可。
第二个函数则是通过文件流IStream& is读取数据，然后反序列化到root中。
当拿到一个未知的Json::Value，又要如何解析？这就要用到is和as系列的接口：
bool isNull() const; // 检查值是否为为空
bool isBool() const; // 检查是否为布尔类型
bool isInt() const; // 检查是否为整型
bool isInt64() const; // 检查是否为64位整型
bool isUInt() const; // 检查是否为无符号整型
bool isUInt64() const; // 检查是否为64位无符号整型
bool isIntegral() const; // 检查是否为整数或者可转化为整数的浮点数
bool isDouble() const; // 检查是否为浮点数
bool isNumeric() const; // 检查是否为数字，整数或浮点数
bool isString() const; // 检查是否为字符串
bool isArray() const; // 检查是否为数组
bool isObject() const; // 检查是否为对象
由于拿到Json::Value后，无法确定内部的值是对象，数组，还是一些标量。因此提供了以上is系列接口，来检测数据类型，防止出现接收数据时，类型不匹配导致的错误。
const char* asCString() const;
String asString() const;
Int asInt() const;
UInt asUInt() const;
Int64 asInt64() const;
UInt64 asUInt64() const;
float asFloat() const;
double asDouble() const;
bool asBool() const;
当确定了类型后，就可以通过以上的as系列接口，直接把Json::Value转化为对应的标量类型，进行后续操作。
而对于数组可能不知道它有多少个元素，可以通过size接口获取下标范围。而对于对象，可能不知道他有哪些key，此时可以通过以下接口：
Members getMemberNames() const;
如果Json::Value内部存储的是对象，该函数用于获取一个Json::Value的所有key，并存储在Json::Value::Members中，Json::Value::Members是一个数组，可以直接通过下标访问。
对象常用以下格式解析：
Json::Value::Members keys = root.getMemberNames();
for (int j = 0; j < keys.size(); j++)
{
Json::Value item = root[keys[j]]
// 解析item
}
确定root是一个对象后，先root.getMemberNames()拿到所有的key。随后通过一个循环遍历所有的key，root[keys[j]]就是对象root的一个成员，随后在对该对象做解析操作即可。
由于不论是标量类型，还是数组或者对象，都是使用Json::Value表示的，所以常用递归的形式来解析：
void print(Json::Value root)
{
if (root.isInt())
std::cout << root.asInt() << std::endl;
else if (root.isBool())
std::cout << root.asBool() << std::endl;
else if (root.isString())
std::cout << root.asString() << std::endl;
else if (root.isArray())
{
std::cout << "[" << std::endl;
for (int i = 0; i < root.size(); i++)
print(root[i]);
std::cout << "]" << std::endl;
}
else if (root.isObject())
{
std::cout << "{" << std::endl;
Json::Value::Members keys = root.getMemberNames();
for (int j = 0; j < keys.size(); j++)
{
std::cout << keys[j] << ": ";
print(root[keys[j]]);
}
std::cout << "}" << std::endl;
}
}
当该函数接收到一个Json::Value root后，先判断他是不是基本的标量类型，如果是标量类型，那么直接输出即可。
如果是数组，那么for (int i = 0; i < root.size(); i++)遍历它的所有下标，每个元素root[i]有可能是标量，嵌套数组，嵌套对象。但是没关系，这些类型都被统一为了Json::Value，直接递归print(root[i])。
对象同理，先通过 root.getMemberNames()拿到所有的key，所有root[keys[j]]就是对象内的元素，这个元素同样有可能是标量，嵌套数组，嵌套对象，它们被统一为了Json::Value，直接递归print(root[keys[j]])。
以递归形式读取刚才的test.json：
void print(Json::Value root)
{
if (root.isInt())
std::cout << root.asInt() << std::endl;
else if (root.isBool())
std::cout << root.asBool() << std::endl;
else if (root.isString())
std::cout << root.asString() << std::endl;
else if (root.isArray())
{
std::cout << "[" << std::endl;
for (int i = 0; i < root.size(); i++)
print(root[i]);
std::cout << "]" << std::endl;
}
else if (root.isObject())
{
std::cout << "{" << std::endl;
Json::Value::Members keys = root.getMemberNames();
for (int j = 0; j < keys.size(); j++)
{
std::cout << keys[j] << ": ";
print(root[keys[j]]);
}
std::cout << "}" << std::endl;
}
}
int main()
{
std::ifstream ifs("test.json");
Json::Reader re;
Json::Value root;
re.parse(ifs, root);
print(root);
return 0;
}
在main函数中，打开文件流ifs("test.json")，随后re.parse(ifs, root)直接从文件流中读取数据，解析到root对象中，最后通过print函数递归输出该数据。
输出结果：
[
hello
world
12
0
[
abc
def
]
{
age: 12
gender: boy
}
]
这个结果没有控制缩进，所有格式有点丑。
标签：const,网络,Value,Json,数组,Linux,序列化,root From： https://blog.csdn.net/fsdfafsdsd/article/details/143099867