Question

我正在使用RapidJSON来解析（大致）符合JSON-RPC的消息。以下是此类消息的示例：

{
    "method": "increment",
    "params": [ { "count": 42 } ]
}

params的内容取决于method的值，因此......我需要针对method的每个可能值针对不同的架构进行验证。为实现这一目标迈出了一步，我创建了一个模式文档的地图，以method名称为键：

std::unordered_map<std::string, rapidjson::SchemaDocument> schemas;

我的意图是做这样的事情（在将收到的JSON解析为RapidJSON文档后，doc）：

if (schemas.find(doc["method"]) != schemas.end()) {
    validate(doc, schemas[doc]);
}

我的问题是：我知道如何验证rapidjson::Document，而不是GenericValue实例（我收集的是doc["method"]返回的内容）。

如何验证RapidJSON文档的片段或“子文档”？

更新/解释：感谢@ wsxedcrfv的回答，我现在意识到我的声明“我知道如何验证rapidjson::Document并不完全准确。我知道验证rapidjson::Document的一种方法。但显然有多种方法可以做到这一点。为了后代清理这个问题，这里是我遗漏的validate()函数原始问题：

bool validate(                                                                                                                                                                             
    rj::SchemaDocument const& schema,
    rj::Document *doc,
    std::string const& jsonMsg
)                  
{
    bool valid = false;              

    rj::StringStream ss(jsonMsg.c_str());

    rj::SchemaValidatingReader<
        rj::kParseDefaultFlags,
        rj::StringStream,
        rj::UTF8<>
    > reader(ss, schema);

    doc->Populate(reader);     

    if (!reader.GetParseResult()) {
        if (!reader.IsValid()) {                                  
            rj::StringBuffer sb;                        
            reader.GetInvalidSchemaPointer().StringifyUriFragment(sb);      
            printf("Message does not conform to schema!\n");
            printf("--------------------------------------------------------------------\n");
            printf("Invalid schema: %s\n", sb.GetString());
            printf("Invalid keyword: %s\n", reader.GetInvalidSchemaKeyword());
            sb.Clear();                                  
            reader.GetInvalidDocumentPointer().StringifyUriFragment(sb);    
            printf("Invalid document: %s\n", sb.GetString());
            printf("--------------------------------------------------------------------\n");
        } 

        else {
            printf("Message JSON is not well-formed!\n");
        }
    } 

    else {
        valid = true;
    }        

    return valid;
}

正如@wsxedcrfv指出的那样，另一种选择是创建一个SchemaValidator实例并将其传递给（子）文档的Accept()方法：

#include "rapidjson/document.h"
#include <rapidjson/schema.h>
#include <iostream>


namespace rj = rapidjson;

namespace
{

std::string testMsg = R"msg({ "root": { "method": "control", "params": [ { "icc_delta_vol":  5 } ] } })msg";

std::string msgSchema = R"schema(
{
    "type": "object",

    "properties": {
        "method": { "$ref": "#/definitions/method" },
        "params": { "$ref": "#/definitions/paramsList" }
    },

    "required": [ "method", "params" ],

    "additionalProperties": false,

    "definitions": {
        // Omitted in the interest of brevity
        ...
    }
})schema";


} // End anonymous namespace

int main()
{
    rj::Document schemaDoc;

    if (schemaDoc.Parse(::msgSchema.c_str()).HasParseError()) {
        std::cout << "Schema contains invalid JSON, aborting...\n";
        exit(EXIT_FAILURE);
    }

    rj::SchemaDocument schema(schemaDoc);
    rj::SchemaValidator validator(schema);

    rj::Document doc;                                                                                                                                                                                                                     
    doc.Parse(::testMsg.c_str());

    std::cout << "doc.Accept(validator) = " << doc["root"].Accept(validator) << '\n';

    return 0;

既然我知道这种替代方法，我可以轻松地使用它来对子文档/片段进行特定于上下文的验证......

Answer 1

我想这个答案对您来说有点晚了，但这对我有用：

    char json[] = "{ \"a\" : 1, \"b\" : 1.2  } ";
    rapidjson::Document d;
    std::cout << "parse json  error? " << d.Parse(json).HasParseError() << "\n";

    char schema[] = "{ \"type\" : \"integer\"  } ";
    rapidjson::Document sd;
    std::cout << "parse schema error? " << sd.Parse(schema).HasParseError() << "\n";
    rapidjson::SchemaDocument s{sd}; //sd may now be deleted

    rapidjson::SchemaValidator vali{s};
    std::cout << "json " << d.Accept(vali) << "\n"; // 0
    vali.Reset();
    std::cout << "a    " << d.GetObject()["a"].Accept(vali) << "\n"; // 1
    vali.Reset();
    std::cout << "b    " << d.GetObject()["b"].Accept(vali) << "\n"; // 0

我不知道您使用的是哪个validate函数，但是Document是GenericValue，而GenericValue提供了Accept。

如何验证RapidJSON文档的子集？

1 个答案: