2. 程式人生 > 其它 >C++實現對Json資料的友好處理

C++實現對Json資料的友好處理

阿新 • • 發佈：2022-02-11

背景

C/C++客戶端需要接收和傳送JSON格式的資料到後端以實現通訊和資料互動。C++沒有現成的處理JSON格式資料的介面，直接引用第三方庫還是避免不了拆解拼接。考慮到此專案將會有大量JSON資料需要處理，避免不了重複性的拆分拼接。所以打算封裝一套C++結構體物件轉JSON資料、JSON資料直接裝C++結構體物件的介面，類似於資料傳輸中常見的序列化和反序列化，以方便後續處理資料，提高開發效率。

設計

目標：

  1. 通過簡單介面就能將C++結構體物件例項轉換為JSON字串資料，或將一串JSON字串資料載入賦值到一個C++結構體物件例項。理想介面：Json2Object(inJsonString, outStructObject)
    ，或者Object2Json(inStructObject, outJsonString)
  2. 支援內建基本型別如bool，int，double的Json轉換，支援自定義結構體的Json轉換，支援上述型別作為元素陣列的Json轉換，以及支援巢狀的結構體的Json轉換

效果：

先上單元測試程式碼

TEST_CASE("解析結構體陣列到JSON串", "[json]")
{
    struct DemoChildrenObject
    {
        bool boolValue;
        int intValue;
        std::string strValue;
        /*JSON相互轉換成員變數宣告（必需）*/
        JSONCONVERT2OBJECT_MEMEBER_REGISTER(boolValue, intValue, strValue)
    };

    struct DemoObjct
    {
        bool boolValue;
        int intValue;
        std::string strValue;
        /*巢狀的支援JSON轉換的結構體成員變數，陣列形式*/
        std::vector< DemoChildrenObject> children;
        
        /*JSON相互轉換成員變數宣告（必需）*/
        JSONCONVERT2OBJECT_MEMEBER_REGISTER(boolValue, intValue, strValue, children)
    };

    DemoObjct demoObj;
    /*開始對demoObj物件的成員變數進行賦值*/
    demoObj.boolValue = true;
    demoObj.intValue = 321;
    demoObj.strValue = "hello worLd";

    DemoChildrenObject child1;
    child1.boolValue = true;
    child1.intValue = 1000;
    child1.strValue = "hello worLd child1";

    DemoChildrenObject child2;
    child2.boolValue = true;
    child2.intValue = 30005;
    child2.strValue = "hello worLd child2";

    demoObj.children.push_back(child1);
    demoObj.children.push_back(child2);
    /*結束對demoObj物件的成員變數的賦值*/

    std::string jsonStr;
    /*關鍵轉換函式*/
    REQUIRE(Object2Json(jsonStr, demoObj)); 
    std::cout << "returned json format: " << jsonStr << std::endl;

    /*列印的內容如下：
    returned json format: {
       "boolValue" : true,
       "children" : [
          {
             "boolValue" : true,
             "intValue" : 1000,
             "strValue" : "hello worLd child1"
          },
          {
             "boolValue" : true,
             "intValue" : 30005,
             "strValue" : "hello worLd child2"
          }
       ],
       "intValue" : 321,
       "strValue" : "hello worLd"
    }
    */
    
    DemoObjct demoObj2;
    /*關鍵轉換函式*/
    REQUIRE(Json2Object(demoObj2, jsonStr));

    /*校驗轉換後的結構體變數中各成員變數的內容是否如預期*/
    REQUIRE(demoObj2.boolValue == true);
    REQUIRE(demoObj2.intValue == 321);
    REQUIRE(demoObj2.strValue == "hello worLd");

    REQUIRE(demoObj2.children.size() == 2);

    REQUIRE(demoObj.children[0].boolValue == true);
    REQUIRE(demoObj.children[0].intValue == 1000);
    REQUIRE(demoObj.children[0].strValue == "hello worLd child1");

    REQUIRE(demoObj.children[1].boolValue == true);
    REQUIRE(demoObj.children[1].intValue == 30005);
    REQUIRE(demoObj.children[1].strValue == "hello worLd child2");
}

實現

本次我們只關注怎麼友好地在結構體與Json字串之間進行轉換，而不深入關注JSon字串具體如何與基本資料型別進行轉換。這個已經有不少的第三方庫幫我們解決這個問題，如cJSON、Jsoncpp、rapidjson，不必再重複造輪子。

此次我們選擇了JsonCPP作為底層的JSON解析支援，如果想替換成其他三方庫也比較簡單，修改對應嵌入的內容即可。

我們的目標是實現兩個介面：

  • Json2Object(inJsonString, outStructObject)

  • Object2Json(inStructObject, outJsonString)

結合JsonCPP自身定義的型別，我們進一步需要實現的是：

  • Json2Object(const Json::Value& jsonTypeValue, outStructObject)

  • Object2Json(inStructObject, const std::string& key, Json::Value& jsonTypeValue)

基本資料型別轉換

對於如bool、int、double、string等基本資料型別，該實現均較為簡單：

/*int 型別支援*/
static bool Json2Object(int& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isInt()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asInt();
        return true;
    }
}

static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, const int& value)
{
    jsonTypeValue[key] = value;
    return true;
}

/*std::string 字串型別支援*/
static bool Json2Object(std::string& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isString()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asString();
        return true;
    }
}

static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, const std::string& value)
{
    jsonTypeValue[key] = value;
    return true;
}

自定義資料結構型別

對於自定義的結構體型別，我們要做的就是要保證其成員變數能夠與JSON節點一一對應，並能夠匹配進行資料填充。

   /*Json字串：
   {
   "boolValue" : true,
   "intValue" : 1234,
   "strValue" : "demo object!"
   }*/

   struct DemoObjct
    {
        bool boolValue;
        int intValue;
        std::string strValue;
    };

如上面示例，在相互轉換過程中，"boolValue"能與DemoObjct物件中名為boolValue的成員變數對應，"strValue"與DemoObjct物件中名為strValue的成員變數對應。

正常情況下，對於這種場景，我們只能對DemoObjct結構體額外實現處理函式進行資料轉換，因不同的結構體宣告定義的成員變數都不一樣，所以針對每個結構體均需要單獨實現，工作繁瑣，不通用。

從這裡下手，我們要做的就是“隱藏”針對類結構體實現的轉換函式，利用語言自身的特性（函式模板等）讓他們幫我們去做這些事情。

  1. 宣告轉換成員函式，在這個成員函式實現裡，讓每個成員變數能從JSON原生資料中讀取或寫入值。
  2. 註冊成員變數，目的是讓轉換成員函式知道需要處理哪些成員變數，每個成員變數又對應JSON原生資料中的哪個節點欄位，以便匹配讀寫。
  3. 在外部呼叫Json2Object 和Object2Json函式時，觸發呼叫該轉換成員函式，以便填充或輸出成員變數的內容。

把大象裝進冰箱裡只需要三步，我們來看這三步怎麼走。

成員變數處理

  • 考慮到每個結構體的成員變數型別和數量不可控，並且需要將每個成員變數作為左值（Json2Object時），不能簡單採用陣列列舉方式處理，可以採用C++11的特性——可變引數模板，從裡到外遍歷處理每個成員變數
template <typename T>
static bool JsonParse(const std::vector<std::string>& names, int index, const Json::Value& jsonTypeValue, T& arg)
{
    const auto key = names[index];
    if (!jsonTypeValue.isMember(key) || Json2Object(arg, jsonTypeValue[key])) {
        return true;
    } else {
        return false;
    }
}

template <typename T, typename... Args>
static bool JsonParse(const std::vector<std::string>& names, int index, const Json::Value& jsonTypeValue, T& arg, Args&... args)
{
    if (!JsonParse(names, index, jsonTypeValue, arg)) {
        return false;
    } else {
        return JsonParse(names, index + 1, jsonTypeValue, args...);
    }
}
  • 成員變數與JSON原生節點key欄位有對應關係，初步先簡單考慮，將成員變數名稱先視為JSON中對應節點的key名稱。這個可以通過巨集定義的特性實現，將宣告註冊的成員變數內容作為字串拆分出key名稱列表。
#define JSONCONVERT2OBJECT_MEMEBER_REGISTER(...)  \
bool ParseHelpImpl(const Json::Value& jsonTypeValue)
{
    std::vector<std::string> names = Member2KeyParseWithStr(#__VA_ARGS__);
    return JsonParse(names, 0, jsonTypeValue, __VA_ARGS__);
}

成員變數註冊

例如DemoObjct這個類結構體，新增JSONCONVERT2OBJECT_MEMEBER_REGISTER並帶上成員變數的註冊宣告：

   struct DemoObjct
    {
        bool boolValue;
        int intValue;
        std::string strValue;
       
       JSONCONVERT2OBJECT_MEMEBER_REGISTER(boolValue, intValue, strValue)
           
    };

等同於：

   struct DemoObjct
    {
        bool boolValue;
        int intValue;
        std::string strValue;
       
       bool ParseHelpImpl(const Json::Value& jsonTypeValue, 
                          std::vector<std::string> &names)
        {
            names = Member2KeyParseWithStr("boolValue, intValue, strValue");
            //names 得到 ["boolValue","intValue", "strValue"]
            //然後帶著這些key逐一從Json中取值賦值到成員變數中
            return JsonParse(names, 0, jsonTypeValue, boolValue, intValue, strValue);
        }      
    };

模板匹配防止編譯報錯

到目前為止，核心的功能已經實現。如果目標結構體類未新增JSON轉換的宣告註冊，外部在使用Json2Object介面時會導致編譯報錯，提示找不到ParseHelpImpl這個成員函式的宣告定義……，我們可以採用enable_if來給未宣告註冊巨集的結構體提供預設函式。

template <typename TClass, typename enable_if<HasConverFunction<TClass>::has, int>::type = 0>
static inline bool Json2Object(TClass& aimObj, const Json::Value& jsonTypeValue)
{
    std::vector<std::string> names = PreGetCustomMemberNameIfExists(aimObj);
    return aimObj.JSONCONVERT2OBJECT_MEMEBER_REGISTER_RESERVERD_IMPLE(jsonTypeValue, names);
}

template <typename TClass, typename  enable_if<!HasConverFunction<TClass>::has, int>::type = 0>
static inline bool Json2Object(TClass& aimObj, const Json::Value& jsonTypeValue)
{
    return false;
}

成員變數匹配Key重新命名

目前的實現均為將成員變數的名稱作為JSON串中的Key名稱，為靈活處理，再補充一個巨集用於重新宣告結構體成員變數中對應到JSON串中的key，例如：

    struct DemoObjct
    {
        bool boolValue;
        int intValue;
        std::string strValue;

        JSONCONVERT2OBJECT_MEMEBER_REGISTER(boolValue, intValue, strValue)
        /*重新宣告成員變數對應到JSON串的key，注意順序一致*/
        JSONCONVERT2OBJECT_MEMEBER_RENAME_REGISTER("bValue", "iValue", "sValue")
    };

    DemoObjct demoObj;
    /*boolValue <--> bValue; intValue <--> iValue; ...*/
    REQUIRE(Json2Object(demoObj, std::string("{\"bValue\":true, \"iValue\":1234, \"sValue\":\"demo object!\"}")));
    REQUIRE(demoObj.boolValue == true);
    REQUIRE(demoObj.intValue == 1234);
    REQUIRE(demoObj.strValue == "demo object!");

Object2Json實現

上面提到為大多為實現Json2Object介面所提供的操作，從結構體物件轉成Json也是類似的操作，這裡就不再闡述，詳細可參考原始碼。

亮點

  • 簡化C++對JSON資料的處理，遮蔽注意拆分處理JSON資料的操作；
  • 提供簡易介面，從結構體到JSON串、JSON串轉結構體切換自如

原始碼



#include "json/json.h"
#include <string>
#include <vector>
#include <initializer_list>

#define JSONCONVERT2OBJECT_MEMEBER_REGISTER(...)  \
bool JSONCONVERT2OBJECT_MEMEBER_REGISTER_RESERVERD_IMPLE(const Json::Value& jsonTypeValue, std::vector<std::string> &names) \
{     \
    if(names.size() <= 0)  { \
        names = Member2KeyParseWithStr(#__VA_ARGS__); \
    }   \
    return JsonParse(names, 0, jsonTypeValue, __VA_ARGS__); \
}   \
bool OBJECTCONVERT2JSON_MEMEBER_REGISTER_RESERVERD_IMPLE(Json::Value& jsonTypeValue, std::vector<std::string> &names) const \
{     \
    if(names.size() <= 0)  { \
        names = Member2KeyParseWithStr(#__VA_ARGS__); \
    }   \
    return ParseJson(names, 0, jsonTypeValue, __VA_ARGS__); \
}   \


#define JSONCONVERT2OBJECT_MEMEBER_RENAME_REGISTER(...)  \
std::vector<std::string> JSONCONVERT2OBJECT_MEMEBER_RENAME_REGISTER_RESERVERD_IMPLE() const \
{     \
    return Member2KeyParseWithMultiParam({ __VA_ARGS__ }); \
}

namespace JSON
{
template <bool, class TYPE = void>
struct enable_if
{
};

template <class TYPE>
struct enable_if<true, TYPE>
{
    typedef TYPE type;
};
} //JSON

template <typename T>
struct HasConverFunction
{
    template <typename TT>
    static char func(decltype(&TT::JSONCONVERT2OBJECT_MEMEBER_REGISTER_RESERVERD_IMPLE)); //@1
    
    template <typename TT>
    static int func(...); //@2

    const static bool has = (sizeof(func<T>(NULL)) == sizeof(char));

    template <typename TT>
    static char func2(decltype(&TT::JSONCONVERT2OBJECT_MEMEBER_RENAME_REGISTER_RESERVERD_IMPLE)); //@1
    template <typename TT>
    static int func2(...); //@2
    const static bool has2 = (sizeof(func2<T>(NULL)) == sizeof(char));
};

static std::vector<std::string> Member2KeyParseWithMultiParam(std::initializer_list<std::string> il)
{
    std::vector<std::string> result;
    for (auto it = il.begin(); it != il.end(); it++) {
        result.push_back(*it);
    }
    return result;
}

inline static std::string NormalStringTrim(std::string const& str)
{
    static char const* whitespaceChars = "\n\r\t ";
    std::string::size_type start = str.find_first_not_of(whitespaceChars);
    std::string::size_type end = str.find_last_not_of(whitespaceChars);
    return start != std::string::npos ? str.substr(start, 1 + end - start) : std::string();
}

inline static std::vector<std::string> NormalStringSplit(std::string str, char splitElem)
{
    std::vector<std::string> strs;
    std::string::size_type pos1, pos2;
    pos2 = str.find(splitElem);
    pos1 = 0;
    while (std::string::npos != pos2) {
        strs.push_back(str.substr(pos1, pos2 - pos1));
        pos1 = pos2 + 1;
        pos2 = str.find(splitElem, pos1);
    }
    strs.push_back(str.substr(pos1));
    return strs;
}

static std::vector<std::string> Member2KeyParseWithStr(const std::string& values)
{
    std::vector<std::string> result;
    auto enumValues = NormalStringSplit(values, ',');
    result.reserve(enumValues.size());
    for (auto const& enumValue : enumValues) {
        result.push_back(NormalStringTrim(enumValue));
    }
    return result;
}

//////////////////////////////////////////////////////////////////////////////

static bool Json2Object(bool& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isBool()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asBool();
        return true;
    }
}
static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, bool value)
{
    jsonTypeValue[key] = value;
    return true;
}

static bool Json2Object(int& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isInt()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asInt();
        return true;
    }
}
static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, const int& value)
{
    jsonTypeValue[key] = value;
    return true;
}

static bool Json2Object(unsigned int& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isUInt()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asUInt();
        return true;
    }
}
static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, const unsigned int& value)
{
    jsonTypeValue[key] = value;
    return true;
}

static bool Json2Object(double& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isDouble()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asDouble();
        return true;
    }
}
static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, const double& value)
{
    jsonTypeValue[key] = value;
    return true;
}

static bool Json2Object(std::string& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isString()) {
        return false;
    } else {
        aimObj = jsonTypeValue.asString();
        return true;
    }
}
static bool Object2Json(Json::Value& jsonTypeValue, const std::string& key, const std::string& value)
{
    jsonTypeValue[key] = value;
    return true;
}

template <typename TClass, typename JSON::enable_if<HasConverFunction<TClass>::has2, int>::type = 0>
static inline std::vector<std::string> PreGetCustomMemberNameIfExists(const TClass& aimObj)
{
    return aimObj.JSONCONVERT2OBJECT_MEMEBER_RENAME_REGISTER_RESERVERD_IMPLE();
}

template <typename TClass, typename JSON::enable_if<!HasConverFunction<TClass>::has2, int>::type = 0>
static inline std::vector<std::string> PreGetCustomMemberNameIfExists(const TClass& aimObj)
{
    return std::vector<std::string>();
}

template <typename TClass, typename JSON::enable_if<HasConverFunction<TClass>::has, int>::type = 0>
static inline bool Json2Object(TClass& aimObj, const Json::Value& jsonTypeValue)
{
    std::vector<std::string> names = PreGetCustomMemberNameIfExists(aimObj);
    return aimObj.JSONCONVERT2OBJECT_MEMEBER_REGISTER_RESERVERD_IMPLE(jsonTypeValue, names);
}

template <typename TClass, typename JSON::enable_if<!HasConverFunction<TClass>::has, int>::type = 0>
static inline bool Json2Object(TClass& aimObj, const Json::Value& jsonTypeValue)
{
    return false;
}

template <typename T>
static bool Json2Object(std::vector<T>& aimObj, const Json::Value& jsonTypeValue)
{
    if (jsonTypeValue.isNull() || !jsonTypeValue.isArray()) {
        return false;
    } else {
        aimObj.clear();
        bool result(true);
        for (int i = 0; i < jsonTypeValue.size(); ++i) {
            T item;
            if (!Json2Object(item, jsonTypeValue[i])) {
                result = false;
            }
            aimObj.push_back(item);
        }
        return result;
    }
}

template <typename T>
static bool JsonParse(const std::vector<std::string>& names, int index, const Json::Value& jsonTypeValue, T& arg)
{
    const auto key = names[index];
    if (!jsonTypeValue.isMember(key) || Json2Object(arg, jsonTypeValue[key])) {
        return true;
    } else {
        return false;
    }
}

template <typename T, typename... Args>
static bool JsonParse(const std::vector<std::string>& names, int index, const Json::Value& jsonTypeValue, T& arg, Args&... args)
{
    if (!JsonParse(names, index, jsonTypeValue, arg)) {
        return false;
    } else {
        return JsonParse(names, index + 1, jsonTypeValue, args...);
    }
}

/** Provider interface*/
template<typename TClass>
bool Json2Object(TClass& aimObj, const std::string& jsonTypeStr)
{
    Json::Reader reader;
    Json::Value root;

    if (!reader.parse(jsonTypeStr, root) || root.isNull()) {
        return false;
    }
    return Json2Object(aimObj, root);
}

static bool GetJsonRootObject(Json::Value& root, const std::string& jsonTypeStr)
{
    Json::Reader reader;
    if (!reader.parse(jsonTypeStr, root)) {
        return false;
    }
    return true;
}

////////////////////////////////////////////////////////////////////////

template <typename TClass, typename JSON::enable_if<HasConverFunction<TClass>::has, int>::type = 0>
static inline bool Object2Json(Json::Value& jsonTypeOutValue, const std::string& key, const TClass& objValue)
{
    std::vector<std::string> names = PreGetCustomMemberNameIfExists(objValue);
    if (key.empty()) {
        return objValue.OBJECTCONVERT2JSON_MEMEBER_REGISTER_RESERVERD_IMPLE(jsonTypeOutValue, names);
    } else {
        Json::Value jsonTypeNewValue;
        const bool result = objValue.OBJECTCONVERT2JSON_MEMEBER_REGISTER_RESERVERD_IMPLE(jsonTypeNewValue, names);
        if (result) {
            jsonTypeOutValue[key] = jsonTypeNewValue;
        }
        return result;
    }
}

template <typename TClass, typename JSON::enable_if<!HasConverFunction<TClass>::has, int>::type = 0>
static inline bool Object2Json(Json::Value& jsonTypeOutValue, const std::string& key, const TClass& objValue)
{
    return false;
}

template <typename T>
static bool Object2Json(Json::Value& jsonTypeOutValue, const std::string& key, const std::vector<T>& objValue)
{
    bool result(true);
    for (int i = 0; i < objValue.size(); ++i) {
        Json::Value item;
        if (!Object2Json(item, "", objValue[i])) {
            result = false;
        } else {
            if (key.empty()) jsonTypeOutValue.append(item);
            else jsonTypeOutValue[key].append(item);
        }
     }
    return result;
}

template <typename T>
static bool ParseJson(const std::vector<std::string>& names, int index, Json::Value& jsonTypeValue, const T& arg)
{
    if (names.size() > index) {
        const std::string key = names[index];
        return Object2Json(jsonTypeValue, key, arg);
    } else {
        return false;
    }
}

template <typename T, typename... Args>
static bool ParseJson(const std::vector<std::string>& names, int index, Json::Value& jsonTypeValue, T& arg, Args&... args)
{
    if (names.size() - (index + 0) != 1 + sizeof...(Args)) {
        return false;
    }
    const std::string key = names[index];
    Object2Json(jsonTypeValue, key, arg);

    return ParseJson(names, index + 1, jsonTypeValue, args...);
}

/** Provider interface*/
template<typename T>
bool Object2Json(std::string& jsonTypeStr, const T& obj)
{
    //std::function<Json::Value()>placehoder = [&]()->Json::Value { return Json::Value(); };
    //auto func = [&](std::function<Json::Value()>f) { return f(); };
    //Json::Value val = func(placehoder);

    Json::StyledWriter writer;
    Json::Value root;
    const bool result = Object2Json(root, "", obj);
    if (result) {
        jsonTypeStr = writer.write(root);
    }
    return result;
}

參考文件

更多內容請關注個人微信公眾號物役記（微訊號：materialchains）

作者：雪影藍楓 出處：https://home.cnblogs.com/u/liaoguifa/ 本文版權歸作者和部落格園共有，歡迎轉載，未經作者同意須保留此段宣告，且在文章頁面明顯位置給出原文連結，否則保留追究法律責任的權利。

相關推薦

C++實現對Json資料的友好處理

背景 C/C++客戶端需要接收和傳送JSON格式的資料到後端以實現通訊和資料互動。C++沒有現成的處理JSON格式資料的介面，直接引用第三方庫還是避免不了拆解拼接。考慮到此專案將會有大量JSON資料需要處理，避免不了重複

基於python實現把json資料轉換成Excel表格

json資料： [{\"authenticate\":-99,\"last_ip\":\"156.2.98.429\",\"last_time\":\"2020/05/23 01:41:36\",\"member_id\":5067002,\"mg_id\":1,\"name\":\"yuanfang\",\"status\":0,\"username\":\"L7898\"},{\"au

JDBC工具類實現對資料庫資料的增刪改查

1、先將連線的地址和賬號密碼放在屬性檔案中，本地連線直接///代替，java1.6以後自動載入驅動

使用protobuf c實現TCP網路資料傳輸

1.自定義資料欄位型別: enum UserStatus { UNKNOWN = 0; IDLE = 1; BUSY = 2; } message UserInfo { required string name = 1;

Spring Boot對json資料的處理以及返回資料的封裝

技術標籤：javaspringBootjavaspring boot SpringBoot 對Json的配置 jackson 中對null的處理(spring boot 預設)

c++ 實現對結構體中的元素進行操作

#include<iostream> using namespace std; //設計一個結構體，成員包括姓名，性別和年齡

SpringBoot - 實現返回 JSON 資料

技術標籤：SpringBootspring bootjson JSON是目前主流的前後端資料傳輸方式，尤其是現在前後端分離模式的盛行，後端返回JSON格式資料更是主流。在Spring Boot專案中，只要添加了Web依賴（spring-boot-starter-we

django學習-12.在html頁面操作實現對指定資料的增刪改查功能

4.資料表的相關curd的簡單操作 通過前面部落格【django學習-10.django連線和操作mysql】裡的操作，我們已經成功在資料庫【hongjingsheng_project】裡建立了一張資料表【hello_person】。

Java讀取Excel檔案的內容，歸檔到json檔案中（對json資料進行讀取、新增/修改put、刪除remove操作）

Java讀取Excel檔案的內容，歸檔到json檔案中（對json資料進行讀取、新增/修改put、刪除remove操作）

KNN演算法實現對iris資料集的預測

KNN演算法的實現 第一次寫機器學習演算法，寫的是KNN預測iris資料集、不會矩陣運算，實現起來很呆，但是總歸還是實現了

C#實現對資料庫增刪改查小案例

資料庫參照之前文章中的學生資料庫表格 本次實現一個小案例，實現C#對資料庫的增刪改查的綜合運用，並在控制檯進行測試。

python實現將json多行資料傳入到mysql中使用

將json多行資料傳入到mysql中使用python實現 表需要提前建立，字符集utf8 如果不行換成utf8mb4

Oracle + mybatis實現對資料的簡單增刪改查例項程式碼

什麼是 MyBatis？ MyBatis 是支援普通 SQL 查詢，儲存過程和高階對映的優秀持久層框架。 MyBatis 消除了幾乎所有的 JDBC 程式碼和引數的手工設定以及對結果集的檢索。MyBatis 可以使用簡單的XML 或註解用於配置和原始

go json資料轉發的實現程式碼

案例 例如，有個 GET 介面，可以批量獲取使用者資訊👇 > curl \'http://localhost:8080/user/1,2,3\'

利用pytorch實現對CIFAR-10資料集的分類

步驟如下： 1.使用torchvision載入並預處理CIFAR-10資料集、 2.定義網路 3.定義損失函式和優化器

pytorch實現對輸入超過三通道的資料進行訓練

案例背景:視訊識別 假設每次輸入是8s的灰度視訊,視訊幀率為25fps,則視訊由200幀影象序列構成.每幀是一副單通道的灰度影象,通過pythonb裡面的np.stack(深度拼接)可將200幀拼接成200通道的深度資料.進而送到網路裡面去

js實現提交前對列表資料的增刪改查

js實現列表資料的增刪改查，AJAX提交後,js操作資料 最近工作中，有一處列表資料是頁面初始化載入的，使用者可以進行操作，因為這些資料並不存在資料庫中，同時為了資料的整潔以及高效，所以要在頁面進行增刪改操作（

tensorflow實現對張量資料的切片操作方式

如下所示： import tensorflow as tf a=tf.constant([[[1,2,3,4],[4,5,6,7],[7,8,9,10]],[[11,12,13,14],[20,21,22,23],[15,16,17,18]]])

Django 返回json資料的實現示例

在一個網站，大量資料的前後端互動，JSON是最好的傳遞資料方式了。 在Django中，使用JSON傳輸資料，有兩種方式，一種是使用Python的JSON包，一種是使用Django的JsonResponse

MySQL資料庫對敏感資料加密及解密的實現方式

大資料時代的到來，資料成為企業最重要的資產之一，資料加密的也是保護資料資產的重要手段。本文主要在結合學習通過MySQL函式及Python加密方法來演示資料加密的一些簡單方式。