使用jsoncpp封装的Json序列化和反序列化的工具类

C++序列化和反序列化json需要写的代码实在是太多了,太过于臃肿了.
相比较其他的语言,如:js,php等.如果在其他语言里面用过json,再在c++里面来使用,那种感觉会是非常无奈的,而且抗拒的.
怎么说呢,勉强的还是能用的吧.凑合用吧.

JsonSerializer.h

/**********************************************************************
* Copyright (C) 2015 - tx7do - All Rights Reserved
*
* 文件名称:        JsonSerializer.h
* 摘    要:        Json序列化工具
*
* 作    者:        yanglinbo, 
* 修    改:        查看文件最下方.
* 
***********************************************************************/

#ifndef __JsonSerializer_H__
#define __JsonSerializer_H__

#include <assert.h>
#include <vector>
#include <json/json.h>

typedef signed __int8           int8;
typedef unsigned __int8         uint8;
typedef signed __int16          int16;
typedef unsigned __int16        uint16;
typedef signed __int32          int32;
typedef unsigned __int32        uint32;
typedef signed __int64          int64;
typedef unsigned __int64        uint64;

class JsonSerializer
{
public:
    JsonSerializer();
    virtual~JsonSerializer();

    JsonSerializer& operator=(const JsonSerializer& other)
    {
        return *this;
    }

public:
    /// 序列化
    virtual const char* serialized() = 0;

    /// 反序列化
    virtual bool deserialize(const char* data, size_t size) = 0;

public:
    /// 清除缓存
    void clearBuffer();

    void resetReadPos() { readPos = 0; }
    void resetWritePos() { writePos = 0; }
    void resetPosition() { resetReadPos(); resetWritePos(); }

    /// 刷新json字符串
    const char* flush();

    /// 刷新成风格化的json字符串
    const std::string& style_flush();

    /// 是否具有该键
    bool isKeyValid(const std::string& key) const;
    bool isKeyValid(const char* key) const;

    /// 获取json字符串
    const std::string& getString() const { return document; }

public:
    /// 当开关打开的时候,所有的数据序列化为数组.
    void toArray() { bToArray = true; }

    /// 当开关打开的时候,序列化的json字符串将被zip压缩.解序列化之前,将会被zip解压缩.
    void enableZip() {  bEnableZip = true; }

public:
    void append(const std::string& key, const int8& value);

    void append(const std::string& key, const int16& value);

    void append(const std::string& key, const int32& value);

    void append(const std::string& key, const int64& value);

    void append(const std::string& key, const uint8& value);

    void append(const std::string& key, const uint16& value);

    void append(const std::string& key, const uint32& value);

    void append(const std::string& key, const uint64& value);

    /// 
    void append(const std::string& key, const float& value);

#ifdef _VECTOR_
    template <typename T>
        void append(const std::string& key, const std::vector<T>& value)
    {
        Json::Value arrayObj;

        if (!value.empty())
        {
            typename std::vector<T>::const_iterator iter    = value.begin();
            typename std::vector<T>::const_iterator& iEnd    = value.end();
            for (; iter != iEnd; ++iter)
            {
                arrayObj.append( *iter );
            }
        }
        else
        {
            arrayObj.resize(0);
        }

        if (bToArray || key.empty())
        {
            root.append(arrayObj);
        }
        else
        {
            root[key] = arrayObj;
        }

        if (bFlushNow) flush();
    }

    template <typename T>
        void appendEx(const std::string& key, std::vector<T>& value)
    {
        Json::Value arrayObj;

        if (!value.empty())
        {
            typename std::vector<T>::iterator iter    = value.begin();
            typename std::vector<T>::iterator& iEnd    = value.end();
            for (; iter != iEnd; ++iter)
            {
                T& current_value = *iter;
                current_value.clearBuffer();
                current_value.serialized();
                arrayObj.append( current_value.root );
            }
        }
        else
        {
            arrayObj.resize(0);
        }

        if (bToArray || key.empty())
        {
            root.append(arrayObj);
        }
        else
        {
            root[key] = arrayObj;
        }

        if (bFlushNow) flush();
    }

    template <typename V>
        bool read(const std::string& key, std::vector<V>& value)
    {
        Json::Value& arrayObj = bToArray ? root[readPos++] : root[key];

        value.clear();
        Json::Value::iterator iter = arrayObj.begin();
        Json::Value::iterator iEnd = arrayObj.end();
        for (; iter!=iEnd; ++iter)
        {
            value.push_back(readValue(*iter, V()));
        }
        return true;
    }

    template <typename V>
        bool readEx(const std::string& key, std::vector<V>& value)
    {
        Json::Value& arrayObj = bToArray ? root[readPos++] : root[key];

        value.clear();
        V vObj;
        Json::Value::iterator iter = arrayObj.begin();
        Json::Value::iterator iEnd = arrayObj.end();
        for (; iter!=iEnd; ++iter)
        {
            Json::Value& current_value = *iter;
            vObj.clearBuffer();
            vObj.root = current_value;
            vObj.deserialize(NULL, 0);
            value.push_back(vObj);
        }
        return true;
    }
#endif

#ifdef _LIST_
    template <typename T>
        void append(const std::string& key, const std::list<T>& value)
    {
        Json::Value arrayObj;

        if (!value.empty())
        {
            typename std::list<T>::const_iterator iter    = value.begin();
            typename std::list<T>::const_iterator& iEnd    = value.end();
            for (; iter != iEnd; ++iter)
            {
                arrayObj.append(*iter);
            }
        }
        else
        {
            arrayObj.resize(0);
        }

        if (bToArray || key.empty())
        {
            root.append(arrayObj);
        }
        else
        {
            root[key] = arrayObj;
        }

        if (bFlushNow) flush();
    }
    template <typename V>
        bool read(const std::string& key, std::list<V>& value)
    {
        Json::Value& arrayObj = bToArray ? root[readPos++] : root[key];

        value.clear();
        Json::Value::const_iterator iter = arrayObj.begin();
        Json::Value::const_iterator iEnd = arrayObj.end();
        for (; iter!=iEnd; ++iter)
        {
            value.push_back(read(*iter));
        }
    }
#endif

#ifdef _MAP_
    template <typename K, typename V>
        void append(const std::string& key, const std::map<K, V>& value)
    {
        Json::Value arrayObj;

        typename std::map<K, V>::const_iterator iter    = value.begin();
        typename std::map<K, V>::const_iterator& iEnd    = value.end();
        for (; iter != iEnd; ++iter)
        {
            arrayObj[iter->first] = (iter->second);
        }

        if (bToArray || key.empty())
        {
            root.append(arrayObj);
        }
        else
        {
            root[key] = arrayObj;
        }

        if (bFlushNow) flush();
    }
    template <typename K, typename V>
        bool read(const std::string& key, std::map<K, V>& value)
    {
        Json::Value arrayObj = root[key];

        value.clear();
    }
#endif

#ifdef _XSTRING_
    void append(const std::string& key, const std::string& value)
    {
        if (bToArray || key.empty())
        {
            root.append(value);
        }
        else
        {
            root[key] = value;
        }

        if (bFlushNow) flush();
    }
#endif

    void append(const std::string& key, JsonSerializer& value);

public:
    bool parse(const char* str, size_t size);

    bool read(const std::string& key, bool& value);

    bool read(const std::string& key, int8& value);
    int8 readValue(const Json::Value& v, int8 def=0) const;

    bool read(const std::string& key, int16& value);
    int16 readValue(const Json::Value& v, int16 def=0) const;

    bool read(const std::string& key, int32& value);
    int32 readValue(const Json::Value& v, int32 def=0) const;

    bool read(const std::string& key, int64& value);
    int64 readValue(const Json::Value& v, int64 def=0) const;

    bool read(const std::string& key, uint8& value);
    uint8 readValue(const Json::Value& v, uint8 def=0) const;

    bool read(const std::string& key, uint16& value);
    uint16 readValue(const Json::Value& v, uint16 def=0) const;

    bool read(const std::string& key, uint32& value);
    uint32 readValue(const Json::Value& v, uint32 def=0) const;

    bool read(const std::string& key, uint64& value);
    uint64 readValue(const Json::Value& v, uint64 def=0) const;

    bool read(const std::string& key, float& value);
    float readValue(const Json::Value& v, float def=0) const;

    bool read(const std::string& key, char* value);

#ifdef _XSTRING_
    bool read(const std::string& key, std::string& value)
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asCString();

        return true;
    }
    std::string readValue(const Json::Value& v, std::string def="") const
    {
        try
        {
            return v.asCString();
        }
        catch ()
        {
            TRACE("Json读取未知异常.\n");
            return def;
        }
        return def;
    }
#endif

    bool read(const std::string& key, time_t& value);

    template <typename T>
    void readObj(const std::string& key, T& value)
    {
        Json::Value& obj = (bToArray || key.empty()) ? root[readPos++] : root[key];
        value.root = obj;
        value.deserialize();
    }

private:
    size_t get_temp_buffer_size(const size_t src_length);

public:
    Json::FastWriter    writer;
    Json::Reader        reader;
    Json::Value            root;

    std::string            document;        ///< json字符串

    bool                bFlushNow;        ///< 立即刷新json字符串
    bool                bEnableZip;        ///< 将json字符串压缩/解压缩成zip格式
    bool                bToArray;        ///< 序列化成数组

    std::vector<uint8>    zipBuffer;

    int                    readPos;        ///< 数组读取索引
    int                    writePos;        ///< 数组写入索引
};

#define OUTPUT_JSON_LEN(MSG) printf("字符串长度:%d\n", MSG.getString().length());
#define OUTPUT_STYLE_JSON(MSG) printf(MSG.style_flush().c_str());
#define OUTPUT_JSON(MSG) printf(MSG.getString().c_str());

#define TEST_SERIALIZE(MSG) MSG.serialized(); OUTPUT_JSON_LEN(MSG); OUTPUT_STYLE_JSON(MSG);

#endif

JsonSerializer.cpp

/**********************************************************************
* Copyright (C) 2015 - tx7do - All Rights Reserved
*
* 文件名称:        JsonSerializer.cpp
* 摘    要:        Json序列化工具
*
* 作    者:        yanglinbo, 
* 修    改:        查看文件最下方.
* 
***********************************************************************/

#include "Stdafx.h"
#include "JsonSerializer.h"
#include <json/json.h>
#include <zip.h>
#include <unzip.h>

#ifdef _DEBUG
#    pragma comment(lib, "json_vc71_libmtd.lib")
#    pragma comment(lib, "zlib1d.lib")
#else
#    pragma comment(lib, "json_vc71_libmt.lib")
#    pragma comment(lib, "zlib1.lib")
#endif

JsonSerializer::JsonSerializer() : bFlushNow(false)
, bEnableZip(false)
, bToArray(false)
, readPos(0)
, writePos(0)
{
    //writer = new Json::FastWriter;
    //reader = new Json::Reader;
    //root = new Json::Value;
}

JsonSerializer::~JsonSerializer()
{
    //safe_delete(writer);
    //safe_delete(reader);
    //safe_delete(root);
}

void JsonSerializer::clearBuffer()
{
    root.clear();
    flush();
    document.clear();

    resetPosition();
}

const char* JsonSerializer::flush()
{
    document.clear();
    document = writer.write(root);
    if (bEnableZip)
    {
        if (zipBuffer.size() < document.length())
        {
            zipBuffer.resize(document.length());
        }

        uLong comprLen = (uLong) zipBuffer.size();
        int err = compress(&zipBuffer[0], &comprLen, (const Bytef*)document.c_str(), (uLong)document.length());
        //TRACE("压缩长度:%d\n", comprLen);
        document.assign((const char*)&zipBuffer[0], comprLen);
    }
    return document.c_str();
}

const std::string& JsonSerializer::style_flush()
{
    flush();
    Json::StyledWriter style_writer;
    Json::Reader style_reader;
    style_reader.parse( document, root );
    document = style_writer.write( root );
    return document;
}

bool JsonSerializer::isKeyValid(const std::string& key) const
{
    return !root[key].isNull();
}

bool JsonSerializer::isKeyValid(const char* key) const
{
    return !root[key].isNull();
}

void JsonSerializer::append(const std::string& key, const int8& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const int16& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const int32& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const int64& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const uint8& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const uint16& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const uint32& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const uint64& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const float& value)
{
    char buffer[64] = {0};

#if _MSC_VER > 1310
    int result = _snprintf_s(buffer, sizeof (buffer), "%.2f", value);
#else
    int result = _snprintf(buffer, sizeof (buffer), "%.2f", value);
#endif
    if (result==sizeof(buffer) || result<0)
    {
        buffer[sizeof(buffer)-1] = 0;
    }

    if (bToArray || key.empty())
    {
        root.append(buffer);
    }
    else
    {
        root[key] = buffer;
    }

    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, JsonSerializer& value)
{
    value.serialized();

    if (bToArray || key.empty())
    {
        root.append(value.root);
    }
    else
    {
        root[key] = value.root;
    }

    if (bFlushNow) flush();
}

bool JsonSerializer::parse(const char* str, size_t size)
{
    if (bEnableZip)
    {
        uLong uncomprLen = (uLong)get_temp_buffer_size(size + 1);
        if (zipBuffer.size() < uncomprLen)
        {
            zipBuffer.resize(uncomprLen);
        }
        Byte* uncompr = &zipBuffer[0];

        ZeroMemory(uncompr, uncomprLen);
        int err = uncompress(uncompr, &uncomprLen, (const Byte*)str, (uLong)size);

        str = (const char*) uncompr;
        size = uncomprLen;
    }

    if (!reader.parse(str, str+size, root, false))
    {
        std::string strError = reader.getFormatedErrorMessages();
        TRACE("解析错误:[%s]\n", strError.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, bool& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asBool();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, int8& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, int16& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, int32& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, int64& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asInt64();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, uint8& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asUInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, uint16& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asUInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, uint32& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asUInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, uint64& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asUInt64();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, float& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;
        if (v.isString())
        {
            const char* str = 0;
            str = v.asCString();
            if (str == NULL) return false;

            char temp = 0;
#if _MSC_VER > 1310
            sscanf_s(str, " %g", &value, &temp);
#else
            sscanf(str, " %g", &value, &temp);
#endif
            return true;
        }
        else if (v.isDouble())
        {
            value = v.asFloat();
            return true;
        }
        else if (v.isInt())
        {
            value = (float) v.asInt();
        }
        else if (v.isUInt())
        {
            value = (float) v.asUInt();
        }
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, TCHAR* value)
{
    if (value == NULL) return false;

    try
    {
        const char* str = NULL;
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        str = v.asCString();

        if (str == NULL) return false;

        strncpy(value, str, strlen(str));
        //value[str.length()+1] = '\0';.
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, time_t& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

size_t JsonSerializer::get_temp_buffer_size(const size_t src_length)
{
    const size_t MB = 1024 * 1024;
    if (src_length < 1*MB)
    {
        return 1*MB;
    }
    else if ((src_length >= 1*MB) && (src_length < 8*MB))
    {
        return 8*MB;
    }
    else
    {
        return 16*MB;
    }
}

int8 JsonSerializer::readValue(const Json::Value& v, int8 def/*=0*/) const
{
    try
    {
        return v.asInt();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

int16 JsonSerializer::readValue(const Json::Value& v, int16 def/*=0*/) const
{
    try
    {
        return v.asInt();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

int32 JsonSerializer::readValue(const Json::Value& v, int32 def/*=0*/) const
{
    try
    {
        return v.asInt();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

int64 JsonSerializer::readValue(const Json::Value& v, int64 def/*=0*/) const
{
    try
    {
        return v.asInt64();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

uint8 JsonSerializer::readValue(const Json::Value& v, uint8 def/*=0*/) const
{
    try
    {
        return v.asUInt();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

uint16 JsonSerializer::readValue(const Json::Value& v, uint16 def/*=0*/) const
{
    try
    {
        return v.asUInt();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

uint32 JsonSerializer::readValue(const Json::Value& v, uint32 def/*=0*/) const
{
    try
    {
        return v.asUInt();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

uint64 JsonSerializer::readValue(const Json::Value& v, uint64 def/*=0*/) const
{
    try
    {
        return v.asUInt64();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

float JsonSerializer::readValue(const Json::Value& v, float def/*=0*/) const
{
    try
    {
        float value = 0;

        if (v.isString())
        {
            const char* str = 0;
            str = v.asCString();
            if (str == NULL) return false;

            char temp = 0;
#if _MSC_VER > 1310
            sscanf_s(str, " %g", &value, &temp);
#else
            sscanf(str, " %g", &value, &temp);
#endif
            return value;
        }
        else if (v.isNumeric())
        {
            value = v.asFloat();
            return value;
        }
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

测试1

struct TestData1 : public JsonSerializer
{
    time_t        nServerTime;

    TestData1()
    {
        clear();
    }

    void clear()
    {
        nServerTime = 0;
    }

    /// 序列化
    virtual const char* serialized()
    {
        clearBuffer();
        append(_T("time"), nServerTime);
        return flush();
    }

    /// 反序列化
    virtual bool deserialize(const char* str, size_t size)
    {
        if (str != NULL && size != 0)
        {
            if (!parse(str, size)) return false;
        }

        read(_T("time"), nServerTime);

        return true;
    }
};

void test1()
{
    // 序列化
    TestData1 data1;
    data1.nServerTime = time(0);
    data1.serialized();
    OUTPUT_STYLE_JSON(data1);

    // 反序列化
    TestData1 data2;
    std::string strJson = "{\"time\" : 1481207292 }";
    data2.deserialize(strJson.c_str(), strJson.length());
    printf("time :%d\n", data2.nServerTime);
}

测试2

struct TestData2 : public JsonSerializer
{
    time_t        nServerTime;
    std::vector<int32> arrInt;
    std::string strTest;

    TestData2()
    {
        clear();
    }

    void clear()
    {
        nServerTime = 0;
        arrInt.clear();
        strTest.clear();
    }

    /// 序列化
    virtual const char* serialized()
    {
        clearBuffer();
        append(_T("time"), nServerTime);
        append(_T("ints"), arrInt);
        append(_T("str"), strTest);
        return flush();
    }

    /// 反序列化
    virtual bool deserialize(const char* str, size_t size)
    {
        if (str != NULL && size != 0)
        {
            if (!parse(str, size)) return false;
        }

        read(_T("time"), nServerTime);
        read(_T("ints"), arrInt);
        read(_T("str"), strTest);

        return true;
    }
};

void test2()
{
    // 序列化
    TestData2 data1;
    data1.nServerTime = time(0);
    data1.arrInt.push_back(1);
    data1.arrInt.push_back(2);
    data1.arrInt.push_back(3);
    data1.arrInt.push_back(4);
    data1.strTest = "序列化字符串";

    data1.serialized();
    OUTPUT_STYLE_JSON(data1);
}

测试执行两个测试的结果大概如下:

注意:
1.依赖zlib,在第三方库里面拷贝zlib1d.dll到bin目录;
2.jsoncpp的lib我嫌太大了,就删掉了,需要自行编译.

时间： 2024-11-20 23:41:13

使用jsoncpp封装的Json序列化和反序列化的工具类的相关文章

PHP中SERIALIZE和JSON序列化与反序列化的区别

在PHP中,serialize和json两种方式对一个对象或数组进行序列化或反序列化有什么区别呢? 假设一个对象和一个数组: $web = new stdClass; $web->site = 'tantengvip'; $web->owner = 'tuntun'; $web->age = 5; 和 $web = array(); $web['site'] = 'tantengvip'; $web['owner'] = 'tuntun'; $web['age'] = 5; 对它们分别用

C# XML和JSON 序列化与反序列化

1.JSON的序列化与反序列化     JSON(JavaScript Object Notation)是一种轻量级的数据交换语言,它虽然是JavaScript的一个子集,但它是独立于语言的文本格式.它的数据格式比较简单,易于读写,且都是压缩的,占用带宽小且易于解析,通常会用JSON格式来传输数据或者用于数据存储.有关JSON数据结构语法的更多知识大家可以在网上其它的地方进行了解,我们只要记住在服务端向客户端传输数据时经常使用它,然后对它的序列化和反序列化非常值得了解就ok了.序列化的过程就是把

JSON序列化与反序列化

以下是对JSON序列化与反序列化进行了详细的分析介绍,需要的朋友可以过来参考下   方法一:引入System.Web.Script.Serialization命名空间使用 JavaScriptSerializer类实现简单的序列化序列化类:Personnel 复制代码 代码如下:     public class Personnel         {             public int Id { get; set; }             public string Name {

asp.net JSON序列化与反序列化使用

  对JSON数据进行序列化和反序列化 可以使用DataContractJsonSerializer类将类型实例序列化为JSON字符串,并将JSON字符串反序列化为类型实例. DataContractJsonSerializer在System.Runtime.Serialization.Json命名空间下,.NET Framework 3.5包含在System.ServiceModel.Web.dll中,需要添加对其的引用;.NET Framework 4在System.Runtime.Seri

C#实现的json序列化和反序列化代码实例

  这篇文章主要介绍了C#实现的json序列化和反序列化代码实例,本文讲解了两种实现方法,并直接给出代码示例,需要的朋友可以参考下 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

Json序列化和反序列化方法解析

 本篇文章主要是对Json序列化和反序列化方法进行了介绍,需要的朋友可以过来参考下,希望对大家有所帮助  代码如下:  /// <summary>         /// Json序列化,用于发送到客户端         /// </summary>         public static string ToJsJson(this object item)         {               DataContractJsonSerializer serializer

C#JSON序列化与反序列化

原文:C#JSON序列化与反序列化 windows phone学习也有一段时间了,想要做一个新闻客户端练练手,于是就在网上找看有没有接口之类.在天狗播客找到了热点热词新闻资讯API开放接口,接口提供的是JSON格式的数据,由于之前没用过JSON,于是就在网上各种查.技术讨论群上各种问...... 废话不多说了,下面把我收获分享出来.望像我一样的小白少走弯路. 一个实体类 public class NewsModel { public string Title { get; set; } publ

windows phone8.1：Xml,Json序列化和反序列化

原文:windows phone8.1:Xml,Json序列化和反序列化 小梦本例主要实现以下四点内容: 将Car对象序列化为xml 将Car对象序列化为Json 将xml反序列化为Car对象 将json反序列化为json对象 Car类如下: [task]public class Car{public int Id { get; set; }public string Make { get; set; }public string Model { get; set; }public int Ye

asp.net JSON序列化与反序列化使用说明

对JSON数据进行序列化和反序列化 可以使用DataContractJsonSerializer类将类型实例序列化为JSON字符串,并将JSON字符串反序列化为类型实例. DataContractJsonSerializer在System.Runtime.Serialization.Json命名空间下,.NET Framework 3.5包含在System.ServiceModel.Web.dll中,需要添加对其的引用:.NET Framework 4在System.Runtime.Serial