QT中组装和解析JSON报文

与Json相关的类：

• QJsonObject
• QJsonArray
• QJsonValue
• QJsonDocument

QJsonValue：

封装Json支持的6种数据类型，分别为：

# 布尔类型
QJsonValue::Bool

# 浮点类型（包括整形）
QJsonValue::Double

# 字符串类型
QJsonValue::String

# Json数组类型
QJsonValue::Array

# Json对象类型
QJsonValue::Object

# 空值类型
QJsonValue::Null

 以下构造可以得到对应的QJsonvalue

// 字符串
QJsonValue(const char *s);
QJsonValue(QLatin1String s);
QJsonValue(const QString &s);

// 整形 and 浮点型
QJsonValue(qint64 v);
QJsonValue(int v);
QJsonValue(double v);

// 布尔类型
QJsonValue(bool b);

// Json对象
QJsonValue(const QJsonObject &o);

// Json数组
QJsonValue(const QJsonArray &a);

// 空值类型
QJsonValue(QJsonValue::Type type = Null);

 判断QJsonValue内部持有的数据类型

// 是否是字符串类型
bool isString() const;

// 是否是浮点类型(整形也是通过该函数判断)
bool isDouble() const;

// 是否是布尔类型
bool isBool() const;

// 是否是Json对象
bool isObject() const;

// 是否是Json数组
bool isArray() const;

// 是否是未定义类型(无法识别的类型)
bool isUndefined() const;

// 是否是空值类型
bool isNull() const;

 判断其类型之后，就可以转换成对应的类型

// 转换为字符串类型
QString toString() const;
QString toString(const QString &defaultValue) const;

// 转换为浮点类型
double toDouble(double defaultValue = 0) const;
// 转换为整形
int toInt(int defaultValue = 0) const;

// 转换为布尔类型
bool toBool(bool defaultValue = false) const;

// 转换为Json对象
QJsonObject toObject(const QJsonObject &defaultValue) const;
QJsonObject toObject() const;

// 转换为Json数组
QJsonArray toArray(const QJsonArray &defaultValue) const;
QJsonArray toArray() const;

QJsonObject：

对应Json数据中的对象

可以存储多个键值对

创建一个QJsonObject对象（通过构造函数）

QJsonObject::QJsonObject();

添加键值对

（value可以是QJsonObject、QJsonArray、int、bool、QString等，会隐式类型转换）

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

获取里面键值对的个数

int QJsonObject::count() const;
int QJsonObject::size() const;
int QJsonObject::length() const;

 通过key获取value

QJsonValue QJsonObject::value(const QString &key) const;
//建议用下标运算符，易读
QJsonValue QJsonObject::operator[](const QString &key) const;

 检查key是否存在

iterator QJsonObject::find(const QString &key);
//建议用这个，直接返回bool
bool QJsonObject::contains(const QString &key) const;

 获取所有的key

QStringList QJsonObject::keys() const;

QJsonArray:

 对应Json数据中的数组，数组中的元素类型统一为QJsonValue

创建一个QJsonArray(通过构造函数)

QJsonArray::QJsonArray();

添加数组元素

// 添加到头部和尾部
void QJsonArray::append(const QJsonValue &value);
void QJsonArray::prepend(const QJsonValue &value);

// 插入到 i 的位置之前
void QJsonArray::insert(int i, const QJsonValue &value); 

// 添加到头部和尾部
void QJsonArray::push_back(const QJsonValue &value);
void QJsonArray::push_front(const QJsonValue &value);

 获取数组里的元素个数

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

 获取数组里元素的值

// 获取头部和尾部
QJsonValue QJsonArray::first() const;
QJsonValue QJsonArray::last() const;

// 获取指定位置，使用下标运算符
QJsonValue QJsonArray::at(int i) const;
QJsonValueRef QJsonArray::operator[](int i);

 删除数组里的元素

// 删除头部和尾部
void QJsonArray::pop_back();
void QJsonArray::pop_front();

void QJsonArray::removeFirst();
void QJsonArray::removeLast();

// 删除指定位置，推荐removeAt，易读
void QJsonArray::removeAt(int i);
QJsonValue QJsonArray::takeAt(int i);

 QJsonDocument：

他对应一个完整Json文档

组装Json和解析Json都需要先创建它

组装Json

//1. 创建QJsonObject 或者 QJsonArray的对象，然后使用其相关方法插值

// 2. 创建 QJsonDocument 对象
// 以插完值的 QJsonObject 或者 QJsonArray 为参数来创建 QJsonDocument 对象
QJsonDocument::QJsonDocument(const QJsonObject &object);
QJsonDocument::QJsonDocument(const QJsonArray &array);

// 3. 将 QJsonDocument 对象中的数据进行序列化
// 通过调用 toXXX() 方法就可以得到文本格式或者二进制格式的 Json 字符串了。
QByteArray QJsonDocument::toBinaryData() const;                          // 二进制格式的json字符串
QByteArray QJsonDocument::toJson(JsonFormat format = Indented) const;  // 文本格式

// 4. 使用得到的字符串进行数据传输，或者保存到文件

 解析Json

// 1. 将 JSON 字符串转换为 QJsonDocument 对象
[static] QJsonDocument QJsonDocument::fromBinaryData(const QByteArray &data, DataValidation validation = Validate);
[static] QJsonDocument QJsonDocument::fromJson(const QByteArray &json, QJsonParseError *error = Q_NULLPTR);

// 2. 将文档对象转换为 json 数组 / 对象

// 2.1 判断文档对象中存储的数据，是 JSON 数组还是 JSON 对象
bool QJsonDocument::isArray() const;
bool QJsonDocument::isObject() const
    
// 2.2 之后，就可以转换为 JSON 数组或 JSON 对象
QJsonObject QJsonDocument::object() const;
QJsonArray QJsonDocument::array() const;

// 3. 调用 QJsonArray / QJsonObject 类提供的 API 获取存储在其中的数据

 举例：

组装下面的Json字符串

{
 "name": "China",
 "info": {
  "capital": "beijing",
  "asian": true,
  "founded": 1949
 },
 "provinces": [{
  "name": "shandong",
  "capital": "jinan"
 }, {
  "name": "zhejiang",
  "capital": "hangzhou"
 }]
}

代码如下：

    //创建根节点，根节点是一个object
    QJsonObject root_obj;

    root_obj.insert("name","china");
    
    //info节点还是一个object
    QJsonObject info;
    info.insert("capital","beijing");
    info.insert("aisan",true);
    info.insert("founded",1949);

    root_obj.insert("info",info);
    
    //province节点是一个数组
    QJsonArray provinces;
    //数组元素是对象
    QJsonObject p1;
    p1.insert("name","zhejiang");
    p1.insert("capital","hangzhou");
    QJsonObject p2;
    p2.insert("name","shandong");
    p2.insert("capital","jinan");
    provinces.append(p1);
    provinces.append(p2);

    root_obj.insert("provinces",provinces);
    
    //通过根节点构造出QJsonDocument，然后转成字符串
    auto str_json=QJsonDocument(root_obj).toJson();

解析下面的Json字符串

{
 "name": "China",
 "info": {
  "capital": "beijing",
  "asian": true,
  "founded": 1949
 },
 "provinces": [{
  "name": "shandong",
  "capital": "jinan"
 }, {
  "name": "zhejiang",
  "capital": "hangzhou"
 }]
}

 代码如下：

QString str_json(R"(
{
 "name": "China",
 "info": {
  "capital": "beijing",
  "asian": true,
  "founded": 1949
 },
 "provinces": [{
  "name": "shandong",
  "capital": "jinan"
 }, {
  "name": "zhejiang",
  "capital": "hangzhou"
 }]
}
    )");

    //先通过需要解析的Json字符串构造出Json文档
    //注意该函数还有第二个参数，也可以不传，传的话可以知道str_json是否是正确格式的Json数据
    //QJsonParseError err;
    //QJsonDocument json_doc=QJsonDocument::fromJson(str_json,&err);
    //if(err.error!=QJsonParseError::NoError)
    //{
      //  return;
    //}
    QJsonDocument json_doc=QJsonDocument::fromJson(str_json.toUtf8());
    if(!json_doc.isObject())
    {
        //判断是否是Json对象
        qDebug()<<"error json!";
        return;
    }

    //获取这个json中最外层的json对象，根节点
    auto json_obj=json_doc.object();

    //直接通过下标获取，通过下标获取的统一是JsonValue，
    //需要先调用toXXXX方法转成实际的类型才可读取
    // auto name=json_obj["china"];
    // auto str_name=name.toString();
    // auto info_obj=json_obj["info"];
    // auto capital=info_obj.toObject()["capital"];
    // auto str_capital=capital.toString();

    auto keys=json_obj.keys();
    //也可以通过遍历key，来读取里面的值
    for(const auto& key:keys)
    {
        //通过下标获取的统一是JsonValue，需要先调用toXXXX方法转成实际的类型才可读取
        QJsonValue json_val=json_obj[key];

        //最好判断一下类型
        if(json_val.isString())
        {
            auto name=json_obj[key].toString();
            qDebug()<<"name是"<<name;
        }
        else if(json_val.isObject())
        {
            auto info_obj=json_obj[key].toObject();

            auto str_cap=info_obj["capital"].toString();
            auto is_asian=info_obj["asian"].toBool();
            auto founded=info_obj["founded"].toInt();
            qDebug()<<"首都是"<<str_cap;
            qDebug()<<"是否亚洲"<<is_asian;
            qDebug()<<"成立年份"<<founded;
        }
        else if(json_val.isArray())
        {
            auto province_info=json_val.toArray();
            int cnt=province_info.count();
            for(int i=0;i<cnt;++i)
            {
                auto pro_info=province_info[i].toObject();
                auto pro_name=pro_info["name"].toString();
                auto pro_cap=pro_info["capital"].toString();
                qDebug()<<"省份是"<<pro_name;
                qDebug()<<"省会是"<<pro_cap;
            }


        }


    }