引言：

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.
    /*! Need to destruct elements of array, members of object, or copy-string.
    */
    ~GenericValue() {
        if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
            switch(flags_) {
            case kArrayFlag:
                for (GenericValue* v = data_.a.elements; v != data_.a.elements + data_.a.size; ++v)
                    v->~GenericValue();
                Allocator::Free(data_.a.elements);
                break;

            case kObjectFlag:
                for (Member* m = data_.o.members; m != data_.o.members + data_.o.size; ++m) {
                    m->name.~GenericValue();
                    m->value.~GenericValue();
                }
                Allocator::Free(data_.o.members);
                break;

            case kCopyStringFlag:
                Allocator::Free(const_cast<Ch*>(data_.s.str));
                break;
            }
        }
    }

    //@}

    //!@name Assignment operators
    //@{

    //! Assignment with move semantics.
    /*! \param rhs Source of the assignment. It will become a null value after assignment.
    */
    GenericValue& operator=(GenericValue& rhs) {
        RAPIDJSON_ASSERT(this != &rhs);
        this->~GenericValue();
        memcpy(this, &rhs, sizeof(GenericValue));
        rhs.flags_ = kNullFlag;
        return *this;
    }

    //! Assignment with primitive types.
    /*! \tparam T Either Type, int, unsigned, int64_t, uint64_t, const Ch*
        \param value The value to be assigned.
    */
    template <typename T>
    GenericValue& operator=(T value) {
        this->~GenericValue();
        new (this) GenericValue(value);
        return *this;
    }
    //@}

    //!@name Type
    //@{

    Type GetType()  const { return static_cast<Type>(flags_ & kTypeMask); }
    bool IsNull()   const { return flags_ == kNullFlag; }
    bool IsFalse()  const { return flags_ == kFalseFlag; }
    bool IsTrue()   const { return flags_ == kTrueFlag; }
    bool IsBool()   const { return (flags_ & kBoolFlag) != 0; }
    bool IsObject() const { return flags_ == kObjectFlag; }
    bool IsArray()  const { return flags_ == kArrayFlag; }
    bool IsNumber() const { return (flags_ & kNumberFlag) != 0; }
    bool IsInt()    const { return (flags_ & kIntFlag) != 0; }
    bool IsUint()   const { return (flags_ & kUintFlag) != 0; }
    bool IsInt64()  const { return (flags_ & kInt64Flag) != 0; }
    bool IsUint64() const { return (flags_ & kUint64Flag) != 0; }
    bool IsDouble() const { return (flags_ & kDoubleFlag) != 0; }
    bool IsString() const { return (flags_ & kStringFlag) != 0; }

    //@}

    //!@name Null
    //@{

    GenericValue& SetNull() { this->~GenericValue(); new (this) GenericValue(); return *this; }

    //@}

    //!@name Bool
    //@{

    bool GetBool() const { RAPIDJSON_ASSERT(IsBool()); return flags_ == kTrueFlag; }
    GenericValue& SetBool(bool b) { this->~GenericValue(); new (this) GenericValue(b); return *this; }

    //@}

    //!@name Object
    //@{

    //! Set this value as an empty object.
    GenericValue& SetObject() { this->~GenericValue(); new (this) GenericValue(kObjectType); return *this; }

    //! Get the value associated with the object's name.
    GenericValue& operator[](const Ch* name) {
        if (Member* member = FindMember(name))
            return member->value;
        else {
            static GenericValue NullValue;
            return NullValue;
        }
    }
    const GenericValue& operator[](const Ch* name) const { return const_cast<GenericValue&>(*this)[name]; }

    //! Member iterators.
    ConstMemberIterator MemberBegin() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.members; }
    ConstMemberIterator MemberEnd() const   { RAPIDJSON_ASSERT(IsObject()); return data_.o.members + data_.o.size; }
    MemberIterator MemberBegin()            { RAPIDJSON_ASSERT(IsObject()); return data_.o.members; }
    MemberIterator MemberEnd()              { RAPIDJSON_ASSERT(IsObject()); return data_.o.members + data_.o.size; }

    //! Check whether a member exists in the object.
    bool HasMember(const Ch* name) const { return FindMember(name) != 0; }

    //! Add a member (name-value pair) to the object.
    /*! \param name A string value as name of member.
        \param value Value of any type.
        \param allocator Allocator for reallocating memory.
        \return The value itself for fluent API.
        \note The ownership of name and value will be transfered to this object if success.
    */
    GenericValue& AddMember(GenericValue& name, GenericValue& value, Allocator& allocator) {
        RAPIDJSON_ASSERT(IsObject());
        RAPIDJSON_ASSERT(name.IsString());
        Object& o = data_.o;
        if (o.size >= o.capacity) {
            if (o.capacity == 0) {
                o.capacity = kDefaultObjectCapacity;
                o.members = (Member*)allocator.Malloc(o.capacity * sizeof(Member));
            }
            else {
                SizeType oldCapacity = o.capacity;
                o.capacity *= 2;
                o.members = (Member*)allocator.Realloc(o.members, oldCapacity * sizeof(Member), o.capacity * sizeof(Member));
            }
        }
        o.members[o.size].name.RawAssign(name);
        o.members[o.size].value.RawAssign(value);
        o.size++;
        return *this;
    }

    GenericValue& AddMember(const Ch* name, Allocator& nameAllocator, GenericValue& value, Allocator& allocator) {
        GenericValue n(name, internal::StrLen(name), nameAllocator);
        return AddMember(n, value, allocator);
    }

    GenericValue& AddMember(const Ch* name, GenericValue& value, Allocator& allocator) {
        GenericValue n(name, internal::StrLen(name));
        return AddMember(n, value, allocator);
    }

    template <typename T>
    GenericValue& AddMember(const Ch* name, T value, Allocator& allocator) {
        GenericValue n(name, internal::StrLen(name));
        GenericValue v(value);
        return AddMember(n, v, allocator);
    }

    //! Remove a member in object by its name.
    /*! \param name Name of member to be removed.
        \return Whether the member existed.
        \note Removing member is implemented by moving the last member. So the ordering of members is changed.
    */
    bool RemoveMember(const Ch* name) {
        RAPIDJSON_ASSERT(IsObject());
        if (Member* m = FindMember(name)) {
            RAPIDJSON_ASSERT(data_.o.size > 0);
            RAPIDJSON_ASSERT(data_.o.members != 0);

            Member* last = data_.o.members + (data_.o.size - 1);
            if (data_.o.size > 1 && m != last) {
                // Move the last one to this place
                m->name = last->name;
                m->value = last->value;
            }
            else {
                // Only one left, just destroy
                m->name.~GenericValue();
                m->value.~GenericValue();
            }
            --data_.o.size;
            return true;
        }
        return false;
    }

    //@}

    //!@name Array
    //@{

    //! Set this value as an empty array.
    GenericValue& SetArray() {  this->~GenericValue(); new (this) GenericValue(kArrayType); return *this; }

    //! Get the number of elements in array.
    SizeType Size() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size; }

    //! Get the capacity of array.
    SizeType Capacity() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.capacity; }

    //! Check whether the array is empty.
    bool Empty() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size == 0; }

    //! Remove all elements in the array.
    /*! This function do not deallocate memory in the array, i.e. the capacity is unchanged.
    */
    void Clear() {
        RAPIDJSON_ASSERT(IsArray()); 
        for (SizeType i = 0; i < data_.a.size; ++i)
            data_.a.elements[i].~GenericValue();
        data_.a.size = 0;
    }

    //! Get an element from array by index.
    /*! \param index Zero-based index of element.
        \note
\code
Value a(kArrayType);
a.PushBack(123);
int x = a[0].GetInt();              // Error: operator[ is ambiguous, as 0 also mean a null pointer of const char* type.
int y = a[SizeType(0)].GetInt();    // Cast to SizeType will work.
int z = a[0u].GetInt();             // This works too.
\endcode
    */