随着现代应用程序的发展，JSON（JavaScript Object Notation）成为了前后端通信中非常常用的数据交换格式。JSON 以其轻量级、可读性强的特点广泛用于 RESTful API 以及 Web 服务的通信。对于复杂的数据结构，JSON 能够通过对象嵌套和数组嵌套来表示。在 Qt 中，我们可以使用 QJsonObject、QJsonArray 和 QJsonDocument 来构建和解析多层嵌套的 JSON 数据。本文将详细介绍如何在 Qt 中处理这些复杂的 JSON 结构。
一. 如何解析多层嵌套的 JSON 数据
当从服务器获取复杂的 JSON 数据时，可能会遇到多层嵌套的结构。假设服务器返回如下的嵌套 JSON 数据：
{
"student": {
"name": "John",
"age": 21,
"sex": "Male",
"address": {
"city": "New York",
"zip": "10001"
}
},
"class": "Physics"
}
这种 JSON 数据包含一个 student 对象，而 student 对象内部又嵌套了一个 address 对象。为了解析这样的 JSON 数据，我们需要递归地提取每一层的对象和字段。
解析多层 JSON 的代码示例
cpp
#include <QCoreApplication>
#include <QJsonObject>
#include <QJsonDocument>
#include <QJsonArray>
#include <QDebug>
int main(int argc, char *argv[]) {
QCoreApplication a(argc, argv);
// 模拟一个多层的 JSON 响应
QByteArray jsonResponse = R"({
"student": {
"name": "John",
"age": 21,
"sex": "Male",
"address": {
"city": "New York",
"zip": "10001"
}
},
"class": "Physics"
})";
// 解析 JSON 文档
QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonResponse);
if (jsonDoc.isObject()) {
QJsonObject rootObject = jsonDoc.object();
// 获取 'student' 对象
if (rootObject.contains("student") && rootObject["student"].isObject()) {
QJsonObject studentObject = rootObject["student"].toObject();
// 提取 'name' 字段
if (studentObject.contains("name") && studentObject["name"].isString()) {
QString name = studentObject["name"].toString();
qDebug() << "Student Name:" << name;
}
// 提取 'age' 字段
if (studentObject.contains("age") && studentObject["age"].isDouble()) {
int age = studentObject["age"].toInt();
qDebug() << "Student Age:" << age;
}
// 提取 'sex' 字段
if (studentObject.contains("sex") && studentObject["sex"].isString()) {
QString sex = studentObject["sex"].toString();
qDebug() << "Student Sex:" << sex;
}
// 提取嵌套的 'address' 对象
if (studentObject.contains("address") && studentObject["address"].isObject()) {
QJsonObject addressObject = studentObject["address"].toObject();
if (addressObject.contains("city") && addressObject["city"].isString()) {
QString city = addressObject["city"].toString();
qDebug() << "City:" << city;
}
if (addressObject.contains("zip") && addressObject["zip"].isString()) {
QString zip = addressObject["zip"].toString();
qDebug() << "ZIP Code:" << zip;
}
}
}
// 获取根级字段 'class'
if (rootObject.contains("class") && rootObject["class"].isString()) {
QString className = rootObject["class"].toString();
qDebug() << "Class:" << className;
}
}
return a.exec();
}解析步骤说明：
- 加载 JSON 文档 ：使用
QJsonDocument::fromJson()将 JSON 数据转换为QJsonDocument。 - 判断 JSON 类型 ：检查
QJsonDocument是否是对象类型，通过jsonDoc.object()提取根对象。 - 递归解析对象 ：对嵌套的对象逐层解析，如提取
student对象中的name、age等字段。 - 解析嵌套对象 ：通过
studentObject["address"].toObject()获取嵌套的address对象，然后进一步提取其中的字段。 - 解析顶层字段 ：提取
class这样的根级字段与嵌套对象的解析方法类似。
二. 如何构建多层嵌套的 JSON 数据
构建多层嵌套的 JSON 数据与解析类似，通过 QJsonObject 和 QJsonArray 可以轻松构建复杂的 JSON 结构。例如，我们构建一个嵌套的 JSON，如下所示：
cpp
{
"student": {
"name": "John",
"age": 21,
"sex": "Male",
"address": {
"city": "New York",
"zip": "10001"
}
},
"class": "Physics"
}构建多层嵌套 JSON 的代码示例
cpp
#include <QCoreApplication>
#include <QJsonObject>
#include <QJsonDocument>
#include <QDebug>
int main(int argc, char *argv[]) {
QCoreApplication a(argc, argv);
// 创建最里面的 address 对象
QJsonObject addressObject;
addressObject["city"] = "New York";
addressObject["zip"] = "10001";
// 创建 student 对象，并包含 name、age、sex 以及 address
QJsonObject studentObject;
studentObject["name"] = "John";
studentObject["age"] = 21;
studentObject["sex"] = "Male";
studentObject["address"] = addressObject; // 嵌套的 address 对象
// 创建根对象，并包含 student 对象和 class 字段
QJsonObject rootObject;
rootObject["student"] = studentObject;
rootObject["class"] = "Physics";
// 将 JSON 对象转换为 QJsonDocument
QJsonDocument jsonDoc(rootObject);
// 输出 JSON 字符串
QByteArray jsonData = jsonDoc.toJson();
qDebug() << jsonData;
return a.exec();
}构建步骤说明：
- 创建嵌套对象 ：首先创建最内层的
address对象，然后将其嵌入到student对象中。 - 创建中间对象 ：在
studentObject中添加name、age、sex字段，并嵌入addressObject。 - 创建根对象 ：将
studentObject和class添加到根对象rootObject中。 - 转换为 JSON 字符串 ：通过
QJsonDocument::toJson()将构建好的 JSON 对象序列化为字符串或QByteArray。
三. 构建包含数组的多层 JSON 数据
有时，JSON 结构可能包含数组。你可以使用 QJsonArray 来表示 JSON 数组。例如，构建一个包含多个学生的 JSON 数据，每个学生都有一个嵌套的 address 对象：
cpp
{
"class": "Physics",
"students": [
{
"name": "John",
"age": 21,
"sex": "Male",
"address": {
"city": "New York",
"zip": "10001"
}
},
{
"name": "Alice",
"age": 22,
"sex": "Female",
"address": {
"city": "Los Angeles",
"zip": "90001"
}
}
]
}构建包含数组的 JSON 的代码示例
cpp
#include <QCoreApplication>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>
#include <QDebug>
int main(int argc, char *argv[]) {
QCoreApplication a(argc, argv);
// 创建第一个学生的 address 对象
QJsonObject addressObject1;
addressObject1["city"] = "New York";
addressObject1["zip"] = "10001";
// 创建第一个 student 对象
QJsonObject studentObject1;
studentObject1["name"] = "John";
studentObject1["age"] = 21;
studentObject1["sex"] = "Male";
studentObject1["address"] = addressObject1;
// 创建第二个学生的 address 对象
QJsonObject addressObject2;
addressObject2["city"] = "Los Angeles";
addressObject2["zip"] = "90001";
// 创建第二个 student 对象
QJsonObject studentObject2;
studentObject2["name"] = "Alice";
studentObject2["age"] = 22;
studentObject2["sex"] = "Female";
studentObject2["address"] = addressObject2;
// 创建 students 数组
QJsonArray studentsArray;
studentsArray.append(studentObject1);
studentsArray.append(studentObject2);
// 创建根对象
QJsonObject rootObject;
rootObject["class"] = "Physics";
rootObject["students"] = studentsArray;
// 输出 JSON 字符串
QJsonDocument jsonDoc(rootObject);
QByteArray jsonData = jsonDoc.toJson();
qDebug() << jsonData;
return a.exec();
}构建步骤说明：
- 创建多个对象 ：为每个学生创建一个
studentObject，并嵌入对应的addressObject。 - 创建数组 ：使用
QJsonArray存储多个studentObject。 - 将数组嵌入根对象 ：将
studentsArray嵌入到rootObject中，构建完整的 JSON 数据。
总结
Qt 提供了强大的 JSON 解析与构建工具，通过 QJsonObject、QJsonArray 和 QJsonDocument，你可以轻松处理复杂的嵌套 JSON 结构。无论是从服务器获取多层嵌套的 JSON 数据并进行解析，还是构建复杂的 JSON 数据并发送给服务器，Qt 都能很好地支持这一流程。
- 解析 JSON ：通过递归访问
QJsonObject，逐层提取数据，确保类型匹配以避免错误。 - 构建 JSON ：通过嵌套对象和数组来构建复杂的 JSON 结构，将其序列化为
QByteArray或字符串以用于通信或存储。
使用 Qt 处理 JSON 数据，你可以方便地与 RESTful API 和 Web 服务进行交互，实现现代应用程序所需的复杂数据操作。