基于OpenAPI/Swagger Schema的JSON输入验证指南

<dependency>
    <groupId>org.openapi4j</groupId>
    <artifactId>openapi-parser</artifactId>
    <version>1.0.7</version>
</dependency>
<dependency>
    <groupId>org.openapi4j</groupId>
    <artifactId>openapi-schema-validator</artifactId>
    <version>1.0.7</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version> <!-- 根据你的项目选择合适的版本 -->
</dependency>

import org.openapi4j.parser.OpenApi3Parser;
import org.openapi4j.parser.model.v3.OpenApi3;
import org.openapi4j.core.validation.ValidationResults;
import org.openapi4j.schema.validator.v3.SchemaValidator;

import java.io.IOException;
import java.net.URL; // 实际场景中可能从文件或URL加载Schema
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class OpenApiJsonValidator {

    public static void main(String[] args) throws IOException {
        // 1. 定义一个简单的OpenAPI Schema字符串
        // 在实际应用中，这个Schema通常会存储在YAML或JSON文件中，并通过文件路径或URL加载。
        String schemaContent = """
                openapi: 3.0.0
                info:
                  title: User API
                  version: 1.0.0
                paths: {}
                components:
                  schemas:
                    User:
                      type: object
                      required:
                        - id
                        - name
                      properties:
                        id:
                          type: integer
                          format: int64
                        name:
                          type: string
                        email:
                          type: string
                          format: email
                """;

        // 2. 使用OpenApi3Parser解析Schema内容
        // 这里直接解析字符串，也可以通过 new OpenApi3Parser().parse(new URL("file:///path/to/schema.yaml")) 加载文件
        OpenApi3 api = new OpenApi3Parser().parse(schemaContent);

        // 3. 从解析后的OpenAPI对象中获取用于验证的特定Schema
        // 假设我们要验证 components/schemas/User 这个模型
        org.openapi4j.schema.validator.v3.Schema userSchema = 
            new SchemaValidator(api.getComponents().getSchemas().get("User"));

        // 4. 准备待验证的JSON数据
        String validJsonInput = """
                {
                  "id": 123,
                  "name": "Alice Smith",
                  "email": "alice@example.com"
                }
                """;

        String invalidJsonInput = """
                {
                  "id": "abc",  // id应该是integer，这里是string
                  "name": null, // name是required且不能为null
                  "age": 30     // age字段未在Schema中定义
                }
                """;

        String missingRequiredJsonInput = """
                {
                  "name": "Bob"
                }
                """; // 缺少必填字段 "id"

        ObjectMapper mapper = new ObjectMapper();

        // 5. 验证有效的JSON数据
        System.out.println("--- 验证有效JSON数据 ---");
        JsonNode validJsonNode = mapper.readTree(validJsonInput);
        ValidationResults validResults = userSchema.validate(validJsonNode);
        if (validResults.isValid()) {
            System.out.println("✅ 有效JSON数据验证通过。");
        } else {
            System.out.println("❌ 有效JSON数据验证失败，错误信息：");
            validResults.getResults().forEach(System.out::println);
        }

        // 6. 验证无效的JSON数据
        System.out.println("\n--- 验证无效JSON数据 ---");
        JsonNode invalidJsonNode = mapper.readTree(invalidJsonInput);
        ValidationResults invalidResults = userSchema.validate(invalidJsonNode);
        if (invalidResults.isValid()) {
            System.out.println("✅ 无效JSON数据验证通过。");
        } else {
            System.out.println("❌ 无效JSON数据验证失败，错误信息：");
            invalidResults.getResults().forEach(System.out::println);
        }

        // 7. 验证缺少必填字段的JSON数据
        System.out.println("\n--- 验证缺少必填字段JSON数据 ---");
        JsonNode missingRequiredJsonNode = mapper.readTree(missingRequiredJsonInput);
        ValidationResults missingRequiredResults = userSchema.validate(missingRequiredJsonNode);
        if (missingRequiredResults.isValid()) {
            System.out.println("✅ 缺少必填字段JSON数据验证通过。");
        } else {
            System.out.println("❌ 缺少必填字段JSON数据验证失败，错误信息：");
            missingRequiredResults.getResults().forEach(System.out::println);
        }
    }
}