自学内容网 自学内容网
自学内容网 > 正文

简单实现QT对象的[json]序列化与反序列化

🕗 发布于 2024-11-18 21:10 qt  json  开发语言  

简单实现QT对象的[json]序列化与反序列化

简介

众所周知json作为一种轻量级的数据交换格式，在开发中被广泛应用。因此如何方便的将对象数据转为json格式和从json格式中加载数据到对象中就变得尤为重要。
在python类动态语言中，我们可以很方便的使用json.dumps()和json.load()完成json数据的生成和加载。但是在QT中就不能非常方便的转换。
因此本文将使用QT中的元对象系统实现简单的json数据转换和加载

应用场景

假如现在需要开发一个系统，采用c/s架构，使用json格式作为前后端的数据交互协议，那么针对每个接口，所需要交互的数据都需要转换为json或者从json中获取。
举个栗子：
现有个需要，需要根据用户id获取用户的详细信息，由客户端发起请求，服务端返回数据

//客户端
//1.定义数据结构体
struct requestUserInfo
{
int id = -1;
};
struct responseUserInfo
{
QString name;
int age;
//....
};
//2.定义数据
requestUserInfo _data;
_data.id = 1;
//3.转换为json数据,转换过程就不展示了
QByteArray _requestData = "xxx";
auto _result = network.sendData(_requestData);
//4.将结果转换为responseUserInfo,转换过程就不详细描述了
responseUserInfo _responseData;
//5.显示详细信息
//.....

在这个过程中，可以很清楚的看到，第3步和第4步的转换和解析过程将会耗费大量的事件书写很多冗余的代码，如果能够很方便的将结构体(对象)转换为json 和从json转换为结构体。代码的书写将会变得简洁而高效。

qt元对象系统

在此之前我们需要先了解一下qt的元对象系统是什么，ai回答如下：

  • 信号和槽机制：Qt的元对象系统支持信号和槽之间的通信，这是Qt中对象间通信的主要方式。信号是由对象发出的通知，告知发生了某个事件，而槽是响应这些信号的函数。这种机制替代了传统的回调函数，使得对象间的协作更加简单和直观
  • 运行时类型信息：元对象系统提供了运行时类型信息（RTTI），允许程序在运行时查询对象的类型。这包括获取类的名称、父类的名称、类中信号和槽的数量和名称等
  • 动态属性系统：Qt的元对象系统支持动态属性，这意味着可以在运行时添加、修改或删除对象的属性。这些属性可以用于Qt Designer工具中，也可以在QML中使用
  • 继承和多态：Qt的元对象系统支持面向对象编程中的继承和多态特性。通过使用Q_OBJECT宏和元对象编译器（MOC），Qt能够为继承自QObject的类生成额外的代码，以支持信号和槽、属性等元对象特性
  • 元对象编译器（MOC）：为了使用元对象系统，需要在类定义中包含Q_OBJECT宏，然后使用MOC编译器生成额外的代码来支持元对象特性。MOC是Qt构建过程中自动调用的，它解析C++头文件，并为包含Q_OBJECT宏的类生成运行时所需的代码
  • 对象树和所有权：Qt使用对象树来组织和管理所有的QObject及其子类的对象。当一个对象被创建并指定另一个对象为其父对象时，它会被添加到父对象的孩子列表中。当父对象被销毁时，子对象也会自动被销毁，这有助于简化内存管理并减少内存泄漏的风险
  • 自定义属性：Qt提供了基于元对象系统的自定义属性机制，允许开发者定义自己的属性，并在Qt Designer和QML中使用这些属性。这些属性可以通过Q_PROPERTY宏来声明，并可以设置为动态属性

总之，继承至QObject的子类，在运行时可以通过qt的元对象系统获取对象的名称和属性信息，并且可以自定义信息，其他的特性不在本文讨论的范围中，如果大家感兴趣，后续可以专门写篇文章介绍。

思路

上面提到Qt的元对象系统可以在运行时获取对象的属性，并且支持自定义属性，所以我们就需要借助元对象的这两个属性来完成对象的序列化和反序列化。
在利用qt的元对象特性，利用QMetaObject类获取属性名称和属性值，在转换为json格式，同理从json格式加载时，也可以利用QMetaObject类向属性中写入数据。

实现

通过上述的原理，我实现了简单的转换和加载函数，都包含在一个头文件中，使用时也只需要包含头文件即可，还是很方便。
jsonHelper.h

#include <QObject>
#include <QJsonObject>
#include <QMetaObject>
#include <QMetaProperty>
#include <QMetaMethod>
#include <QJsonValue>

#define READ_WRITE_VALUE(_type,val) \
_type get_##val() const {return val;}\
void set_##val(const _type& _t){val = _t;}

#define READ_WRITE_VALUE_TEMPLATE(val) \
auto get_##val() const -> decltype(val) { return val; } \
void set_##val(const decltype(val)& _t) { val = _t; }

#define READ_FUNC_NAME(_name) get_##_name
#define WRITE_FUNC_NAME(_name) set_##_name

#define READ_OBJECT(_name)Q_INVOKABLE QJsonObject read_##_name(){return objDump(&_name);}

#define WRITE_OBJECT(_name)Q_INVOKABLE void set_##_name(const QJsonObject& _jsonObj){ objLoad(_jsonObj,&_name);}

inline QJsonObject objDump(QObject* _obj)
{
    QJsonObject _jsonObj;

    auto _meatObj = _obj->metaObject();

    for(int i = _meatObj->propertyOffset(); i < _meatObj->propertyCount(); i++)
    {
        auto _property = _meatObj->property(i);
        auto _type = _property.type();
        if(_type < QVariant::UserType)
        {
            _jsonObj[_property.name()] = _property.read(_obj).toJsonValue();
        }
    }

    for(int i = _meatObj->methodOffset(); i < _meatObj->methodCount(); i++)
    {
        auto _meth = _meatObj->method(i);
        if(_meth.returnType() != QMetaType::QJsonObject)
        {
            continue;
        }

        QJsonObject _tempObj;
        _meth.invoke(_obj,Qt::AutoConnection,Q_RETURN_ARG(QJsonObject,_tempObj));

        QString _key = _meth.name();
        _key = _key.remove("read_");
        _jsonObj[_key] = _tempObj;
    }

    return _jsonObj;
}

inline void objLoad(const QJsonObject& jsonObj,QObject* _obj)
{
    auto _meatObj = _obj->metaObject();

    for(int i = _meatObj->propertyOffset(); i < _meatObj->propertyCount(); i++)
    {
        auto _property = _meatObj->property(i);
        QJsonValue _val = jsonObj[_property.name()];
        _property.write(_obj,_val.toVariant());
    }

    for(int i = _meatObj->methodOffset(); i < _meatObj->methodCount(); i++)
    {
        auto _meth = _meatObj->method(i);
        if(_meth.returnType() != QMetaType::Void)
        {
            continue;
        }

        QString _key = _meth.name();
        _key = _key.remove("set_");
        QJsonObject tempObj = jsonObj[_key].toObject();
        _meth.invoke(_obj,Q_ARG(QJsonObject,tempObj));

    }
}

使用方式

  • 定义数据结构对象
#include "JsonHelper.h"

class testStruct : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int a READ READ_FUNC_NAME(a) WRITE WRITE_FUNC_NAME(a) CONSTANT)
public:
    testStruct &operator=(const testStruct& other)
    {
        if(this != &other)
        {
            this->a = other.a;
        }

        return *this;
    }
    int a;

protected:
    READ_WRITE_VALUE(int,a)
};

class myStruct : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int id READ READ_FUNC_NAME(id) WRITE WRITE_FUNC_NAME(id) CONSTANT)
    Q_PROPERTY(QString name READ READ_FUNC_NAME(name) WRITE WRITE_FUNC_NAME(name) CONSTANT)
    Q_PROPERTY(QStringList nameList READ READ_FUNC_NAME(nameList) WRITE WRITE_FUNC_NAME(nameList) CONSTANT)
public:
    int id;
    QString name;
    QStringList nameList;
    testStruct _s1;

protected:
    READ_WRITE_VALUE(int,id)
    READ_WRITE_VALUE(QString,name)
    READ_WRITE_VALUE(QStringList,nameList)
    READ_OBJECT(_s1)
    WRITE_OBJECT(_s1)

};
  • 类型转换与加载
void int main()
{
testStruct _ss;
    _ss.a = 12;

    myStruct _t;
    _t.id = 1;
    _t.name = "小明";
    _t.nameList = QStringList({"zhangsan","lisi"});
    _t._s1 = _ss;

    auto _obj = objDump(&_t);
    qDebug() << _obj;

    myStruct _t1;
    objLoad(_obj,&_t1);

    qDebug() << _t1.id << _t1.name << _t1.nameList << _t1._s1.a;

return 0;
}

题外话

可以发现定义数据结构时还是比较繁琐的，如果有更方便的方式来定义数据结构，在实际场景中可用性将会变的更好。
因此，我实现了一个简单的代码自动生成工具，可以将struct结构体转换为满足上述条件的数据对象。如下所示。
在这里插入图片描述
这样就可以不用费劲的编写数据对象结构了。
工具和代码都已经上传GitHub了，感兴趣可以下载使用
GitHub链接
也提供了打包好的生成工具，可直接下载使用：
生成工具链接


原文地址：https://blog.csdn.net/weixin_43435307/article/details/143824065

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024