前言
　　从 Qt 5.0 就开始提供处理 Json 数据的操作支持，JSON是一种对源自Javascript的对象数据进行编码的格式，但现在广泛用作互联网上的数据交换格式，Qt中的JSON支持提供了一个易于使用的C++ API来解析，修改和保存JSON数据。

　　Qt中所有的 JSON 类都是基于值的隐式共享类（隐式共享类的意思是只要它没有被修改，它就与创建它的文档共享数据）。常用的相关类为如下表格的前四个：

一，QJsonDocument
QJsonDocument 是一个封装完整JSON文档的类，可以从基于UTF-8编码的文本表示和Qt自己的二进制格式来对该文档进行读写操作。使用 QJsonDocument::fromJson() 可以将JSON文档从基于文本的表示形式转换为 QJsonDocument，使用 QJsonDocument::toJson() 可以将其转换回文本形式。解析器非常快速和有效，并可以使用 QJsonDocument::toBinaryData() 将 JSON 转换为Qt使用的二进制表示。

因为 QJsonObject 和 QJsonArray 这两个对象中的数据是不能直接转换为字符串类型的，如果要进行数据传输或者数据的持久化保存，需要对数据进行序列化和反序列化操作，详细如下

QJsonObject 或者 QJsonArray 序列化为字符串
1. 创建 QJsonDocument 对象

1 QJsonDocument::QJsonDocument(const QJsonObject &object);    //个人常用
2 QJsonDocument::QJsonDocument(const QJsonArray &array);
3 QJsonDocument::QJsonDocument(const QJsonDocument &other);    //几乎不用
4  
5 QJsonDocument::QJsonDocument();    //或者创建一个空对象，使用以下两个方法设置数据
6 QJsonDocument::setArray(const QJsonArray &array);
7 QJsonDocument::setObject(const QJsonObject &object);

2. 将文件对象中的数据进行序列化

1 QByteArray QJsonDocument::toBinaryData() const;    //二进制格式的json字符串     
2 QByteArray QJsonDocument::toJson(JsonFormat format = Indented) const;    //文本格式 个人常用

3. 使用得到的字符串进行数据传输，或者磁盘文件持久化

字符串反序列化为 QJsonObject 或者 QJsonArray

　　1. 将通过网络通信或磁盘文件读取得到的 Json 格式字符串转换为 QJsonDocument 对象

1 QJsonDocument QJsonDocument::fromJson(const QByteArray &json, QJsonParseError *error = Q_NULLPTR);    //个人常用
2 QJsonDocument QJsonDocument::fromBinaryData(const QByteArray &data, DataValidation validation = Validate);
3 QJsonDocument QJsonDocument::fromRawData(const char *data, int size, DataValidation validation = Validate)
4 QJsonDocument QJsonDocument::fromVariant(const QVariant &variant)

　　2. 将文档对象转换为 Json 数组或 Json 对象

1 bool QJsonDocument::isArray() const;    //判断文档对象中存储的数据是不是数组
2 bool QJsonDocument::isObject() const    //判断文档对象中存储的数据是不是json对象
3 QJsonObject QJsonDocument::object() const;    //文档对象中的数据转换为json对象
4 QJsonArray QJsonDocument::array() const;    //文档对象中的数据转换为json数组

　　3.通过调用 QJsonArray , QJsonObject 类提供的 API 读取存储在 QJsonDocument 对象中的数据

二，QJsonArray
　　QJsonArray 封装了 Json 中的数组，数组里面的所有元素统一为 QJsonValue 类型。常用API函数如下，详细参照官方文档：

创建一个 Json 数组

1 QJsonArray::QJsonArray();    //创建一个空数组
2 QJsonArray::QJsonArray(const QJsonArray &other)    //拷贝构造，不常用
3 QJsonArray::QJsonArray(std::initializer_list<QJsonValue> args)    //没用过

添加数据

1 void QJsonArray::append(const QJsonValue &value);        //在数组尾部追加
2 void QJsonArray::insert(int i, const QJsonValue &value); //将value插入到i的位置
3 iterator QJsonArray::insert(iterator before, const QJsonValue &value);  //std 知识
4 void QJsonArray::prepend(const QJsonValue &value);        //将value添加到数组头部
5 void QJsonArray::push_back(const QJsonValue &value);        //将value添加到数组尾部
6 void QJsonArray::push_front(const QJsonValue &value);        //将value添加到数组头部

删除数据

1 iterator QJsonArray::erase(iterator it);    //基于迭代器删除
2 void QJsonArray::pop_back();           //删除尾部
3 void QJsonArray::pop_front();          //删除头部
4 void QJsonArray::removeAt(int i);      //删除i位置的元素
5 void QJsonArray::removeFirst();        //删除头部
6 void QJsonArray::removeLast();         //删除尾部
7 QJsonValue QJsonArray::takeAt(int i);  //删除i位置的原素, 并返回删除的元素的值

获取数组中元素个数

1 int QJsonArray::count() const;
2 int QJsonArray::size() const;

获取数组中的元素值

1 QJsonValue QJsonArray::at(int i) const;    //获取指定i位置的元素
2 QJsonValue QJsonArray::first() const;    //头部元素
3 QJsonValue QJsonArray::last() const;    //尾部元素
4 QJsonValueRef QJsonArray::operator[](int i);    //注意这获取的是指定i位置的元素引用
5 QVariantList QJsonArray::toVariantList() const;

三，QJsonObject

QJsonObject 是键值对的列表，里面可以存储多个键值对，其中键是惟一的字符串，值由QJsonValue 表示。常用API函数如下，详细参照官方文档：

创建一个 Json 对象

1 QJsonObject::QJsonObject();    // 构造空对象
2 QJsonObject::QJsonObject(std::initializer_list<QPair<QString, QJsonValue> > args);
3 QJsonObject::QJsonObject(const QJsonObject &other);

将键值对添加到对象中

iterator QJsonObject::insert(const QString &key, const QJsonValue &value);

删除键值对

1 void QJsonObject::remove(const QString &key);
2 QJsonValue QJsonObject::take(const QString &key);    // 删除并返回key对应的value值

获取对象中键值对个数

1 int QJsonObject::count() const;
2 int QJsonObject::size() const;
3 int QJsonObject::length() const;

通过 key 得到 value

1 QJsonValue QJsonObject::value(const QString &key) const; // utf8格式
2 QJsonValue QJsonObject::value(QLatin1String key) const;    // 字符串不支持中文
3 QJsonValue QJsonObject::operator[](const QString &key) const;
4 QJsonValue QJsonObject::operator[](QLatin1String key) const;

通过 key 查找对象中是否有该键值对

1 iterator QJsonObject::find(const QString &key); //重载类型的接口会根据输入的参数自行选择
2 const_iterator QJsonObject::find(const QString &key) const;
3 bool QJsonObject::contains(const QString &key) const;
4 bool QJsonObject::contains(QLatin1String key) const;

四，QJsonValue

　　QJsonValue 类用JSON封装了一个值，该值在内部是严格类型的，与QVariant相反，它不会尝试进行任何隐式类型转换。这意味着转换为不存储在值中的类型将返回一个默认的构造返回值。值的类型可以是如下六种基本数据类型：

创建一个 QJsonValue 对象

 1 QJsonValue::QJsonValue(const QJsonArray &a); //Json数组
 2 QJsonValue::QJsonValue(const QJsonObject &o); //Json对象
 3 QJsonValue::QJsonValue(const QJsonValue &other); //拷贝构造
 4 QJsonValue::QJsonValue(Type type = Null); //空值类型
 5 QJsonValue::QJsonValue(bool b); //布尔类型
 6 //整型和浮点型
 7 QJsonValue::QJsonValue(double n);
 8 QJsonValue::QJsonValue(int n);
 9 QJsonValue::QJsonValue(qint64 n);
10 //字符串
11 QJsonValue::QJsonValue(const QString &s);
12 QJsonValue::QJsonValue(QLatin1String s);
13 QJsonValue::QJsonValue(const char *s);
14 //将variant转换为QJsonValue并返回
15 [static] QJsonValue QJsonValue::fromVariant(const QVariant &variant);

判断 QJsonValue 对象的内部封装的数据类型

1 bool QJsonValue::isArray() const; //是否是Json数组
2 bool QJsonValue::isObject() const; //是否是Json对象
3 bool QJsonValue::isBool() const; //是否是布尔类型
4 bool QJsonValue::isDouble() const; //是否是浮点类型(整形也是通过该函数判断)
5 bool QJsonValue::isNull() const; //是否是空值类型
6 bool QJsonValue::isString() const; //是否是字符串类型
7 bool QJsonValue::isUndefined() const; //是否是未定义类型(无法识别的类型)

将 QJsonValue 对象转换成内部封装的基础数据类型

 1 QJsonArray QJsonValue::toArray(const QJsonArray &defaultValue) const; //转换为Json数组
 2 QJsonArray QJsonValue::toArray() const;
 3 bool QJsonValue::toBool(bool defaultValue = false) const; //转换为布尔类型
 4 double QJsonValue::toDouble(double defaultValue = 0) const; //转换为浮点类型
 5 int QJsonValue::toInt(int defaultValue = 0) const; //转换为整形
 6 QJsonObject QJsonValue::toObject() const; //转换为Json对象
 7 QJsonObject QJsonValue::toObject(const QJsonObject &defaultValue) const;
 8 QString QJsonValue::toString() const; //转换为字符串类型
 9 QString QJsonValue::toString(const QString &defaultValue) const;

QJsonValue fromVariant(const QVariant &variant); 该静态接口的参数转换规则如下表：

五，案例答疑解惑

1，测试读写的 test.json 文件内容（文件路径 E:\test.json）

 1   {
 2       "FirstName": "Fu",
 3       "LastName": "Cong",
 4       "Age": 24,
 5       "Address": {
 6           "Street": "首创悦榕汇",
 7           "City": "BeiJing",
 8           "Country": "BeiJing"
 9       },
10       "Phone numbers": [
11           "+44 12345",
12           "+44 678910"
13       ]
14   }

2，所需要的头文件

1 #include <QJsonDocument>
2 #include <QJsonArray>
3 #include <QJsonObject>
4 #include <QJsonValue>
5 #include <QFile>
6 #include <QDebug>

3，写 Json 文件接口实现

 1 void writeJson()
 2 {
 3     QJsonObject obj_root;
 4     obj_root.insert("FirstName","Fu");
 5     obj_root.insert("LastName","Cong");
 6     obj_root.insert("Age",24);
 7  
 8     QJsonObject subObj_addr;
 9     subObj_addr.insert("Street","首创悦榕汇");
10     subObj_addr.insert("City","BeiJing");
11     subObj_addr.insert("Country","BeiJing");
12  
13     obj_root.insert("Address",subObj_addr);
14  
15     QJsonArray arr_phone;
16     arr_phone.append("+44 12345");
17     arr_phone.append("+44 678910");
18  
19     obj_root.insert("Phone numbers",arr_phone);
20  
21     QJsonDocument jsonDocu(obj_root);
22     QByteArray jsonData = jsonDocu.toJson();
23  
24     QFile file("E:\\test.json");
25     if(file.open(QIODevice::WriteOnly)){
26         file.write(jsonData);
27         file.close();
28     }
29 }

效果图如下

4，读 Json 文件接口实现

 1 void readJson()
 2 {
 3     QFile file("E:\\test.json");
 4     QByteArray jsonData;
 5     if(file.open(QIODevice::ReadOnly)){
 6         jsonData = file.readAll();
 7         file.close();
 8     }
 9  
10     QJsonDocument jsonDocu = QJsonDocument::fromJson(jsonData);
11  
12     if(jsonDocu.isObject()){
13         QJsonObject obj_root = jsonDocu.object();
14         QStringList keys = obj_root.keys();
15         for(auto key : keys){
16             QJsonValue value = obj_root.value(key);
17             if(value.isString()){
18                 qDebug() << key <<": "<< value.toString();
19             }else if(value.isDouble()){
20                 qDebug() << key <<": "<< value.toInt();
21             }else if(value.isArray()){
22                 QJsonArray arr = value.toArray();
23                 for(int i = 0; i < arr.count(); ++i){
24                     if(arr.at(i).isString()){
25                         qDebug() << key <<": "<< arr.at(i).toString();
26                     }
27                     //这里就不判断是否为其它类型了，因为测试文件已知为字符串，要写也和上面类似，无限套娃
28                 }
29             }else if(value.isObject()){
30                 QJsonObject subObj = value.toObject();
31                 QStringList subKeys = subObj.keys();
32                 for(auto subKey : subKeys){
33                     QJsonValue subValue = subObj.value(subKey);
34                     if(subValue.isString()){
35                         qDebug() << subKey <<": "<< subValue.toString();
36                     }
37                     //这里就不判断是否为其它类型了，因为测试文件已知为字符串，要写也和上面类似，无限套娃
38                 }
39             }
40         }
41     }
42 }

效果图如下

posted on 2023-03-28 13:39 一杯清酒邀明月阅读(2003) 评论(0) 编辑收藏举报