So überprüfen Sie, ob das JSON-Format den Anforderungen in Java entspricht

JSON-Schema

JSON-Schema ist ein leistungsstarkes Tool zur Validierung der JSON-Datenstruktur. Es kann als Muster oder Regel verstanden werden.

Json-Schema definiert eine Reihe von Vokabeln und Regeln, die zum Definieren von Json-Metadaten verwendet werden, und die Metadaten werden auch in Form von Json-Daten ausgedrückt. Json-Metadaten definieren die Spezifikationen, die Json-Daten erfüllen müssen. Die Spezifikationen umfassen Mitglieder, Strukturen, Typen, Einschränkungen usw.

JSON-Schema ist die Formatbeschreibung, Definition und Vorlage von JSON. Damit können Sie alle JSON-Daten generieren, die die Anforderungen erfüllen.

JSON-Schema-Validator

In Java können Sie das JSON-Datenformat überprüfen json-schema-validator, konkrete Beispiele sind wie folgt: json-schema-validator，具体实例如下：

1. 引入依赖

        <dependency>
            <groupId>com.github.fge</groupId>
            <artifactId>json-schema-validator</artifactId>
            <version>2.2.6</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.3.0</version>
        </dependency>

jackson-core和 jackson-core 是必须要引入的，他们为 json-schema-validator 必须的

2. 编写schema

如果我们要校验的数据格式如下：

{
    "data": [
        {
            "sex": "男",
            "name": "王小明",
            "age": 18
        },
        {
            "sex": "女",
            "name": "王小红",
            "age": 17
        }
    ],
    "type": "human"
}

外面是type和data，里面是一个数组，数组属性包括sex、name、age

编写schema文件

{
    "type": "object",
    "properties": {
        "type": {
            "type": "string"
        },
        "data": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string",
                        "maxLength": 3
                    },
                    "sex": {
                        "enum": [
                            "男",
                            "女"
                        ]
                    },
                    "age": {
                        "type": "number"
                    }
                },
                "required": [
                    "name",
                    "sex",
                    "age"
                ]
            }
        }
    },
    "required": [
        "type",
        "data"
    ]
}

以上json描述了目标json的数据格式，外层必须字段type、data，里面限制了name的最大长度 maxLength 为3，sex 为枚举值，只可取 男、女两个字符串，age 为number类型。

3. 代码实现

public Map validatorJsonUnchecked(String body) {
        Map<String, String> map = new HashMap<>();
        String filePath = "validator" + File.separator + "validator.json";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            JsonNode jsonNodeSchema = objectMapper.readTree(ResourceUtil.readUtf8Str(filePath));
            JsonNode jsonNode = objectMapper.readTree(body);
            ProcessingReport processingReport = JsonSchemaFactory.byDefault().getValidator().validate(jsonNodeSchema, jsonNode, true);
            if (!processingReport.isSuccess()) {
                processingReport.forEach(processingMessage -> {
                    JsonNode missing = processingMessage.asJson().get("missing");
                    String keyword = processingMessage.asJson().get("keyword").asText();
                    // 如果缺失字段
                    if (!Objects.isNull(missing)) {
                        missing.forEach(miss -> {
                            String text = miss.asText();
                            map.put(text, text + " 字段缺失");
                        });
                        // 如果字段超长
                    } else if ("maxLength".equals(keyword)) {
                        String field = processingMessage.asJson().get("instance").get("pointer").asText();
                        String value = processingMessage.asJson().get("value").asText();
                        field = field.substring(field.lastIndexOf("/") + 1);
                        map.put(field, value + " 字段长度过长");
                        // 如果不在枚举范围内
                    } else if ("enum".equals(keyword)) {
                        String field = processingMessage.asJson().get("instance").get("pointer").asText();
                        String value = processingMessage.asJson().get("value").asText();
                        field = field.substring(field.lastIndexOf("/") + 1);
                        map.put(field, field + "字段值错误，" + value + "不在枚举范围内");
                    } else if ("type".equals(keyword)) {
                        String field = processingMessage.asJson().get("instance").get("pointer").asText();
                        String found = processingMessage.asJson().get("found").asText();
                        String expected = processingMessage.asJson().get("expected").toString();
                        field = field.substring(field.lastIndexOf("/") + 1);
                        map.put(field, field + " 类型错误，现有类型: " + found + ", 预期类型:" + expected);
                    }
                });
            }
        } catch (IOException | ProcessingException e) {
            log.error("校验json格式异常", e);
        }
        return map;
    }

以上代码首先获取了 要校验的json的标准文件 validator.json，然后调用 JsonSchemaFactory.byDefault().getValidator().validate(jsonNodeSchema, jsonNode, true) 方法对传进来的json 进行了校验，这里 true 的意思是深度检查，如果没有这个参数，校验json的时候遇到第一个错误，就直接返回了

接下来构建测试方法

    public static void main(String[] args) {
        ValidatorService validatorService = new ValidatorServiceImpl();
        Map<String, Object> body = new HashMap<>();
        HashMap<String, Object> one = new HashMap<String, Object>() {{
            put("name", "王小明");
            put("sex", "男");
            put("age", 18);
        }};
        HashMap<String, Object> two = new HashMap<String, Object>() {{
            put("name", "王小明1");
            put("sex", "未知");
            put("age", "18");
        }};
        body.put("type", "human");
        body.put("data", Arrays.asList(one,two));

        Map map = validatorService.validatorJsonUnchecked(JSONUtil.toJsonStr(body));
        System.out.println(map);
    }

4. 执行结果

{sex=sex字段值错误，未知不在枚举范围内, name=王小明1 字段长度过长, age=age 类型错误，现有类型: string, 预期类型:["integer","number"]}

5. 整理总结

如果schema 编写的时候，对列表使用了中括号 []

1. Abhängigkeiten einführen

{
    "type": "object",
    "properties": {
        "type": {
            "type": "string"
        },
        "data": {
            "type": "array",
            "items": [
                {
                    "type": "object",
                    "properties": {
                        "name": {
                            "type": "string",
                            "maxLength": 3
                        },
                        "sex": {
                            "enum": [
                                "男",
                                "女"
                            ]
                        },
                        "age": {
                            "type": "number"
                        }
                    },
                    "required": [
                        "name",
                        "sex",
                        "age"
                    ]
                }
            ]
        }
    },
    "required": [
        "type",
        "data"
    ]
}

jackson-core und jackson-core müssen eingeführt werden, sie sind für json-schema-validator

Schreibschema

Wenn das Datenformat, das wir überprüfen möchten, wie folgt lautet: rrreeeDraußen Es handelt sich um Typ und Daten, die ein Array sind. Zu den Array-Attributen gehören Geschlecht, Name und Alter. Das obige JSON beschreibt das Datenformat des Ziel-JSON und Daten, und der maximale Name ist innerhalb begrenzt. Die Länge maxLength beträgt 3, Geschlecht ist ein Aufzählungswert und kann nur zwei Zeichenfolgen annehmen, männlich und weiblich, und Alter ist vom Typ Zahl. 🎜

3. Code-Implementierung

rrreee🎜Der obige Code ruft zunächst die Standarddatei validator.json des zu verifizierenden JSON ab und ruft dann JsonSchemaFactory.byDefault() auf .getValidator Die Methode ().validate(jsonNodeSchema, jsonNode, true) überprüft den eingehenden JSON. Hier bedeutet true eine eingehende Prüfung. Wenn es keinen solchen Parameter gibt, überprüfen Sie den JSON. Beim ersten Fehler wurde direkt zurückgegeben🎜🎜Dann wird die Testmethode erstellt🎜rrreee

4. Ausführungsergebnis

🎜🎜{Geschlecht=Geschlechtsfeldwert ist falsch, unbekannt liegt nicht im Aufzählungsbereich, Name = Wang Xiaoming1 Die Feldlänge ist zu lang, Alter = Alterstypfehler, vorhandener Typ: Zeichenfolge, erwarteter Typ: ["Ganzzahl", "Zahl"]}🎜🎜

5. Zusammenfassung

🎜Wenn Schema geschrieben wird Wenn Sie eckige Klammern [] für die Liste verwenden, wird bei der Überprüfung nur der erste im Array überprüft. Dies ist eine Gefahr, wie folgt: 🎜rrreee🎜Wenn dies der Fall ist, nur der erste Daten im Datenarray werden überprüft. 🎜Wenn andere Fehler vorliegen, werden keine Fehler gemeldet! ! 🎜🎜

Das obige ist der detaillierte Inhalt vonSo überprüfen Sie, ob das JSON-Format den Anforderungen in Java entspricht. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!