如何在jMeter中使用JSONSchema验证JSON数据

对于我的请求，我得到了

json

响应。因此，我想在

jMeter

中使用

JSONSchema

进行结构和数据类型验证

如何以最佳方式实现这一点？

jMeter

中是否有任何插件可用于执行此类任务

示例：

响应Json是

{
  "id": "60D5B6D2-9607-4E23-91D0-14EB5EA806EA",
  "imp": [
    {
      "id": "1",
      "tagid": "759926",
      "banner": {
        "w": 300,
        "h": 250,
        "topframe": 1,
        "api": [
          5
        ]
      }
    }
  ]
}

JSONSchema是

{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "id": {
      "type": "string"
    },
    "imp": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "tagid": {
            "type": "string"
          },
          "banner": {
            "type": "object",
            "properties": {
              "w": {
                "type": "integer",
                "minimim": 10,
                "maximum": 150
              },
              "h": {
                "type": "integer",
                "minimim": 10,
                "maximum": 150
              },
              "topframe": {
                "type": "integer",
                "minimim": 10,
                "maximum": 150
              },
              "api": {
                "type": "array",
                "items": {
                  "type": "integer"
                }
              }
            },
            "additionalProperties": false,
            "required": [
              "w",
              "h",
              "topframe",
              "api"
            ]
          }
        },
        "additionalProperties": false,
        "required": [
          "id",
          "tagid",
          "banner"
        ]
      }
    }
  },
  "additionalProperties": false,
  "required": [
    "id",
    "imp"
  ]
}

尝试JMeter插件，它允许您执行JSON文档的验证（如结构、值，一次只键入一个），但不用于模式验证

您可以使用或

手动下载jar并将其放入

/lib/ext

文件夹，然后重新启动JMeter

---

从文档：

此组件允许您执行JSON文档的验证

首先，如果数据不是JSON，它将解析JSON并失败

其次，它将使用来自Jayway的语法搜索指定路径 JsonPath 1.2.0。如果找不到路径，它将失败

第三，如果在文档中找到JSON路径，并根据 请求了预期值，它将执行验证。为空 值在GUI中有一个特殊的复选框

---

没有针对模式验证JSON对象的内置支持，因此您必须执行本文中所述的脚本编写。为了防止引用的链接消失，您将需要以下库

获取它们的最快和最简单的方法是创建最小的文件，如：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>foo</groupId>
    <artifactId>bar</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/com.github.fge/json-schema-validator -->
        <dependency>
            <groupId>com.github.fge</groupId>
            <artifactId>json-schema-validator</artifactId>
            <version>2.2.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.github.fge/jackson-coreutils -->
        <dependency>
            <groupId>com.github.fge</groupId>
            <artifactId>jackson-coreutils</artifactId>
            <version>1.8</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.github.fge/json-schema-core -->
        <dependency>
            <groupId>com.github.fge</groupId>
            <artifactId>json-schema-core</artifactId>
            <version>1.2.5</version>
        </dependency>
    </dependencies>


</project>

---

在

如何使用JSON路径断言验证JSON的结构？同样，这不是完整的结构。当您使用

Jayway JsonPath 1.2.0

样式编写断言时，如果找不到元素的路径，则会引发失败，这间接导致您正在测试结构。请参阅我的答案

文档

部分的第二点

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>foo</groupId>
    <artifactId>bar</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/com.github.fge/json-schema-validator -->
        <dependency>
            <groupId>com.github.fge</groupId>
            <artifactId>json-schema-validator</artifactId>
            <version>2.2.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.github.fge/jackson-coreutils -->
        <dependency>
            <groupId>com.github.fge</groupId>
            <artifactId>jackson-coreutils</artifactId>
            <version>1.8</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.github.fge/json-schema-core -->
        <dependency>
            <groupId>com.github.fge</groupId>
            <artifactId>json-schema-core</artifactId>
            <version>1.2.5</version>
        </dependency>
    </dependencies>


</project>

import java.io.File;
import java.io.IOException;
import java.net.URL;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.github.fge.jackson.JsonLoader;
import com.github.fge.jsonschema.core.exceptions.ProcessingException;
import com.github.fge.jsonschema.core.report.ProcessingMessage;
import com.github.fge.jsonschema.core.report.ProcessingReport;
import com.github.fge.jsonschema.main.JsonSchema;
import com.github.fge.jsonschema.main.JsonSchemaFactory;


public class ValidationUtils {

    public static final String JSON_V4_SCHEMA_IDENTIFIER = "http://json-schema.org/draft-04/schema#";
    public static final String JSON_SCHEMA_IDENTIFIER_ELEMENT = "$schema";

    public static JsonNode getJsonNode(String jsonText)
            throws IOException
    {
        return JsonLoader.fromString(jsonText);
    } // getJsonNode(text) ends

    public static JsonNode getJsonNode(File jsonFile)
            throws IOException
    {
        return JsonLoader.fromFile(jsonFile);
    } // getJsonNode(File) ends

    public static JsonNode getJsonNode(URL url)
            throws IOException
    {
        return JsonLoader.fromURL(url);
    } // getJsonNode(URL) ends

    public static JsonNode getJsonNodeFromResource(String resource)
            throws IOException
    {
        return JsonLoader.fromResource(resource);
    } // getJsonNode(Resource) ends

    public static JsonSchema getSchemaNode(String schemaText)
            throws IOException, ProcessingException
    {
        final JsonNode schemaNode = getJsonNode(schemaText);
        return _getSchemaNode(schemaNode);
    } // getSchemaNode(text) ends

    public static JsonSchema getSchemaNode(File schemaFile)
            throws IOException, ProcessingException
    {
        final JsonNode schemaNode = getJsonNode(schemaFile);
        return _getSchemaNode(schemaNode);
    } // getSchemaNode(File) ends

    public static JsonSchema getSchemaNode(URL schemaFile)
            throws IOException, ProcessingException
    {
        final JsonNode schemaNode = getJsonNode(schemaFile);
        return _getSchemaNode(schemaNode);
    } // getSchemaNode(URL) ends

    public static JsonSchema getSchemaNodeFromResource(String resource)
            throws IOException, ProcessingException
    {
        final JsonNode schemaNode = getJsonNodeFromResource(resource);
        return _getSchemaNode(schemaNode);
    } // getSchemaNode() ends

    public static void validateJson(JsonSchema jsonSchemaNode, JsonNode jsonNode)
            throws ProcessingException
    {
        ProcessingReport report = jsonSchemaNode.validate(jsonNode);
        if (!report.isSuccess()) {
            for (ProcessingMessage processingMessage : report) {
                throw new ProcessingException(processingMessage);
            }
        }
    } // validateJson(Node) ends

    public static boolean isJsonValid(JsonSchema jsonSchemaNode, JsonNode jsonNode) throws ProcessingException
    {
        ProcessingReport report = jsonSchemaNode.validate(jsonNode);
        return report.isSuccess();
    } // validateJson(Node) ends

    public static boolean isJsonValid(String schemaText, String jsonText) throws ProcessingException, IOException
    {
        final JsonSchema schemaNode = getSchemaNode(schemaText);
        final JsonNode jsonNode = getJsonNode(jsonText);
        return isJsonValid(schemaNode, jsonNode);
    } // validateJson(Node) ends

    public static boolean isJsonValid(File schemaFile, File jsonFile) throws ProcessingException, IOException
    {
        final JsonSchema schemaNode = getSchemaNode(schemaFile);
        final JsonNode jsonNode = getJsonNode(jsonFile);
        return isJsonValid(schemaNode, jsonNode);
    } // validateJson(Node) ends

    public static boolean isJsonValid(URL schemaURL, URL jsonURL) throws ProcessingException, IOException
    {
        final JsonSchema schemaNode = getSchemaNode(schemaURL);
        final JsonNode jsonNode = getJsonNode(jsonURL);
        return isJsonValid(schemaNode, jsonNode);
    } // validateJson(Node) ends    

    public static void validateJson(String schemaText, String jsonText) throws IOException, ProcessingException{
        final JsonSchema schemaNode = getSchemaNode(schemaText);
        final JsonNode jsonNode = getJsonNode(jsonText);
        validateJson(schemaNode, jsonNode);
    } // validateJson(text) ends

    public static void validateJson(File schemaFile, File jsonFile) throws IOException, ProcessingException{
        final JsonSchema schemaNode = getSchemaNode(schemaFile);
        final JsonNode jsonNode = getJsonNode(jsonFile);
        validateJson(schemaNode, jsonNode);
    } // validateJson(File) ends

    public static void validateJson(URL schemaDocument, URL jsonDocument) throws IOException, ProcessingException{
        final JsonSchema schemaNode = getSchemaNode(schemaDocument);
        final JsonNode jsonNode = getJsonNode(jsonDocument);
        validateJson(schemaNode, jsonNode);
    } // validateJson(URL) ends

    public static void validateJsonResource(String schemaResource, String jsonResource) throws IOException, ProcessingException{
        final JsonSchema schemaNode = getSchemaNode(schemaResource);
        final JsonNode jsonNode = getJsonNodeFromResource(jsonResource);
        validateJson(schemaNode, jsonNode);
    } // validateJsonResource() ends

    private static JsonSchema _getSchemaNode(JsonNode jsonNode)
            throws ProcessingException
    {
        final JsonNode schemaIdentifier = jsonNode.get(JSON_SCHEMA_IDENTIFIER_ELEMENT);
        if (null == schemaIdentifier){
            ((ObjectNode) jsonNode).put(JSON_SCHEMA_IDENTIFIER_ELEMENT, JSON_V4_SCHEMA_IDENTIFIER);
        }

        final JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
        return factory.getJsonSchema(jsonNode);
    } // _getSchemaNode() ends
}