• QT项目中通过数据封装实现Json结构和数据类之间的相互转换

    目录

    基本类型封装

    1.对字符串类型的封装

    2.对整型的封装

    3.对枚举类型进行封装

    3.对日期类型进行封装

    数据信息类封装

    1.数据信息体封装

    2.数据信息集合封装

    使用封装的数据结构

    1.定义新的业务数据类型

    2.使用新的数据类型

    开发项目中最重要的组成部分非数据莫属了，这里介绍一种QT项目中的数据封装方法。方法中封装的数据能进行自我监测，发生变化之后主动向外部发送消息通知变化，同时封装的数据可以实现与JSON数据结构之间的相互转换，这对于数据持久化和网络请求是很有帮助的。

    基本类型封装

    为了提升代码的复用性，这里我们将通用的方法和属性与基本的属性类型封装到一起，方便程序的调用。基本类型之间的继承关系如下图所示:

    DataDecorator是数据封装的基类，包含了数据内容的一些通用属性

    StringDecorator是对字符串类型的属性的封装

    IntDecorator是对整型类型的属性的封装

    EnumeratorDecorator是对枚举类型的数据的封装

    DateTimeDecorator是对日期类型的数据的封装

    基本类型的数据基类如下，封装了属性字段需要的额外的辅助参数，以及与Json结构之间相互转化的方法接口:

    1. //data-decorator.h
    2. #ifndef DATADECORATOR_H
    3. #define DATADECORATOR_H
    4.  
    5. #include <QJsonObject>
    6. #include <QJsonValue>
    7. #include <QObject>
    8. #include <QScopedPointer>
    9.  
    10. class Entity;
    11. class DataDecorator : public QObject
    12. {
    13. 	Q_OBJECT
    14.     //导出QML中需要访问属性
    15.     Q_PROPERTY( QString ui_describe READ label CONSTANT )
    16. public:
    17.     /**@brief 构造描述
    18.    * @1 该属性字段属于哪个数据实体
    19.    * @2 该属性字段对应的key值
    20.    * @3 该属性字段对应的描述信息
    21.    */
    22. 	DataDecorator(Entity* parent = nullptr, const QString& key = "SomeItemKey", const QString& label = "");
    23. 	virtual ~DataDecorator();
    24.  
    25.     const QString& key() const;   //key值用来查找该属性
    26.     const QString& label() const; //label用来描述该属性字段
    27.     Entity* parentEntity();       //属性字段属于哪个数据实体(比如用户等)
    28.  
    29.     //Json和数据类之间的相互转化
    30. 	virtual QJsonValue jsonValue() const = 0;
    31. 	virtual void update(const QJsonObject& jsonObject) = 0;
    32.  
    33. private:
    34.     //私有的数据类
    35. 	class Implementation;
    36. 	QScopedPointer<Implementation> implementation;
    37. };
    38. #endif

    1. //data-decorator.cpp
    2. #include "data-decorator.h"
    3. class DataDecorator::Implementation
    4. {
    5. public:
    6. 	Implementation(Entity* _parent, const QString& _key, const QString& _label)
    7. 		: parentEntity(_parent)
    8. 		, key(_key)
    9. 		, label(_label)
    10. 	{
    11. 	}
    12. 	Entity* parentEntity{nullptr};
    13. 	QString key;
    14. 	QString label;
    15. };
    16.  
    17. DataDecorator::DataDecorator(Entity* parent, const QString& key, const QString& label)
    18. 	: QObject((QObject*)parent)
    19. {
    20. 	implementation.reset(new Implementation(parent, key, label));
    21. }
    22. DataDecorator::~DataDecorator()
    23. {
    24. }
    25. const QString& DataDecorator::key() const
    26. {
    27. 	return implementation->key;
    28. }
    29.  
    30. const QString& DataDecorator::label() const
    31. {
    32. 	return implementation->label;
    33. }
    34.  
    35. Entity* DataDecorator::parentEntity()
    36. {
    37. 	return implementation->parentEntity;
    38. }

    基本类型的封装类派生自DataDecorator类，实现如下：

    1.对字符串类型的封装

    1. //string-decorator.h
    2. #ifndef STRINGDECORATOR_H
    3. #define STRINGDECORATOR_H
    4.  
    5. #include <QJsonObject>
    6. #include <QJsonValue>
    7. #include <QObject>
    8. #include <QScopedPointer>
    9. #include <QString>
    10. #include <data/data-decorator.h>
    11.  
    12. class  StringDecorator : public DataDecorator
    13. {
    14. 	Q_OBJECT
    15.    //QML访问的属性
    16. 	Q_PROPERTY( QString ui_value READ value WRITE setValue NOTIFY valueChanged )
    17. public:
    18. 	StringDecorator(Entity* parentEntity = nullptr, const QString& key = "SomeItemKey", const QString& label = "", const QString& value = "");
    19. 	~StringDecorator();
    20.  
    21.     //修改和获取字符串封装类型中的原始数据
    22. 	StringDecorator& setValue(const QString& value);
    23. 	const QString& value() const;
    24.  
    25. 	QJsonValue jsonValue() const override;
    26. 	void update(const QJsonObject& jsonObject) override;
    27.  
    28. signals:
    29.     //数据发生变化的时候发送的信号
    30. 	void valueChanged();
    31.  
    32. private:
    33. 	class Implementation;
    34. 	QScopedPointer<Implementation> implementation;
    35. };
    36.  
    37. #endif

    1. //string-decorator.cpp
    2. #include "string-decorator.h"
    3. #include <QVariant>
    4.  
    5. class StringDecorator::Implementation
    6. {
    7. public:
    8. 	Implementation(StringDecorator* _stringDecorator, const QString& _value)
    9. 		: stringDecorator(_stringDecorator)
    10. 		, value(_value)
    11. 	{
    12. 	}
    13.  
    14. 	StringDecorator* stringDecorator{nullptr};
    15. 	QString value;
    16. };
    17.  
    18. StringDecorator::StringDecorator(Entity* parentEntity, const QString& key, const QString& label, const QString& value)
    19. 	: DataDecorator(parentEntity, key, label)
    20. {
    21. 	implementation.reset(new Implementation(this, value));
    22. }
    23.  
    24. StringDecorator::~StringDecorator()
    25. {
    26. }
    27.  
    28. const QString& StringDecorator::value() const
    29. {
    30. 	return implementation->value;
    31. }
    32.  
    33. StringDecorator& StringDecorator::setValue(const QString& value)
    34. {
    35. 	if(value != implementation->value) {
    36. 		implementation->value = value;
    37. 		emit valueChanged();
    38. 	}
    39. 	return *this;
    40. }
    41.  
    42. QJsonValue StringDecorator::jsonValue() const
    43. {
    44. 	return QJsonValue::fromVariant(QVariant(implementation->value));
    45. }
    46.  
    47. void StringDecorator::update(const QJsonObject& _jsonObject)
    48. {
    49. 	if (_jsonObject.contains(key())) {
    50. 		setValue(_jsonObject.value(key()).toString());
    51. 	}
    52. }

    2.对整型的封装

    1. //int-decorator.h
    2. #ifndef INTDECORATOR_H
    3. #define INTDECORATOR_H
    4.  
    5. #include <QJsonObject>
    6. #include <QJsonValue>
    7. #include <QObject>
    8. #include <QScopedPointer>
    9. #include <data/data-decorator.h>
    10.  
    11. class  IntDecorator : public DataDecorator
    12. {
    13. 	Q_OBJECT
    14.    // QML访问的接口
    15. 	Q_PROPERTY( int ui_value READ value WRITE setValue NOTIFY valueChanged )
    16.  
    17. public:
    18. 	IntDecorator(Entity* parentEntity = nullptr, const QString& key = "SomeItemKey", const QString& label = "", int value = 0);
    19. 	~IntDecorator();
    20.  
    21.     //修改和获取对应的属性值
    22. 	IntDecorator& setValue(int value);
    23. 	int value() const;
    24.  
    25. public:
    26. 	QJsonValue jsonValue() const override;
    27. 	void update(const QJsonObject& jsonObject) override;
    28.  
    29. signals:
    30. 	void valueChanged();
    31.  
    32. private:
    33. 	class Implementation;
    34. 	QScopedPointer<Implementation> implementation;
    35. };
    36.  
    37. #endif

    1. //int-decorator.cpp
    2. #include "int-decorator.h"
    3. #include <QVariant>
    4.  
    5. class IntDecorator::Implementation
    6. {
    7. public:
    8. 	Implementation(IntDecorator* intDecorator, int value)
    9. 		: intDecorator(intDecorator)
    10. 		, value(value)
    11. 	{
    12. 	}
    13.  
    14. 	IntDecorator* intDecorator{nullptr};
    15. 	int value;
    16. };
    17.  
    18. IntDecorator::IntDecorator(Entity* parentEntity, const QString& key, const QString& label, int value)
    19. 	: DataDecorator(parentEntity, key, label)
    20. {
    21. 	implementation.reset(new Implementation(this, value));
    22. }
    23.  
    24. IntDecorator::~IntDecorator()
    25. {
    26. }
    27.  
    28. int IntDecorator::value() const
    29. {
    30. 	return implementation->value;
    31. }
    32.  
    33. IntDecorator& IntDecorator::setValue(int value)
    34. {
    35. 	if(value != implementation->value) {
    36. 		// ...Validation here if required...
    37. 		implementation->value = value;
    38. 		emit valueChanged();
    39. 	}
    40.  
    41. 	return *this;
    42. }
    43.  
    44. QJsonValue IntDecorator::jsonValue() const
    45. {
    46. 	return QJsonValue::fromVariant(QVariant(implementation->value));
    47. }
    48.  
    49. void IntDecorator::update(const QJsonObject& jsonObject)
    50. {
    51. 	if (jsonObject.contains(key())) {
    52. 		auto l_value = jsonObject.value(key()).toInt();
    53. 		setValue(l_value);
    54. 	} else {
    55. 		setValue(0);
    56. 	}
    57. }

    3.对枚举类型进行封装

    和其它的基本类型不同，枚举类型除了包含一个整型的数值以外，还包含一个映射表，对每个枚举数值有一个对应的字符串映射，用于枚举的对外显示。

    1. //enumerator-decorator.h
    2. #ifndef ENUMERATORDECORATOR_H
    3. #define ENUMERATORDECORATOR_H
    4. #include <map>
    5. #include <QJsonObject>
    6. #include <QJsonValue>
    7. #include <QObject>
    8. #include <QScopedPointer>
    9. #include <data/data-decorator.h>
    10.  
    11. class EnumeratorDecorator : public DataDecorator
    12. {
    13. 	Q_OBJECT
    14.     //枚举属性值
    15. 	Q_PROPERTY( int ui_value READ value WRITE setValue NOTIFY valueChanged )
    16.     //枚举属性对应的字符串描述
    17. 	Q_PROPERTY( QString ui_valueDescription READ valueDescription NOTIFY valueChanged )
    18. public:
    19. 	EnumeratorDecorator(Entity* parentEntity = nullptr, const QString& key = "SomeItemKey", const QString& label = "", int value = 0, const std::map<int, QString>& descriptionMapper = std::map<int, QString>());
    20. 	~EnumeratorDecorator();
    21.     
    22.     //获取属性对应的值和描述
    23. 	EnumeratorDecorator& setValue(int value);
    24. 	int value() const;
    25. 	QString valueDescription() const;
    26.  
    27. 	QJsonValue jsonValue() const override;
    28. 	void update(const QJsonObject& jsonObject) override;
    29.  
    30. signals:
    31. 	void valueChanged();
    32.  
    33. private:
    34. 	class Implementation;
    35. 	QScopedPointer<Implementation> implementation;
    36. };
    37. #endif

    1. //enumerator-decorator.cpp
    2. #include "enumerator-decorator.h"
    3. #include <QVariant>
    4.  
    5. class EnumeratorDecorator::Implementation
    6. {
    7. public:
    8. 	Implementation(EnumeratorDecorator* enumeratorDecorator, int value, const std::map<int, QString>& descriptionMapper)
    9. 		: enumeratorDecorator(enumeratorDecorator)
    10. 		, value(value)
    11. 		, descriptionMapper(descriptionMapper)
    12. 	{
    13. 	}
    14.  
    15. 	EnumeratorDecorator* enumeratorDecorator{nullptr};
    16. 	int value;
    17. 	std::map<int, QString> descriptionMapper;
    18. };
    19.  
    20. EnumeratorDecorator::EnumeratorDecorator(Entity* parentEntity, const QString& key, const QString& label, int value, const std::map<int, QString>& descriptionMapper)
    21. 	: DataDecorator(parentEntity, key, label)
    22. {
    23. 	implementation.reset(new Implementation(this, value, descriptionMapper));
    24. }
    25.  
    26. EnumeratorDecorator::~EnumeratorDecorator()
    27. {
    28. }
    29.  
    30. int EnumeratorDecorator::value() const
    31. {
    32. 	return implementation->value;
    33. }
    34.  
    35. QString EnumeratorDecorator::valueDescription() const
    36. {
    37. 	if (implementation->descriptionMapper.find(implementation->value) != implementation->descriptionMapper.end()) {
    38. 		return implementation->descriptionMapper.at(implementation->value);
    39. 	} else {
    40. 		return {};
    41. 	}
    42. }
    43.  
    44. EnumeratorDecorator& EnumeratorDecorator::setValue(int value)
    45. {
    46. 	if (value != implementation->value) {
    47. 		// ...Validation here if required...
    48. 		implementation->value = value;
    49. 		emit valueChanged();
    50. 	}
    51.  
    52. 	return *this;
    53. }
    54.  
    55. QJsonValue EnumeratorDecorator::jsonValue() const
    56. {
    57. 	return QJsonValue::fromVariant(QVariant(implementation->value));
    58. }
    59.  
    60. void EnumeratorDecorator::update(const QJsonObject& jsonObject)
    61. {
    62. 	if (jsonObject.contains(key())) {
    63. 		auto valueFromJson = jsonObject.value(key()).toInt();
    64. 		setValue(valueFromJson);
    65. 	} else {
    66. 		setValue(0);
    67. 	}
    68. }

    3.对日期类型进行封装

    由于日期有不同的显示形式，因此我们在日期的封装类型中扩展一些新的接口，方便调用者获取日期的不同显示形式。

    1. //datetime-decorator.h
    2. #ifndef DATETIMEDECORATOR_H
    3. #define DATETIMEDECORATOR_H
    4.  
    5. #include <QDateTime>
    6. #include <QJsonObject>
    7. #include <QJsonValue>
    8. #include <QObject>
    9. #include <QScopedPointer>
    10. #include <data/data-decorator.h>
    11.  
    12. class DateTimeDecorator : public DataDecorator
    13. {
    14. 	Q_OBJECT
    15.     //QML中访问各种日期的格式
    16. 	Q_PROPERTY( QString ui_iso8601String READ toIso8601String NOTIFY valueChanged )
    17. 	Q_PROPERTY( QString ui_prettyDateString READ toPrettyDateString NOTIFY valueChanged )
    18. 	Q_PROPERTY( QString ui_prettyTimeString READ toPrettyTimeString NOTIFY valueChanged )
    19. 	Q_PROPERTY( QString ui_prettyString READ toPrettyString NOTIFY valueChanged )
    20. 	Q_PROPERTY( QDateTime ui_value READ value WRITE setValue NOTIFY valueChanged )
    21.  
    22. public:
    23. 	DateTimeDecorator(Entity* parentEntity = nullptr, const QString& key = "SomeItemKey", const QString& label = "", const QDateTime& value = QDateTime());
    24. 	~DateTimeDecorator();
    25.  
    26. 	const QDateTime& value() const;
    27. 	DateTimeDecorator& setValue(const QDateTime& value);
    28.  
    29.     //获取各种显示格式
    30. 	QString toIso8601String() const;
    31. 	QString toPrettyDateString() const;
    32. 	QString toPrettyTimeString() const;
    33. 	QString toPrettyString() const;
    34.  
    35. 	QJsonValue jsonValue() const override;
    36. 	void update(const QJsonObject& jsonObject) override;
    37.  
    38. signals:
    39. 	void valueChanged();
    40.  
    41. private:
    42. 	class Implementation;
    43. 	QScopedPointer<Implementation> implementation;
    44. };
    45.  
    46. #endif

    1. //datetime-decorator.cpp
    2. #include "datetime-decorator.h"
    3. #include <QVariant>
    4.  
    5. class DateTimeDecorator::Implementation
    6. {
    7. public:
    8. 	Implementation(DateTimeDecorator* dateTimeDecorator, const QDateTime& value)
    9. 		: dateTimeDecorator(dateTimeDecorator)
    10. 		, value(value)
    11. 	{
    12. 	}
    13. 	DateTimeDecorator* dateTimeDecorator{nullptr};
    14. 	QDateTime value;
    15. };
    16.  
    17. DateTimeDecorator::DateTimeDecorator(Entity* parentEntity, const QString& key, const QString& label, const QDateTime& value)
    18. 	: DataDecorator(parentEntity, key, label)
    19. {
    20. 	implementation.reset(new Implementation(this, value));
    21. }
    22.  
    23. DateTimeDecorator::~DateTimeDecorator()
    24. {
    25. }
    26.  
    27. const QDateTime& DateTimeDecorator::value() const
    28. {
    29. 	return implementation->value;
    30. }
    31.  
    32. DateTimeDecorator& DateTimeDecorator::setValue(const QDateTime& value)
    33. {
    34. 	if(value != implementation->value) {
    35. 		// ...Validation here if required...
    36. 		implementation->value = value;
    37. 		emit valueChanged();
    38. 	}
    39.  
    40. 	return *this;
    41. }
    42.  
    43. QString DateTimeDecorator::toIso8601String() const
    44. {
    45. 	if (implementation->value.isNull()) {
    46. 		return "";
    47. 	} else {
    48. 		return implementation->value.toString(Qt::ISODate);
    49. 	}
    50. }
    51.  
    52. QString DateTimeDecorator::toPrettyString() const
    53. {
    54. 	if (implementation->value.isNull()) {
    55. 		return "Not set";
    56. 	} else {
    57. 		return implementation->value.toString( "ddd d MMM yyyy @ HH:mm:ss" );
    58. 	}
    59. }
    60.  
    61. QString DateTimeDecorator::toPrettyDateString() const
    62. {
    63. 	if (implementation->value.isNull()) {
    64. 		return "Not set";
    65. 	} else {
    66. 		return implementation->value.toString( "d MMM yyyy" );
    67. 	}
    68. }
    69.  
    70. QString DateTimeDecorator::toPrettyTimeString() const
    71. {
    72. 	if (implementation->value.isNull()) {
    73. 		return "Not set";
    74. 	} else {
    75. 		return implementation->value.toString( "hh:mm ap" );
    76. 	}
    77. }
    78.  
    79. QJsonValue DateTimeDecorator::jsonValue() const
    80. {
    81. 	return QJsonValue::fromVariant(QVariant(implementation->value.toString(Qt::ISODate)));
    82. }
    83.  
    84. void DateTimeDecorator::update(const QJsonObject& jsonObject)
    85. {
    86. 	if (jsonObject.contains(key())) {
    87. 		auto valueAsString = jsonObject.value(key()).toString();
    88. 		auto valueAsDate = QDateTime::fromString(valueAsString, Qt::ISODate);  // yyyy-MM-ddTHH:mm:ss
    89. 		setValue(valueAsDate);
    90. 	} else {
    91. 		setValue(QDateTime());
    92. 	}
    93. }

    数据信息类封装

    封装好了基本类型就可以进一步封装数据信息类了。数据信息类就是一个有很多基本类型组合成的一个有机的数据集合整体，基本数据之间都是有逻辑关系的。比如消费者信息类就包含:字符串类型的姓名、整型的年龄、字符串类型的地址、字符串类型的性别等等。数据信息类和基本类型之间的对应关系有一对一的，也有一对多的，比如一个人只有一个名字，但可能有多个地址，在封装的时候需要考虑到这点。数据信息类的封装类之间的关系如下图所示:

    数据实体的基类Entity封装实体需要基本属性和方法，一个数据实体包含多个基本类型的属性。同时一个数据实体可能包含多个其它的数据实体，比如一个用户可以拥有多量车多个账户等等。

    1.数据信息体封装

    Entity包含数据信息实体的基本属性和方法实现如下:

    1. //entity.h
    2. #ifndef ENTITY_H
    3. #define ENTITY_H
    4.  
    5. #include <map>
    6. #include <QObject>
    7. #include <QScopedPointer>
    8. #include <data/data-decorator.h>
    9. #include <data/entity-collection.h>
    10.  
    11. class Entity : public QObject
    12. {
    13. 	Q_OBJECT
    14.  
    15. public:
    16. 	Entity(QObject* parent = nullptr, const QString& key = "SomeEntityKey");
    17. 	Entity(QObject* parent, const QString& key, const QJsonObject& jsonObject);
    18. 	virtual ~Entity();
    19.  
    20. public:
    21.     //数据信息体对应的key值
    22. 	const QString& key() const;
    23.  
    24.     //数据信息类和Json结构之间的相互转换
    25. 	void update(const QJsonObject& jsonObject);
    26. 	QJsonObject toJson() const;
    27.  
    28. signals:
    29.     //信息体集合发生变化
    30. 	void childCollectionsChanged(const QString& collectionKey);
    31.     //包含的信息体发生变化
    32. 	void childEntitiesChanged();
    33.     //包含的属性发生变化
    34. 	void dataDecoratorsChanged();
    35.  
    36. protected:
    37.     //添加包含的信信息体
    38. 	Entity* addChild(Entity* entity, const QString& key);
    39.     //添加包含的信息实体列表
    40. 	EntityCollectionBase* addChildCollection(EntityCollectionBase* entityCollection);
    41.     //添加子属性
    42. 	DataDecorator* addDataItem(DataDecorator* dataDecorator);
    43. protected:
    44. 	class Implementation;
    45. 	QScopedPointer<Implementation> implementation;
    46. };
    47.  
    48. #endif

    1. //entity.cpp
    2. #include "entity.h"
    3. #include <QJsonArray>
    4.  
    5. class Entity::Implementation
    6. {
    7. public:
    8. 	Implementation(Entity* _entity, const QString& _key)
    9. 		: entity(_entity)
    10. 		, key(_key)
    11. 	{
    12. 	}
    13. 	Entity* entity{nullptr};
    14. 	QString key;
    15. 	std::map<QString, EntityCollectionBase*> childCollections;
    16. 	std::map<QString, Entity*> childEntities;
    17. 	std::map<QString, DataDecorator*> dataDecorators;
    18. };
    19.  
    20. Entity::Entity(QObject* parent, const QString& key)
    21. 	: QObject(parent)
    22. {
    23. 	implementation.reset(new Implementation(this, key));
    24. }
    25.  
    26. Entity::Entity(QObject* parent, const QString& key, const QJsonObject& jsonObject)
    27. 	: Entity(parent, key)
    28. {
    29. 	update(jsonObject);
    30. }
    31.  
    32. Entity::~Entity()
    33. {
    34. }
    35. const QString& Entity::key() const
    36. {
    37. 	return implementation->key;
    38. }
    39.  
    40. Entity* Entity::addChild(Entity* entity, const QString& key)
    41. {
    42. 	if(implementation->childEntities.find(key) == std::end(implementation->childEntities)) {
    43. 		implementation->childEntities[key] = entity;
    44. 		emit childEntitiesChanged();
    45. 	}
    46.  
    47. 	return entity;
    48. }
    49.  
    50. EntityCollectionBase* Entity::addChildCollection(EntityCollectionBase* entityCollection)
    51. {
    52. 	if(implementation->childCollections.find(entityCollection->getKey()) == std::end(implementation->childCollections)) {
    53. 		implementation->childCollections[entityCollection->getKey()] = entityCollection;
    54. 		emit childCollectionsChanged(entityCollection->getKey());
    55. 	}
    56.  
    57. 	return entityCollection;
    58. }
    59.  
    60. DataDecorator* Entity::addDataItem(DataDecorator* dataDecorator)
    61. {
    62. 	if(implementation->dataDecorators.find(dataDecorator->key()) == std::end(implementation->dataDecorators)) {
    63. 		implementation->dataDecorators[dataDecorator->key()] = dataDecorator;
    64. 		emit dataDecoratorsChanged();
    65. 	}
    66. 	return dataDecorator;
    67. }
    68.  
    69. void Entity::update(const QJsonObject& jsonObject)
    70. {
    71. 	// Update data decorators
    72. 	for (std::pair<QString, DataDecorator*> dataDecoratorPair : implementation->dataDecorators) {
    73. 		dataDecoratorPair.second->update(jsonObject);
    74. 	}
    75.  
    76. 	// Update child entities
    77. 	for (std::pair<QString, Entity*> childEntityPair : implementation->childEntities) {
    78. 		childEntityPair.second->update(jsonObject.value(childEntityPair.first).toObject());
    79. 	}
    80.  
    81. 	// Update child collections
    82. 	for (std::pair<QString, EntityCollectionBase*> childCollectionPair : implementation->childCollections) {
    83. 		childCollectionPair.second->update(jsonObject.value(childCollectionPair.first).toArray());
    84. 	}
    85. }
    86.  
    87. QJsonObject Entity::toJson() const
    88. {
    89. 	QJsonObject returnValue;
    90.  
    91. 	// Add data decorators
    92. 	for (std::pair<QString, DataDecorator*> dataDecoratorPair : implementation->dataDecorators) {
    93. 		returnValue.insert( dataDecoratorPair.first, dataDecoratorPair.second->jsonValue() );
    94. 	}
    95.  
    96. 	// Add child entities
    97. 	for (std::pair<QString, Entity*> childEntityPair : implementation->childEntities) {
    98. 		returnValue.insert( childEntityPair.first, childEntityPair.second->toJson() );
    99. 	}
    100.  
    101. 	// Add child collections
    102. 	for (std::pair<QString, EntityCollectionBase*> childCollectionPair : implementation->childCollections) {
    103. 		QJsonArray entityArray;
    104. 			for (Entity* entity : childCollectionPair.second->baseEntities()) {
    105. 			entityArray.append( entity->toJson() );
    106. 		}
    107. 		returnValue.insert( childCollectionPair.first, entityArray );
    108. 	}
    109.  
    110. 	return returnValue;
    111. }

    2.数据信息集合封装

    数据信息集合就是对数据体的列表进行封装，比如一个用户包含一个地址列表，地址列表就是地址信息的集合。通过模板操作，我们可以实现各种信息实体的序列化和反序列化，信息集合的实现如下:

    1. #ifndef ENTITYCOLLECTION_H
    2. #define ENTITYCOLLECTION_H
    3.  
    4. #include <QJsonArray>
    5. #include <QJsonValue>
    6. #include <QObject>
    7.  
    8. class Entity;
    9. //基类声明集合变化的信号
    10. class EntityCollectionObject : public QObject
    11. {
    12. 	Q_OBJECT
    13.  
    14. public:
    15. 	EntityCollectionObject(QObject* _parent = nullptr) : QObject(_parent) {}
    16. 	virtual ~EntityCollectionObject() {}
    17.  
    18. signals:
    19. 	void collectionChanged();
    20. };
    21.  
    22. //数据信息集合的基类
    23. class EntityCollectionBase : public EntityCollectionObject
    24. {
    25. public:
    26. 	EntityCollectionBase(QObject* parent = nullptr, const QString& key = "SomeCollectionKey")
    27. 		: EntityCollectionObject(parent)
    28. 		, key(key)
    29. 	{}
    30.  
    31. 	virtual ~EntityCollectionBase()
    32. 	{}
    33.  
    34. 	QString getKey() const
    35. 	{
    36. 		return key;
    37. 	}
    38.  
    39. 	virtual void clear() = 0;
    40.     //json数组转成数据实体
    41. 	virtual void update(const QJsonArray& json) = 0;
    42. 	virtual std::vector<Entity*> baseEntities() = 0;
    43.  
    44. 	template <class T>
    45. 	QList<T*>& derivedEntities();
    46.  
    47. 	template <class T>
    48. 	T* addEntity(T* entity);
    49.  
    50. private:
    51. 	QString key;
    52. };
    53.  
    54. //数据信息基类
    55. template <typename T>
    56. class EntityCollection : public EntityCollectionBase
    57. {
    58. public:
    59. 	EntityCollection(QObject* parent = nullptr, const QString& key = "SomeCollectionKey")
    60. 		: EntityCollectionBase(parent, key)
    61. 	{}
    62.  
    63. 	~EntityCollection()
    64. 	{}
    65.  
    66.     //清空列表
    67. 	void clear() override
    68. 	{
    69. 		for(auto entity : collection) {
    70. 			entity->deleteLater();
    71. 		}
    72. 		collection.clear();
    73. 	}
    74.     //更新列表
    75. 	void update(const QJsonArray& jsonArray) override
    76. 	{
    77. 		clear();
    78. 		for(const QJsonValue& jsonValue : jsonArray) {
    79. 			addEntity(new T(this, jsonValue.toObject()));
    80. 		}
    81. 	}
    82.     
    83.     //获取列表
    84. 	std::vector<Entity*> baseEntities() override
    85. 	{
    86. 		std::vector<Entity*> returnValue;
    87. 		for(T* entity : collection) {
    88. 			returnValue.push_back(entity);
    89. 		}
    90. 		return returnValue;
    91. 	}
    92.     
    93.     //获取列表的引用
    94. 	QList<T*>& derivedEntities()
    95. 	{
    96. 		return collection;
    97. 	}
    98.     
    99.     //添加新的信息实体
    100. 	T* addEntity(T* entity)
    101. 	{
    102. 		if(!collection.contains(entity)) {
    103. 			collection.append(entity);
    104. 			EntityCollectionObject::collectionChanged();
    105. 		}
    106. 		return entity;
    107. 	}
    108. private:
    109. 	QList<T*> collection;
    110. };
    111.  
    112. template <class T>
    113. QList<T*>& EntityCollectionBase::derivedEntities()
    114. {
    115. 	return dynamic_cast<const EntityCollection<T>&>(*this).derivedEntities();
    116. }
    117.  
    118. template <class T>
    119. T* EntityCollectionBase::addEntity(T* entity)
    120. {
    121. 	return dynamic_cast<const EntityCollection<T>&>(*this).addEntity(entity);
    122. }
    123.  
    124. #endif

    使用封装的数据结构

    1.定义新的业务数据类型

    封装完成之后，我们就可以在项目中使用我们封装的类型了，这里以一个消费者Customer为例说明一下封装的基本类型的使用方法。Customer消费者包含两个基本属性字符串类型的姓名，整型的年龄，以及一个地址列表。地址包含城市街道邮政编码等信息，地址的实现方式如下：

    1. //address.h
    2. #ifndef ADDRESS_H
    3. #define ADDRESS_H
    4.  
    5. #include <QObject>
    6. #include <data/string-decorator.h>
    7. #include <data/entity.h>
    8.  
    9. class Address : public Entity
    10. {
    11. 	Q_OBJECT
    12.     Q_PROPERTY(StringDecorator* ui_building MEMBER building CONSTANT)
    13.     Q_PROPERTY(StringDecorator* ui_street MEMBER street CONSTANT)
    14.     Q_PROPERTY(StringDecorator* ui_city MEMBER city CONSTANT)
    15.     Q_PROPERTY(StringDecorator* ui_postcode MEMBER postcode CONSTANT)
    16. 	Q_PROPERTY(QString ui_fullAddress READ fullAddress CONSTANT)
    18. public:
    19. 	explicit Address(QObject* parent = nullptr);
    20. 	Address(QObject* parent, const QJsonObject& json);
    21.  
    22.     StringDecorator* building{nullptr}; //建筑
    23.     StringDecorator* street{nullptr};   //街道
    24.     StringDecorator* city{nullptr};     //城市
    25.     StringDecorator* postcode{nullptr}; //邮政编码
    26.  
    27. 	QString fullAddress() const;
    28. };
    29.  
    30. #endif
    1. //address.cpp
    2. #include "address.h"
    3.  
    4. Address::Address(QObject* parent)
    5. 		: Entity(parent, "address")
    6. {
    7. 	building = static_cast<StringDecorator*>(addDataItem(new StringDecorator(this, "building", "Building")));
    8. 	street = static_cast<StringDecorator*>(addDataItem(new StringDecorator(this, "street", "Street")));
    9. 	city = static_cast<StringDecorator*>(addDataItem(new StringDecorator(this, "city", "City")));
    10. 	postcode = static_cast<StringDecorator*>(addDataItem(new StringDecorator(this, "postcode", "Post Code")));
    11. }
    12.  
    13. Address::Address(QObject* parent, const QJsonObject& json)
    14. 		: Address(parent)
    15. {
    16. 	update(json);
    17. }
    18.  
    19. QString Address::fullAddress() const
    20. {
    21. 	return building->value() + " " + street->value() + "\n" + city->value() + "\n" + postcode->value();
    22. }

    消费者信息类中除了包含基本属性之外，还包含一个地址信息集合,对应的实现如下:

    1. //customer.h
    2. #ifndef Customer_H
    3. #define Customer_H
    4.  
    5. #include <QObject>
    6. #include <QtQml/QQmlListProperty>
    7. #include <data/string-decorator.h>
    8. #include <data/int-decorator.h>
    9. #include <data/entity.h>
    10. #include <data/entity-collection.h>
    11. #include <data/address.h>
    12.  
    13. class Customer : public Entity
    14. {
    15. 	Q_OBJECT
    16.     //QML访问的信息接口
    17.     //年龄信息
    18.     Q_PROPERTY( IntDecorator* ui_age MEMBER age CONSTANT )
    19.     //姓名信息
    20.     Q_PROPERTY( StringDecorator* ui_name MEMBER name CONSTANT )
    21.     Q_PROPERTY( Address* ui_mainAddress MEMBER defaultAddr CONSTANT ) //默认地址
    22.     //地址列表
    23.     Q_PROPERTY( QQmlListProperty<Address> ui_address READ ui_address NOTIFY addresssListChanged)
    24.  
    25. public:
    26.     explicit Customer(QObject* parent = nullptr);
    27.     Customer(QObject* parent, const QJsonObject& json);
    28.  
    29.     IntDecorator* age{nullptr};       //年龄
    30.     StringDecorator* name{nullptr};   //姓名
    31.     Address* defaultAddr{nullptr};    //默认地址
    32.     //地址列表
    33.     EntityCollection<Address>* addresses{nullptr};
    34.     //qml访问的地址列表
    35.     QQmlListProperty<Address> ui_address();
    36.  
    37. signals:
    38.     void addresssListChanged();
    39. };
    40.  
    41. #endif
    1. //customer.cpp
    2. #include "customer.h"
    3.  
    4. Customer::Customer(QObject* parent)
    5.     : Entity(parent, "Customer")
    6. {
    7.     age = static_cast<IntDecorator*>(addDataItem(new IntDecorator(this, "age", "年龄")));
    8.     name = static_cast<StringDecorator*>(addDataItem(new StringDecorator(this, "name", "姓名")));
    9.     defaultAddr = static_cast<Address*>(addChild(new Address(this), "defaultAddress"));
    10.     addresses = static_cast<EntityCollection<Address>*>(addChildCollection(new EntityCollection<Address>(this, "address")));
    11. }
    12.  
    13. Customer::Customer(QObject* parent, const QJsonObject& json)
    14.     : Customer(parent)
    15. {
    16.     update(json);
    17. }
    18.  
    19. QQmlListProperty<Address> Customer::ui_address()
    20. {
    21.     return QQmlListProperty<Address>(this, addresses->derivedEntities());
    22. }

    2.使用新的数据类型

    通过使用新的封装类型，我们就可以实现Json结构和数据类之间的相互转换了，使用方法如下:

    1. #include "widget.h"
    2. #include <QApplication>
    3. #include <data/customer.h>
    4. #include <data/address.h>
    5.  
    6. int main(int argc, char *argv[])
    7. {
    8.     QApplication a(argc, argv);
    9.     //将json结构转换成一个数据类
    10.     QJsonObject customer_json;
    11.     Customer* customer = new Customer(NULL,customer_json);
    12.     //名字变化处理
    13.     QObject::connect(customer->name,&StringDecorator::valueChanged,[&](){});
    14.     //年龄变化的处理
    15.     QObject::connect(customer->age,&IntDecorator::valueChanged,[&](){});
    16.     //默认地址变化的处理
    17.     QObject::connect(customer->defaultAddr,&Address::dataDecoratorsChanged,[&](){});
    18.  
    19.     //修改数据
    20.     customer->name->setValue("小明");
    21.     customer->age->setValue(23);
    22.     customer->defaultAddr->city->setValue("北京市");
    23.     customer->defaultAddr->street->setValue("光明街道");
    24.     customer->defaultAddr->building->setValue("6号楼");
    25.     customer->defaultAddr->postcode->setValue("56788");
    26.  
    27.     //添加新地址
    28.     Address* new_addr = new Address();
    29.     new_addr->city->setValue("西河市");
    30.     new_addr->street->setValue("细节街道");
    31.     new_addr->building->setValue("6号楼");
    32.     new_addr->postcode->setValue("56789");
    33.     customer->addresses->addEntity(new_addr);
    34.  
    35.     //将数据类型转换成json数据结构
    36.     QJsonObject json_object = customer->toJson();
    37.     return a.exec();
    38. }

    通过这种封装，我们就可以实现数据类和Json数据结构之间的相互转化了，同时所有属性都有描述信息，这对于我们的复用和扩展都是很有帮助的。 

  • 相关阅读:
    pandas是什么以及pandas的三种数据结构Series、DataFrame、MultiIndex的创建方式函数代码
    全职RISC-V芯片D1开发板使用adb串口COM连接设备和文件上传下载
    深度神经网络预测模型,人工神经网络回归分析
    HCIP学习--扩展知识点
    艾美捷测序级 II，纯化胰蛋白酶化验程序&文献参考
    UG\NX二次开发 实时查看 NX 日志文件
    理解MTU VLAN与端口VLAN两个概念
    远程运维如何更高效的远程管理？向日葵的这几项功能会帮到你
    【附源码】Python计算机毕业设计网上购物平台
    Nested loop（PostgreSQL 14 Internals翻译版）
  • 原文地址：https://blog.csdn.net/yang1fei2/article/details/125032738