Qt JSON数据解析和存储详解

引言：

21世纪是一个信息时代，更是一个网络全球化的时代，随着科学技术的发展，越来越多的App不光是需要和网络服务器进行数据传输和交互，也需要和其他 App 进行数据传递。承担App与网络来进行传输和存储数据的一般是XML或者JSON。在软件通信领域中XML和JSON扮演重要角。
最近一段时间，小编综合了之前在项目中对JSON的一些了解，参考了一些相关资料，把自己的一些思考融入了这篇总结文档中，同事尝试用通俗诙谐的语言风格来阐述，期望能给感兴趣的读者带来帮助。

为了不和时代落伍，我们必须积极响应和号召党的领导，所以必须要学习 JSON数据的解析和存储，其实很Easy的。

一、JSON

1.1、JSON是什么？
JSON(JavaScript Object Notation)是一种轻量级的数据交换格式。它基于JavaScript（Standard ECMA-262 3rd Edition - December 1999）的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C、C++、C#、Java、JavaScript、Perl、Python等）。这些特性使JSON成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成。

JSON是存储和交换文本信息的语法，类似XML。
JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。 这些特性使JSON成为理想的数据交换语言
1.2 、JSON格式
JSON构建于两种结构：
1.“名称/值”对的集合(A collection of name/value pairs)。不同的语言中，它被理解为对象（object），纪录（record），结构(struct)，字典(dictionary)，哈希表（hash table），有键列表(keyed list)，或者关联数组(associative array)。
2.值的有序列表(An ordered list of values)。在大多数语言中，它被理解为数组(array)、矢量(vector), 列表(list)或者是序列(sequence)。
JSON具有以下这些形式：
1.简单的一个 { ，，，，}。
2.里面有数组 { , [{,,},{,,}],}。
3.直接一个数组。
4.数组里有数组。
5.其他情况？ 没有吧，除非json数据不规范。
1.3、解析json数据常用方法
包括JSONObject、JSONArray、JSONStringer、JSONTokener、JSONWriter、JSONEx。

二、JSON解析

前面讲了那么多废话其实也是必须的“毕竟十万个为什么吗“，咱们今天主要讲JSON数据格式的解析，在这呢小编先给大家看一个咱们经常用到的JSON格式的数据，这是聚合官网中“全国天气预报”请求返回的数据格式，格式稍微有点复杂不过也是我们在项目中经常用到的JSON格式，大家都清楚JSON格式的数据是由对象和数组两者结合起来的，再怎么复杂也只有这两种的结合。
JSON数据样式：

详细解析：
(1)、首先我们从服务器请求数据，服务器返回的数据是一个封装好的JSON格式的字符串，我们将这个字符串临时保存下来以备后面解析用，这里我用到了c_str()函数，对此类型函数的详解见:string中c_str()、data()、copy(p,n)函数的用法
(2)、此代码主要用来定位每个名称，然后将对应名称的内容存储下来。

bool StructureFormatData::parseAlarmListJson(const QString& str,EntitiesBase* result,QString& message)
{
    std::string ss = ChineseTexttoStdstring(str);
    const char* json = ss.c_str();
    rapidjson::Document document;
    if (document.Parse<0>(json).HasParseError())
        return false;
    assert(document.IsObject());

    int code = 0;
    std::string mess = "";
    //add
    for(rapidjson::Document::Member* m = document.MemberBegin();m!=document.MemberEnd();++m)
    {
        std::string name = m->name.GetString();
        if(name == "code")
        {
            code = m->value.GetInt();
        }
        else if(name == "data")
        {
            for (rapidjson::SizeType i = 0; i < m->value.Size();++i)
            {
                AlarmEntity* ae = new AlarmEntity;
                for(rapidjson::Document::Member* m1 = m->value[rapidjson::SizeType(i)].MemberBegin();m1!=m->value[rapidjson::SizeType(i)].MemberEnd();++m1)
                {
                    parseAlarmJson(m1,ae);
                }
                result->addChild(ae);
            }
        }
        else if(name == "message")
        {
            std::string vs= m->value.GetString();
            message = QString::fromUtf8(vs.c_str());
        }
    }
    if(code !=1)
        return false;
    return true;
}

(3)、此代码是对json数据解析的一个封装，比较难以理解，而且代码比较长。

#ifndef RAPIDJSON_DOCUMENT_H_
#define RAPIDJSON_DOCUMENT_H_

#include "reader.h"
#include "strfunc.h"
#include <new>      // placement new

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4127) // conditional expression is constant
#endif

namespace rapidjson {

///
// GenericValue

//! Represents a JSON value. Use Value for UTF8 encoding and default allocator.
/*!
    A JSON value can be one of 7 types. This class is a variant type supporting
    these types.

    Use the Value if UTF8 and default allocator

    \tparam Encoding    Encoding of the value. (Even non-string values need to have the same encoding in a document)
    \tparam Allocator   Allocator type for allocating memory of object, array and string.
*/
#pragma pack (push, 4)
template <typename Encoding, typename Allocator = MemoryPoolAllocator<> > 
class GenericValue {
public:
    //! Name-value pair in an object.
    struct Member { 
        GenericValue<Encoding, Allocator> name;     //!< name of member (must be a string)
        GenericValue<Encoding, Allocator> value;    //!< value of member.
    };

    typedef Encoding EncodingType;                  //!< Encoding type from template parameter.
    typedef Allocator AllocatorType;                //!< Allocator type from template parameter.
    typedef typename Encoding::Ch Ch;               //!< Character type derived from Encoding.
    typedef Member* MemberIterator;                 //!< Member iterator for iterating in object.
    typedef const Member* ConstMemberIterator;      //!< Constant member iterator for iterating in object.
    typedef GenericValue* ValueIterator;            //!< Value iterator for iterating in array.
    typedef const GenericValue* ConstValueIterator; //!< Constant value iterator for iterating in array.

    //!@name Constructors and destructor.
    //@{
   

    //! Default constructor creates a null value.
    GenericValue() : flags_(kNullFlag) {}

    //! Copy constructor is not permitted.
private:
    GenericValue(const GenericValue& rhs);

public:

    //! Constructor with JSON value type.
    /*! This creates a Value of specified type with default content.
        \param type Type of the value.
        \note Default content for number is zero.
    */
    GenericValue(Type type) {
        static const unsigned defaultFlags[7] = {
            kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kConstStringFlag,
            kNumberFlag | kIntFlag | kUintFlag | kInt64Flag | kUint64Flag | kDoubleFlag
        };
        RAPIDJSON_ASSERT(type <= kNumberType);
        flags_ = defaultFlags[type];
        memset(&data_, 0, sizeof(data_));
    }

    //! Constructor for boolean value.
    GenericValue(bool b) : flags_(b ? kTrueFlag : kFalseFlag) {}

    //! Constructor for int value.
    GenericValue(int i) : flags_(kNumberIntFlag) { 
        data_.n.i64 = i;
        if (i >= 0)
            flags_ |= kUintFlag | kUint64Flag;
    }

    //! Constructor for unsigned value.
    GenericValue(unsigned u) : flags_(kNumberUintFlag) {
        data_.n.u64 = u; 
        if (!(u & 0x80000000))
            flags_ |= kIntFlag | kInt64Flag;
    }

    //! Constructor for int64_t value.
    GenericValue(int64_t i64) : flags_(kNumberInt64Flag) {
        data_.n.i64 = i64;
        if (i64 >= 0) {
            flags_ |= kNumberUint64Flag;
            if (!(i64 & 0xFFFFFFFF00000000LL))
                flags_ |= kUintFlag;
            if (!(i64 & 0xFFFFFFFF80000000LL))
                flags_ |= kIntFlag;
        }
        else if (i64 >= -2147483648LL)
            flags_ |= kIntFlag;
    }

    //! Constructor for uint64_t value.
    GenericValue(uint64_t u64) : flags_(kNumberUint64Flag) {
        data_.n.u64 = u64;
        if (!(u64 & 0x8000000000000000ULL))
            flags_ |= kInt64Flag;
        if (!(u64 & 0xFFFFFFFF00000000ULL))
            flags_ |= kUintFlag;
        if (!(u64 & 0xFFFFFFFF80000000ULL))
            flags_ |= kIntFlag;
    }

    //! Constructor for double value.
    GenericValue(double d) : flags_(kNumberDoubleFlag) { data_.n.d = d; }

    //! Constructor for constant string (i.e. do not make a copy of string)
    GenericValue(const Ch* s, SizeType length) { 
        RAPIDJSON_ASSERT(s != NULL);
        flags_ = kConstStringFlag;
        data_.s.str = s;
        data_.s.length = length;
    }

    //! Constructor for constant string (i.e. do not make a copy of string)
    GenericValue(const Ch* s) { SetStringRaw(s, internal::StrLen(s)); }

    //! Constructor for copy-string (i.e. do make a copy of string)
    GenericValue(const Ch* s, SizeType length, Allocator& allocator) { SetStringRaw(s, length, allocator); }

    //! Constructor for copy-string (i.e. do make a copy of string)
    GenericValue(const Ch*s, Allocator& allocator) { SetStringRaw(s, internal::StrLen(s), allocator); }

    //! Destructor.