在java中验证JSON模式

我正在处理一个API调用的POC，我需要验证特殊字符的请求。因此，如果请求中存在无效的特殊字符，它应该抛出异常。我用的是spring boot这是我所有的文件

StudentController.java

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.kjetland.jackson.jsonSchema.JsonSchemaConfig;
import com.kjetland.jackson.jsonSchema.JsonSchemaGenerator;
import org.everit.json.schema.Schema;
import org.everit.json.schema.loader.SchemaLoader;
import org.json.JSONObject;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;

@RestController
public class StudentController {

    @PostMapping("/student")
    public Student home(@Valid @RequestBody Student student) throws JsonProcessingException {
        JSONObject jsonObject = new JSONObject(student.getAddress());
        ObjectMapper mapper = new ObjectMapper();
        JsonSchemaGenerator schemaGen = new JsonSchemaGenerator(mapper, JsonSchemaConfig.nullableJsonSchemaDraft4());
        JsonNode addressSchema = schemaGen.generateJsonSchema(Address.class);
        String jsonSchemaAsString = mapper.writeValueAsString(addressSchema);
        JSONObject jsonSchema = new JSONObject(jsonSchemaAsString);
        System.out.println("JSON: "+jsonObject);
        System.out.println("jsonSchema: "+jsonSchema);
        Schema schema = SchemaLoader.load(jsonSchema);
        schema.validate(jsonObject);
        return student;
    }
}

Student.java

import java.util.Objects;

public class Student {
    private String name;

    private int age;

    private Object address;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Object getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age &&
                name.equals(student.name) &&
                address.equals(student.address);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, address);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address +
                '}';
    }
}

Address.java

import com.kjetland.jackson.jsonSchema.annotations.JsonSchemaInject;
import com.kjetland.jackson.jsonSchema.annotations.JsonSchemaString;

import javax.validation.constraints.NotNull;
import java.util.List;
import java.util.Objects;

@JsonSchemaInject(strings = {@JsonSchemaString(path = "patternProperties/^[a-zA-Z0-9@]*$/type", value = "string")})
public class Address {
    @NotNull
    private String street;
    private String state;
    private int zipCode;
    @NotNull
    private List<String> phoneNo;
    @NotNull
    private List<Country> country;

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public int getZipCode() {
        return zipCode;
    }

    public void setZipCode(int zipCode) {
        this.zipCode = zipCode;
    }

    public List<String> getPhoneNo() {
        return phoneNo;
    }

    public void setPhoneNo(List<String> phoneNo) {
        this.phoneNo = phoneNo;
    }

    public List<Country> getCountry() {
        return country;
    }

    public void setCountry(List<Country> country) {
        this.country = country;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Address)) return false;
        Address address = (Address) o;
        return zipCode == address.zipCode &&
                Objects.equals(street, address.street) &&
                Objects.equals(state, address.state) &&
                Objects.equals(phoneNo, address.phoneNo) &&
                Objects.equals(country, address.country);
    }

    @Override
    public int hashCode() {
        return Objects.hash(street, state, zipCode, phoneNo, country);
    }

    @Override
    public String toString() {
        return "Address{" +
                "street='" + street + '\'' +
                ", state='" + state + '\'' +
                ", zipCode=" + zipCode +
                ", phoneNo=" + phoneNo +
                ", country=" + country +
                '}';
    }
}

pom.xml

<?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>com.xyz</groupId>
    <artifactId>annotation-validator</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>annotation-validator</name>
    <description>Demo project for student response</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.github.everit-org.json-schema</groupId>
            <artifactId>org.everit.json.schema</artifactId>
            <version>1.9.2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.kjetland/mbknor-jackson-jsonschema -->
        <dependency>
            <groupId>com.kjetland</groupId>
            <artifactId>mbknor-jackson-jsonschema_2.12</artifactId>
            <version>1.0.31</version>
        </dependency>
    </dependencies>

    <repositories>
        <repository>
            <id>jitpack.io</id>
            <url>https://jitpack.io</url>
        </repository>
    </repositories>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

我得到以下错误

{
    "timestamp": "2018-12-06T05:01:14.009+0000",
    "status": 500,
    "error": "Internal Server Error",
    "message": "#: 3 schema violations found",
    "path": "/student"
}

基于上述错误，即使在发送有效请求时，它也会返回一个架构冲突发现错误

至于那两条println语句的输出，在这里

JSON: {"country":[{"name":"China"},{"name":"USA"}],"zipCode":99174,"street":"crab apple ln","state":"florida","phoneNo":["Hello","World"]}

jsonSchema: {"patternProperties":{"^[a-zA-Z0-9@]*$":{"type":"string"}},"$schema":"http://json-schema.org/draft-04/schema#","additionalProperties":false,"title":"Address","type":"object","definitions":{"Country":{"patternProperties":{"^[a-zA-Z0-9@]*$":{"type":"string"}},"additionalProperties":false,"type":"object","properties":{"name":{"oneOf":[{"type":"null","title":"Not included"},{"type":"string"}]}}}},"properties":{"zipCode":{"type":"integer"},"country":{"type":"array","items":{"$ref":"#/definitions/Country"}},"street":{"type":"string"},"state":{"oneOf":[{"type":"null","title":"Not included"},{"type":"string"}]},"phoneNo":{"type":"array","items":{"type":"string"}}},"required":["street","zipCode","phoneNo","country"]}

---

删除

模式属性

。你为什么还要加上它们

尝试使用在线模式验证器，例如，使用

print

语句中的字符串，您将看到更好的错误消息，如果删除

patternProperties

，这些错误消息就会消失

---

这是因为

patternProperties

表示键为字母数字（匹配

^[a-zA-Z0-9@]*$

）的所有属性必须是类型

字符串

，这显然不适用于

zipCode

（类型

整数

）、

国家

（类型

数组

）和

电话号码

（键入

array

）。

为什么

Student.address

是一个类型

Object

？它应该是一个类型

address

，返回类型

getAddress（）

。两个

println（）的输出是什么

statements？@Andreas添加了printn语句的输出。至于对象，这实际上是一个POC，我将在其中实现逻辑的实际代码是一个对象，因此我尝试模仿该行为为什么

Country.name

允许为空？那么我如何在方案验证中检查无效的特殊字符？@zakSyed什么特殊字符？架构显式列出有效的属性名称（由POJO字段定义），并指定不允许使用未知属性（

“additionalProperties”：false

）。任何带有特殊字符的字段名都是未知的，因此不允许。我的要求是，如果字符串中发送了一个特殊字符，例如“*”，那么它应该抛出一个错误。例如，如果我发送“crab apple ln*****”作为street，它应该抛出一个异常。应该允许的唯一特殊字符是，.@和$，在字符串中发送的任何其他特殊字符都应该抛出一个异常。我刚刚尝试发送“crab apple ln*****”正如street在删除patternProperties后不会引发异常并给出成功响应。换句话说，是否有方法使用正则表达式模式检查所有字符串属性arch没有提供答案，然后问另一个问题。这个问题已经得到了回答。

{
    "timestamp": "2018-12-06T05:01:14.009+0000",
    "status": 500,
    "error": "Internal Server Error",
    "message": "#: 3 schema violations found",
    "path": "/student"
}

JSON: {"country":[{"name":"China"},{"name":"USA"}],"zipCode":99174,"street":"crab apple ln","state":"florida","phoneNo":["Hello","World"]}

jsonSchema: {"patternProperties":{"^[a-zA-Z0-9@]*$":{"type":"string"}},"$schema":"http://json-schema.org/draft-04/schema#","additionalProperties":false,"title":"Address","type":"object","definitions":{"Country":{"patternProperties":{"^[a-zA-Z0-9@]*$":{"type":"string"}},"additionalProperties":false,"type":"object","properties":{"name":{"oneOf":[{"type":"null","title":"Not included"},{"type":"string"}]}}}},"properties":{"zipCode":{"type":"integer"},"country":{"type":"array","items":{"$ref":"#/definitions/Country"}},"street":{"type":"string"},"state":{"oneOf":[{"type":"null","title":"Not included"},{"type":"string"}]},"phoneNo":{"type":"array","items":{"type":"string"}}},"required":["street","zipCode","phoneNo","country"]}