ดาวน์โหลด json schema validator - json schema validator ซอร์สโค้ดดาวน์โหลดดาวน์โหลด

นี่คือการใช้งาน Java ของ Json Schema Core Draft V4, V6, V7, V2019-09 และ V2020-12 ข้อกำหนดสำหรับการตรวจสอบความถูกต้องของ JSON Schema การใช้งานนี้สนับสนุนการปรับแต่งเมตามาสคีมาคำศัพท์คำหลักและรูปแบบ

นอกจากนี้ยังรองรับการตรวจสอบความถูกต้อง/การตอบสนองของ OpenAPI 3 ด้วยการใช้ meta-schema ที่เหมาะสม สำหรับผู้ใช้ที่ต้องการรวบรวมข้อมูลจากโหนด JSON ตามสคีมา Walkers สามารถช่วยได้ ตัวแยกวิเคราะห์ JSON ที่ใช้คือ Jackson Parser เนื่องจากเป็นองค์ประกอบสำคัญในกรอบ Microservices Light-4J ของเราเพื่อตรวจสอบความถูกต้องของการร้องขอ/การตอบสนองต่อข้อกำหนดของ OpenAPI สำหรับสคีมา Light-REST-4J และ RPC สำหรับแสงไฮบริด-4J ที่รันไทม์ประสิทธิภาพเป็นสิ่งสำคัญที่สุดในการออกแบบ

JSON SCHEMA SPECIFICATION

ข้อมูลเกี่ยวกับการสนับสนุนความเข้ากันได้สำหรับแต่ละเวอร์ชันรวมถึงปัญหาที่ทราบสามารถพบได้ในความเข้ากันได้กับเอกสารเวอร์ชัน JSON Schema

ตั้งแต่ร่าง 2019-09 คำหลัก format จะสร้างคำอธิบายประกอบโดยค่าเริ่มต้นเท่านั้นและไม่ได้สร้างการยืนยัน

พฤติกรรมนี้สามารถแทนที่เพื่อสร้างการยืนยันโดยการตั้งค่า setFormatAssertionsEnabled เป็น true ใน SchemaValidatorsConfig หรือ ExecutionConfig

การอัพเกรดเป็นเวอร์ชันใหม่

ไลบรารีนี้สามารถมีการเปลี่ยนแปลงที่แตกหักในรุ่นรอง minor มาซึ่งอาจต้องมีการเปลี่ยนแปลงรหัส

ข้อมูลเกี่ยวกับการเปลี่ยนแปลงที่โดดเด่นหรือทำลายเมื่ออัปเกรดห้องสมุดสามารถพบได้ในการอัพเกรดเอกสารเวอร์ชันใหม่

หน้ารีลีสจะมีข้อมูลเกี่ยวกับเวอร์ชันล่าสุด

เปรียบเทียบกับการใช้งานอื่น ๆ

โครงการเปรียบเทียบการตรวจสอบความถูกต้องของ JSON Schema จาก Creek มีการเปรียบเทียบข้อมูลการตรวจสอบความถูกต้องของสคีมาตาม JVM ซึ่งเปรียบเทียบทั้งลักษณะการทำงานและประสิทธิภาพของการใช้งาน Java ที่แตกต่างกันจำนวนหนึ่ง

การเปรียบเทียบการทำงาน
การเปรียบเทียบประสิทธิภาพ

โครงการ Bowtie มีรายงานที่เปรียบเทียบลักษณะการทำงานของการใช้งานที่แตกต่างกันรวมถึงการใช้งานที่ไม่ใช่ Java แต่ไม่ได้ทำการเปรียบเทียบประสิทธิภาพใด ๆ

ทำไมห้องสมุดนี้

ผลงาน

นี่ควรเป็นการใช้งานการตรวจสอบความถูกต้องของ Java Schema ที่เร็วที่สุด

ต่อไปนี้เป็นผลมาจากการตรวจสอบความถูกต้องของ JSON Schema Perftest ที่ใช้สายรัด Java Microbenchmark

โปรดทราบว่าผลลัพธ์ของเกณฑ์มาตรฐานนั้นขึ้นอยู่กับปริมาณงานข้อมูลอินพุตและสคีมาที่ใช้สำหรับการตรวจสอบความถูกต้อง

ในกรณีนี้เวิร์กโหลดนี้ใช้ข้อกำหนดร่าง 4 และทดสอบประสิทธิภาพส่วนใหญ่ของการประเมินคำหลัก properties คุณอาจอ้างถึงผลลัพธ์ของการเปรียบเทียบประสิทธิภาพของการใช้งานการตรวจสอบความถูกต้องของ JSON ที่ใช้ JVM สำหรับผลลัพธ์มาตรฐานสำหรับเวิร์กโหลดทั่วไปมากขึ้น

หากประสิทธิภาพเป็นข้อพิจารณาที่สำคัญปริมาณงานตัวอย่างเฉพาะควรได้รับการเปรียบเทียบเนื่องจากมีคุณสมบัติด้านประสิทธิภาพที่แตกต่างกันเมื่อใช้คำหลักบางคำ ตัวอย่างเช่นการใช้คำหลัก unevaluatedProperties หรือ unevaluatedItems จะเรียกเก็บคำอธิบายประกอบในตัวตรวจสอบที่เกี่ยวข้องเช่น properties หรือ items ตรวจสอบรายการและการรวบรวมคำอธิบายประกอบจะส่งผลกระทบต่อประสิทธิภาพการทำงาน

Networknt 1.4.1

 Benchmark                                            Mode  Cnt      Score    Error   Units
NetworkntBenchmark.testValidate                     thrpt   10   8352.126 ± 61.870   ops/s
NetworkntBenchmark.testValidate:gc.alloc.rate       thrpt   10    721.296 ±  5.342  MB/sec
NetworkntBenchmark.testValidate:gc.alloc.rate.norm  thrpt   10  90560.013 ±  0.001    B/op
NetworkntBenchmark.testValidate:gc.count            thrpt   10     61.000           counts
NetworkntBenchmark.testValidate:gc.time             thrpt   10     68.000               ms

Everit 1.14.1

 Benchmark                                            Mode  Cnt       Score    Error   Units
EveritBenchmark.testValidate                        thrpt   10    3775.453 ± 44.023   ops/s
EveritBenchmark.testValidate:gc.alloc.rate          thrpt   10    1667.345 ± 19.437  MB/sec
EveritBenchmark.testValidate:gc.alloc.rate.norm     thrpt   10  463104.030 ±  0.003    B/op
EveritBenchmark.testValidate:gc.count               thrpt   10     140.000           counts
EveritBenchmark.testValidate:gc.time                thrpt   10     158.000               ms

ฟังก์ชั่น

การใช้งานนี้ได้รับการทดสอบกับชุดทดสอบ JSON Schema เนื่องจากการทดสอบจะถูกเพิ่มเข้าไปในห้องสวีทอย่างต่อเนื่องผลการทดสอบเหล่านี้อาจไม่เป็นปัจจุบัน

การดำเนินการ	โดยรวม	Draft_03	Draft_04	Draft_06	Draft_07	Draft_2019_09	Draft_2020_12
เครือข่าย	ผ่าน: R: 4803 (100.0%) O: 2372 (100.0%) ล้มเหลว: R: 0 (0.0%) o: 0 (0.0%)		ผ่าน: R: 610 (100.0%) O: 251 (100.0%) ล้มเหลว: R: 0 (0.0%) o: 0 (0.0%)	ผ่าน: R: 822 (100.0%) O: 318 (100.0%) ล้มเหลว: R: 0 (0.0%) o: 0 (0.0%)	ผ่าน: R: 906 (100.0%) o: 541 (100.0%) ล้มเหลว: R: 0 (0.0%) o: 0 (0.0%)	ผ่าน: R: 1220 (100.0%) O: 625 (100.0%) ล้มเหลว: R: 0 (0.0%) o: 0 (0.0%)	ผ่าน: R: 1245 (100.0%) o: 637 (100.0%) ล้มเหลว: R: 0 (0.0%) o: 0 (0.0%)

โปรดทราบว่าสิ่งนี้ใช้ JoniRegularExpressionFactory สำหรับการทดสอบ pattern และ format regex

Jackson Parser

ห้องสมุดนี้ใช้แจ็คสันซึ่งเป็นตัวแยกวิเคราะห์ Java JSON ที่ใช้กันอย่างแพร่หลายในโครงการอื่น ๆ หากคุณใช้ Jackson Parser ในโครงการของคุณอยู่แล้วมันเป็นเรื่องธรรมดาที่จะเลือกห้องสมุดนี้มากกว่าผู้อื่นเพื่อตรวจสอบสคีมา

การสนับสนุน yaml

ห้องสมุดทำงานร่วมกับ JSON และ YAML ทั้งในคำจำกัดความสคีมาและข้อมูลอินพุต

การสนับสนุน OpenAPI

ข้อมูลจำเพาะ OpenAPI 3.0 ใช้ JSON Schema เพื่อตรวจสอบความถูกต้องของคำขอ/การตอบกลับ แต่มีความแตกต่างบางอย่าง ด้วยไฟล์การกำหนดค่าคุณสามารถเปิดใช้งานไลบรารีเพื่อทำงานกับการตรวจสอบ OpenAPI 3.0

การพึ่งพาน้อยที่สุด

ตามหลักการออกแบบของแพลตฟอร์มแสงห้องสมุดนี้มีการพึ่งพาน้อยที่สุดเพื่อให้แน่ใจว่าไม่มีความขัดแย้งในการพึ่งพาเมื่อใช้งาน

การพึ่งพาที่จำเป็น

ต่อไปนี้คือการพึ่งพาที่จะรวมโดยอัตโนมัติเมื่อรวมไลบรารีนี้

< dependency >
    <!-- Used for logging -->
    < groupId >org.slf4j</ groupId >
    < artifactId >slf4j-api</ artifactId >
    < version >${version.slf4j}</ version >
</ dependency >

< dependency >
    <!-- Used to process JSON -->
    < groupId >com.fasterxml.jackson.core</ groupId >
    < artifactId >jackson-databind</ artifactId >
    < version >${version.jackson}</ version >
</ dependency >

< dependency >
    <!-- Used to process YAML -->
    < groupId >com.fasterxml.jackson.dataformat</ groupId >
    < artifactId >jackson-dataformat-yaml</ artifactId >
    < version >${version.jackson}</ version >
</ dependency >

< dependency >
    <!-- Used to validate RFC 3339 date and date-time -->
    < groupId >com.ethlo.time</ groupId >
    < artifactId >itu</ artifactId >
    < version >${version.itu}</ version >
</ dependency >

การพึ่งพาตัวเลือก

ต่อไปนี้เป็นตัวเลือกการพึ่งพาที่อาจจำเป็นสำหรับตัวเลือกบางอย่าง

สิ่งเหล่านี้จะไม่รวมโดยอัตโนมัติและการตั้งค่าตัวเลือกที่เกี่ยวข้องโดยไม่ต้องเพิ่มไลบรารีจะส่งผลให้ ClassNotFoundException

< dependency >
    <!-- Used to validate ECMA 262 regular expressions -->
    <!-- Approximately 50 MB in dependencies -->
    <!-- GraalJSRegularExpressionFactory -->
    < groupId >org.graalvm.js</ groupId >
    < artifactId >js</ artifactId >
    < version >${version.graaljs}</ version >
</ dependency >

< dependency >
    <!-- Used to validate ECMA 262 regular expressions -->
    <!-- Approximately 2 MB in dependencies -->
    <!-- JoniRegularExpressionFactory -->
    < groupId >org.jruby.joni</ groupId >
    < artifactId >joni</ artifactId >
    < version >${version.joni}</ version >
</ dependency >

ไม่รวมการพึ่งพา

ต่อไปนี้เป็นสิ่งที่จำเป็นต้องมีการพึ่งพาที่รวมอยู่โดยอัตโนมัติ แต่สามารถยกเว้นได้อย่างชัดเจนหากไม่จำเป็น

การพึ่งพา Yaml สามารถยกเว้นได้หากไม่จำเป็นต้องใช้ การพยายามประมวลผลสคีมาหรืออินพุตที่เป็น Yaml จะส่งผลให้ ClassNotFoundException

< dependency >
    < groupId >com.networknt</ groupId >
    < artifactId >json-schema-validator</ artifactId >
    < exclusions >
        < exclusion >
            < groupId >com.fasterxml.jackson.dataformat</ groupId >
            < artifactId >jackson-dataformat-yaml</ artifactId >
        </ exclusion >
    </ exclusions >
</ dependency >

การพึ่งพาเวลา ETHLO สามารถยกเว้นได้หากไม่จำเป็นต้องมีการตรวจสอบความถูกต้องที่แม่นยำของรูปแบบ date-time รูป date-time ที่จะใช้ java.time.OffsetDateTime เพื่อตรวจสอบว่า date-time ถูกต้องหรือไม่

< dependency >
    < groupId >com.networknt</ groupId >
    < artifactId >json-schema-validator</ artifactId >
    < exclusions >
        < exclusion >
            < groupId >com.ethlo.time</ groupId >
            < artifactId >itu</ artifactId >
        </ exclusion >
    </ exclusions >
</ dependency >

ชุมชน

ห้องสมุดนี้มีความกระตือรือร้นมากกับผู้มีส่วนร่วมจำนวนมาก คุณสมบัติใหม่และการแก้ไขข้อผิดพลาดได้รับการจัดการอย่างรวดเร็วโดยสมาชิกในทีม เนื่องจากมันเป็นการพึ่งพาที่สำคัญของกรอบ Light-4J ในองค์กร GitHub เดียวกันจึงจะได้รับการพัฒนาและบำรุงรักษาพร้อมกับกรอบ

ข้อกำหนดเบื้องต้น

ห้องสมุดรองรับ Java 8 ขึ้นไป หากคุณต้องการสร้างจากซอร์สโค้ดคุณต้องติดตั้ง JDK 8 ในพื้นที่ เพื่อรองรับ JDK หลายเวอร์ชันคุณสามารถใช้ sdkman

การใช้งาน

การเพิ่มการพึ่งพา

แพ็คเกจนี้มีอยู่ใน Maven Central

Maven:

< dependency >
    < groupId >com.networknt</ groupId >
    < artifactId >json-schema-validator</ artifactId >
    < version >1.5.3</ version >
</ dependency >

Gradle:

 dependencies {
    implementation ( group : 'com.networknt' , name : 'json-schema-validator' , version : '1.5.3' );
}

การตรวจสอบอินพุตกับสคีมา

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าอินพุตได้รับการตรวจสอบกับสคีมาอย่างไร มันประกอบด้วยขั้นตอนต่อไปนี้

การสร้างโรงงานสคีมาด้วยภาษาสคีมาเริ่มต้นและวิธีการเรียกใช้สคีมา
- การกำหนดค่าการแมป $id ไปยัง URI ดึงข้อมูลโดยใช้ schemaMappers
- การกำหนดค่าวิธีการสคีมาโดยใช้ URI ดึงข้อมูลโดยใช้ schemaLoaders ตัวอย่างเช่น Map<String, String> schemas ที่มีการแมปของการดึงข้อมูล URI ไปยังข้อมูลสคีมาเป็น String สามารถกำหนดค่าโดยใช้ builder.schemaLoaders(schemaLoaders -> schemaLoaders.schemas(schemas)) นอกจากนี้ยังยอมรับ Function<String, String> schemaRetrievalFunction
การสร้างการกำหนดค่าสำหรับการควบคุมพฤติกรรมการตรวจสอบความถูกต้อง
กำลังโหลดสคีมาจากตำแหน่งสคีมาพร้อมกับการกำหนดค่าตัวตรวจสอบ
การใช้สคีมาเพื่อตรวจสอบข้อมูลพร้อมกับการตั้งค่าการกำหนดค่าเฉพาะการดำเนินการใด ๆ เช่นสถานที่ตั้งหรือเปิดใช้งานการยืนยันรูปแบบหรือไม่

 // This creates a schema factory that will use Draft 2020-12 as the default if $schema is not specified
// in the schema data. If $schema is specified in the schema data then that schema dialect will be used
// instead and this version is ignored.
JsonSchemaFactory jsonSchemaFactory = JsonSchemaFactory . getInstance ( VersionFlag . V202012 , builder -> 
    // This creates a mapping from $id which starts with https://www.example.org/ to the retrieval URI classpath:schema/
    builder . schemaMappers ( schemaMappers -> schemaMappers . mapPrefix ( "https://www.example.org/" , "classpath:schema/" ))
);

SchemaValidatorsConfig . Builder builder = SchemaValidatorsConfig . builder ();
// By default the JDK regular expression implementation which is not ECMA 262 compliant is used
// Note that setting this requires including optional dependencies
// builder.regularExpressionFactory(GraalJSRegularExpressionFactory.getInstance());
// builder.regularExpressionFactory(JoniRegularExpressionFactory.getInstance());
SchemaValidatorsConfig config = builder . build ();

// Due to the mapping the schema will be retrieved from the classpath at classpath:schema/example-main.json.
// If the schema data does not specify an $id the absolute IRI of the schema location will be used as the $id.
JsonSchema schema = jsonSchemaFactory . getSchema ( SchemaLocation . of ( "https://www.example.org/example-main.json" ), config );
String input = "{ r n "
    + "  " main " : { r n "
    + "    " common " : { r n "
    + "      " field " : " invalidfield " r n "
    + "    } r n "
    + "  } r n "
    + "}" ;

Set < ValidationMessage > assertions = schema . validate ( input , InputFormat . JSON , executionContext -> {
    // By default since Draft 2019-09 the format keyword only generates annotations and not assertions
    executionContext . getExecutionConfig (). setFormatAssertionsEnabled ( true );
});

ตรวจสอบความถูกต้องของสคีมากับ meta-schema

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสคีมาได้รับการตรวจสอบความถูกต้องกับ meta-schema อย่างไร

นี่เป็นจริงเช่นเดียวกับการตรวจสอบอินพุตกับสคีมายกเว้นในกรณีนี้อินพุตคือสคีมาและสคีมาที่ใช้คือ meta-schema

โปรดทราบว่า Meta-Schemas สำหรับร่าง 4, ร่าง 6, ร่าง 7, ร่าง 2019-09 และร่าง 2020-12 ถูกรวมเข้ากับห้องสมุดและทรัพยากร ClassPath เหล่านี้จะถูกใช้โดยค่าเริ่มต้น

 JsonSchemaFactory jsonSchemaFactory = JsonSchemaFactory . getInstance ( VersionFlag . V202012 );

SchemaValidatorsConfig . Builder builder = SchemaValidatorsConfig . builder ();
// By default the JDK regular expression implementation which is not ECMA 262 compliant is used
// Note that setting this requires including optional dependencies
// builder.regularExpressionFactory(GraalJSRegularExpressionFactory.getInstance());
// builder.regularExpressionFactory(JoniRegularExpressionFactory.getInstance());
SchemaValidatorsConfig config = builder . build ();

// Due to the mapping the meta-schema will be retrieved from the classpath at classpath:draft/2020-12/schema.
JsonSchema schema = jsonSchemaFactory . getSchema ( SchemaLocation . of ( SchemaId . V202012 ), config );
String input = "{ r n "
    + "  " type " : " object " , r n "
    + "  " properties " : { r n "
    + "    " key " : { r n "
    + "      " title " : " My key " , r n "
    + "      " type " : " invalidtype " r n "
    + "    } r n "
    + "  } r n "
    + "}" ;
Set < ValidationMessage > assertions = schema . validate ( input , InputFormat . JSON , executionContext -> {
    // By default since Draft 2019-09 the format keyword only generates annotations and not assertions
    executionContext . getExecutionConfig (). setFormatAssertionsEnabled ( true );
});

ผลลัพธ์และรูปแบบผลลัพธ์

ผลลัพธ์

ประเภทของผลลัพธ์ต่อไปนี้ถูกสร้างขึ้นโดยไลบรารี

พิมพ์ คำอธิบาย

การยืนยัน ข้อผิดพลาดการตรวจสอบความถูกต้องที่สร้างขึ้นโดยคำหลักในอินสแตนซ์ข้อมูลอินพุตเฉพาะ โดยทั่วไปอธิบายไว้ใน ValidationMessage หรือใน OutputUnit โปรดทราบว่าตั้งแต่ร่าง 2019-09 คำหลักรูป format จะไม่สร้างการยืนยันตามค่าเริ่มต้นอีกต่อไปและแทนที่จะสร้างคำอธิบายประกอบเท่านั้นเว้นแต่จะได้รับการกำหนดค่าเป็นอย่างอื่นโดยใช้ตัวเลือกการกำหนดค่าหรือโดยใช้ meta-schema ที่ใช้คำศัพท์ที่เหมาะสม

คำอธิบายประกอบ ข้อมูลเพิ่มเติมที่สร้างขึ้นโดยคำหลักสำหรับอินสแตนซ์ข้อมูลอินพุตเฉพาะ โดยทั่วไปอธิบายไว้ใน OutputUnit การรวบรวมคำอธิบายประกอบและการรายงานจะปิดโดยค่าเริ่มต้น คำอธิบายประกอบที่ต้องการโดยคำหลักเช่น unevaluatedProperties หรือ unevaluatedItems จะถูกรวบรวมเพื่อวัตถุประสงค์ในการประเมินและไม่สามารถปิดใช้งานได้ แต่จะไม่ถูกรายงานเว้นแต่จะกำหนดค่าให้ทำเช่นนั้น

พิมพ์	คำอธิบาย
การยืนยัน	ข้อผิดพลาดการตรวจสอบความถูกต้องที่สร้างขึ้นโดยคำหลักในอินสแตนซ์ข้อมูลอินพุตเฉพาะ โดยทั่วไปอธิบายไว้ใน `ValidationMessage` หรือใน `OutputUnit` โปรดทราบว่าตั้งแต่ร่าง 2019-09 คำหลักรูป `format` จะไม่สร้างการยืนยันตามค่าเริ่มต้นอีกต่อไปและแทนที่จะสร้างคำอธิบายประกอบเท่านั้นเว้นแต่จะได้รับการกำหนดค่าเป็นอย่างอื่นโดยใช้ตัวเลือกการกำหนดค่าหรือโดยใช้ meta-schema ที่ใช้คำศัพท์ที่เหมาะสม
คำอธิบายประกอบ	ข้อมูลเพิ่มเติมที่สร้างขึ้นโดยคำหลักสำหรับอินสแตนซ์ข้อมูลอินพุตเฉพาะ โดยทั่วไปอธิบายไว้ใน `OutputUnit` การรวบรวมคำอธิบายประกอบและการรายงานจะปิดโดยค่าเริ่มต้น คำอธิบายประกอบที่ต้องการโดยคำหลักเช่น `unevaluatedProperties` หรือ `unevaluatedItems` จะถูกรวบรวมเพื่อวัตถุประสงค์ในการประเมินและไม่สามารถปิดใช้งานได้ แต่จะไม่ถูกรายงานเว้นแต่จะกำหนดค่าให้ทำเช่นนั้น

ข้อมูลต่อไปนี้ใช้เพื่ออธิบายผลลัพธ์ทั้งสองประเภท

พิมพ์	คำอธิบาย
เส้นทางการประเมินผล	นี่คือชุดของคีย์จากรูทซึ่งการประเมินผ่านผ่านไปถึงสคีมาเพื่อประเมินอินสแตนซ์ ซึ่งรวมถึง `$ref` และ `$dynamicRef` เช่น `/properties/bar/$ref/properties/bar-prop`
ที่ตั้งสคีมา	นี่คือ IRI ที่เป็นที่ยอมรับของสคีมารวมถึงชิ้นส่วนตัวชี้ JSON ไปยังสคีมาที่ใช้สำหรับการประเมินอินสแตนซ์ เช่น `https://json-schema.org/schemas/example#/$defs/bar/properties/bar-prop`
ตำแหน่งอินสแตนซ์	นี่คือชิ้นส่วนตัวชี้ JSON สำหรับข้อมูลอินสแตนซ์ที่กำลังประเมิน เช่น `/bar/bar-prop`

การยืนยันมีข้อมูลเพิ่มเติมต่อไปนี้

พิมพ์	คำอธิบาย
ข้อความ	ข้อความแสดงข้อผิดพลาดการตรวจสอบความถูกต้อง
รหัส	รหัสข้อผิดพลาด
คีย์ข้อความ	คีย์ข้อความที่ใช้สำหรับการสร้างข้อความสำหรับการแปล
ข้อโต้แย้ง	อาร์กิวเมนต์ที่ใช้ในการสร้างข้อความ
พิมพ์	คำหลักที่สร้างข้อความ
คุณสมบัติ	ชื่อคุณสมบัติที่ทำให้เกิดข้อผิดพลาดการตรวจสอบความถูกต้องสำหรับคำหลัก `required` โปรดทราบว่านี่ไม่ใช่ส่วนหนึ่งของตำแหน่งอินสแตนซ์ตามที่ชี้ไปที่โหนดอินสแตนซ์
โหนดสคีมา	`JsonNode` ชี้ไปที่ตำแหน่งสคีมา นี่คือข้อมูลสคีมาที่ทำให้ข้อมูลอินพุตล้มเหลว เป็นไปได้ที่จะได้รับข้อมูลตำแหน่งโดยการกำหนดค่า `JsonSchemaFactory` ด้วย `JsonNodeReader` ที่ใช้ `LocationJsonNodeFactoryFactory` และใช้ `JsonNodes.tokenLocationOf(schemaNode)`
โหนดอินสแตนซ์	`JsonNode` ชี้ไปที่ตำแหน่งอินสแตนซ์ นี่คือข้อมูลอินพุตที่ล้มเหลวในการตรวจสอบ เป็นไปได้ที่จะได้รับข้อมูลตำแหน่งโดยการกำหนดค่า `JsonSchemaFactory` ด้วย `JsonNodeReader` ที่ใช้ `LocationJsonNodeFactoryFactory` และใช้ `JsonNodes.tokenLocationOf(instanceNode)`
ข้อผิดพลาด	ข้อผิดพลาด
รายละเอียด	รายละเอียดเพิ่มเติมที่สามารถตั้งค่าโดยการใช้งานคำหลักที่กำหนดเอง สิ่งนี้ไม่ได้ใช้โดยไลบรารี

คำอธิบายประกอบมีข้อมูลเพิ่มเติมต่อไปนี้

พิมพ์	คำอธิบาย
ค่า	ค่าคำอธิบายประกอบที่สร้างขึ้น

ข้อมูลบรรทัดและคอลัมน์

ไลบรารีสามารถกำหนดค่าเพื่อจัดเก็บข้อมูลบรรทัดและคอลัมน์ในอินสแตนซ์ JsonNode สำหรับอินสแตนซ์และโหนดสคีมา สิ่งนี้จะส่งผลเสียต่อประสิทธิภาพและไม่ได้รับการกำหนดค่าตามค่าเริ่มต้น

สิ่งนี้ทำได้โดยการกำหนดค่า JsonNodeReader ที่ใช้ LocationJsonNodeFactoryFactory บน JsonSchemaFactory ข้อมูล JsonLocation สามารถเรียกคืนได้โดยใช้ JsonNodes.tokenLocationOf(jsonNode)

 String schemaData = "{ r n "
                + "  " $id " : " https://schema/myschema " , r n "
                + "  " properties " : { r n "
                + "    " startDate " : { r n "
                + "      " format " : " date " , r n "
                + "      " minLength " : 6 r n "
                + "    } r n "
                + "  } r n "
                + "}" ;
String inputData = "{ r n "
                + "  " startDate " : " 1 " r n "
                + "}" ;
JsonSchemaFactory factory = JsonSchemaFactory . getInstance ( VersionFlag . V202012 ,
        builder -> builder . jsonNodeReader ( JsonNodeReader . builder (). locationAware (). build ()));
SchemaValidatorsConfig config = SchemaValidatorsConfig . builder (). build ();
JsonSchema schema = factory . getSchema ( schemaData , InputFormat . JSON , config );
Set < ValidationMessage > messages = schema . validate ( inputData , InputFormat . JSON , executionContext -> {
    executionContext . getExecutionConfig (). setFormatAssertionsEnabled ( true );
});
List < ValidationMessage > list = messages . stream (). collect ( Collectors . toList ());
ValidationMessage format = list . get ( 0 );
JsonLocation formatInstanceNodeTokenLocation = JsonNodes . tokenLocationOf ( format . getInstanceNode ());
JsonLocation formatSchemaNodeTokenLocation = JsonNodes . tokenLocationOf ( format . getSchemaNode ());
ValidationMessage minLength = list . get ( 1 );
JsonLocation minLengthInstanceNodeTokenLocation = JsonNodes . tokenLocationOf ( minLength . getInstanceNode ());
JsonLocation minLengthSchemaNodeTokenLocation = JsonNodes . tokenLocationOf ( minLength . getSchemaNode ());

assertEquals ( "format" , format . getType ());
assertEquals ( "date" , format . getSchemaNode (). asText ());
assertEquals ( 5 , formatSchemaNodeTokenLocation . getLineNr ());
assertEquals ( 17 , formatSchemaNodeTokenLocation . getColumnNr ());
assertEquals ( "1" , format . getInstanceNode (). asText ());
assertEquals ( 2 , formatInstanceNodeTokenLocation . getLineNr ());
assertEquals ( 16 , formatInstanceNodeTokenLocation . getColumnNr ());
assertEquals ( "minLength" , minLength . getType ());
assertEquals ( "6" , minLength . getSchemaNode (). asText ());
assertEquals ( 6 , minLengthSchemaNodeTokenLocation . getLineNr ());
assertEquals ( 20 , minLengthSchemaNodeTokenLocation . getColumnNr ());
assertEquals ( "1" , minLength . getInstanceNode (). asText ());
assertEquals ( 2 , minLengthInstanceNodeTokenLocation . getLineNr ());
assertEquals ( 16 , minLengthInstanceNodeTokenLocation . getColumnNr ());
assertEquals ( 16 , minLengthInstanceNodeTokenLocation . getColumnNr ());

รูปแบบเอาท์พุท

ไลบรารีนี้ใช้รูปแบบการตั้งค่าสถานะรายการและรูปแบบเอาต์พุตลำดับชั้นที่กำหนดไว้ในข้อกำหนดสำหรับเอาต์พุตที่สามารถอ่านได้สำหรับเครื่องสำหรับการตรวจสอบความถูกต้องของ JSON Schema และคำอธิบายประกอบ

รูปแบบรายการและลำดับชั้นมีประโยชน์อย่างยิ่งสำหรับการทำความเข้าใจว่าระบบมาถึงผลลัพธ์ที่เฉพาะเจาะจงได้อย่างไร

รูปแบบเอาต์พุต	คำอธิบาย
ค่าเริ่มต้น	สร้างรายการการยืนยัน
บูลีน	ส่งคืน `true` หากการตรวจสอบความถูกต้องสำเร็จ โปรดทราบว่าตัวเลือก Fail Fast เปิดใช้งานโดยค่าเริ่มต้นสำหรับรูปแบบเอาต์พุตนี้
ธง	ส่งคืนวัตถุ `OutputFlag` ที่มี `valid` มี `true` หากการตรวจสอบความถูกต้องสำเร็จ โปรดทราบว่าตัวเลือก Fail Fast เปิดใช้งานโดยค่าเริ่มต้นสำหรับรูปแบบเอาต์พุตนี้
รายการ	ส่งคืนวัตถุ `OutputUnit` พร้อม `details` พร้อมรายการ `OutputUnit` Objects พร้อมการยืนยันและคำอธิบายประกอบ โปรดทราบว่าคำอธิบายประกอบจะไม่ได้รับการรวบรวมโดยค่าเริ่มต้นและจะต้องเปิดใช้งานเนื่องจากจะส่งผลกระทบต่อประสิทธิภาพ
เกี่ยวกับลำดับชั้น	ส่งคืนวัตถุ `OutputUnit` ที่มีลำดับชั้นของวัตถุ `OutputUnit` สำหรับเส้นทางการประเมินด้วยการยืนยันและคำอธิบายประกอบ โปรดทราบว่าคำอธิบายประกอบจะไม่ได้รับการรวบรวมโดยค่าเริ่มต้นและจะต้องเปิดใช้งานเนื่องจากจะส่งผลกระทบต่อประสิทธิภาพ

ตัวอย่างต่อไปนี้แสดงวิธีการสร้างรูปแบบเอาต์พุตแบบลำดับชั้นด้วยการรวบรวมคำอธิบายประกอบและการรายงานที่เปิดใช้งานและเปิดการยืนยันรูปแบบ

 JsonSchemaFactory factory = JsonSchemaFactory . getInstance ( VersionFlag . V202012 );
SchemaValidatorsConfig config = SchemaValidatorsConfig (). builder (). formatAssertionsEnabled ( true ). build ();
JsonSchema schema = factory . getSchema ( SchemaLocation . of ( "https://json-schema.org/schemas/example" ), config );
        
OutputUnit outputUnit = schema . validate ( inputData , InputFormat . JSON , OutputFormat . HIERARCHICAL , executionContext -> {
    executionContext . getExecutionConfig (). setAnnotationCollectionEnabled ( true );
    executionContext . getExecutionConfig (). setAnnotationCollectionFilter ( keyword -> true );
});

ต่อไปนี้เป็นตัวอย่างตัวอย่างจากรูปแบบลำดับชั้น

{
  "valid" : false ,
  "evaluationPath" : " " ,
  "schemaLocation" : " https://json-schema.org/schemas/example# " ,
  "instanceLocation" : " " ,
  "droppedAnnotations" : {
    "properties" : [ " foo " , " bar " ],
    "title" : " root "
  },
  "details" : [ {
    "valid" : false ,
    "evaluationPath" : " /properties/foo/allOf/0 " ,
    "schemaLocation" : " https://json-schema.org/schemas/example#/properties/foo/allOf/0 " ,
    "instanceLocation" : " /foo " ,
    "errors" : {
      "required" : " required property 'unspecified-prop' not found "
    }
  }, {
    "valid" : false ,
    "evaluationPath" : " /properties/foo/allOf/1 " ,
    "schemaLocation" : " https://json-schema.org/schemas/example#/properties/foo/allOf/1 " ,
    "instanceLocation" : " /foo " ,
    "droppedAnnotations" : {
      "properties" : [ " foo-prop " ],
      "title" : " foo-title " ,
      "additionalProperties" : [ " foo-prop " , " other-prop " ]
    },
    "details" : [ {
      "valid" : false ,
      "evaluationPath" : " /properties/foo/allOf/1/properties/foo-prop " ,
      "schemaLocation" : " https://json-schema.org/schemas/example#/properties/foo/allOf/1/properties/foo-prop " ,
      "instanceLocation" : " /foo/foo-prop " ,
      "errors" : {
        "const" : " must be a constant value 1 "
      },
      "droppedAnnotations" : {
        "title" : " foo-prop-title "
      }
    } ]
  }, {
    "valid" : false ,
    "evaluationPath" : " /properties/bar/$ref " ,
    "schemaLocation" : " https://json-schema.org/schemas/example#/$defs/bar " ,
    "instanceLocation" : " /bar " ,
    "droppedAnnotations" : {
      "properties" : [ " bar-prop " ],
      "title" : " bar-title "
    },
    "details" : [ {
      "valid" : false ,
      "evaluationPath" : " /properties/bar/$ref/properties/bar-prop " ,
      "schemaLocation" : " https://json-schema.org/schemas/example#/$defs/bar/properties/bar-prop " ,
      "instanceLocation" : " /bar/bar-prop " ,
      "errors" : {
        "minimum" : " must have a minimum value of 10 "
      },
      "droppedAnnotations" : {
        "title" : " bar-prop-title "
      }
    } ]
  } ]
}

การกำหนดค่า

การกำหนดค่าการดำเนินการ

ชื่อ	คำอธิบาย	ค่าเริ่มต้น
`annotationCollectionEnabled`	ควบคุมว่ามีการรวบรวมคำอธิบายประกอบระหว่างการประมวลผลหรือไม่ โปรดทราบว่าการรวบรวมคำอธิบายประกอบจะส่งผลเสียต่อประสิทธิภาพ	`false`
`annotationCollectionFilter`	เพรดิเคตที่ใช้ในการควบคุมคำหลักที่จะรวบรวมและรายงานคำอธิบายประกอบสำหรับ สิ่งนี้ต้องการ `annotationCollectionEnabled` ที่เป็น `true`	`keyword -> false`
`locale`	สถานที่ที่จะใช้สำหรับการสร้างข้อความในการ `ValidationMessage` โปรดทราบว่าค่านี้ถูกคัดลอกจาก `SchemaValidatorsConfig` สำหรับการดำเนินการแต่ละครั้ง	`Locale.getDefault()`
`failFast`	ไม่ว่าจะส่งคืนความล้มเหลวทันทีเมื่อมีการยืนยัน โปรดทราบว่าค่านี้ถูกคัดลอกจาก `SchemaValidatorsConfig` สำหรับการดำเนินการแต่ละครั้ง แต่ถูกตั้งค่าเป็น `true` สำหรับแบบบูลีนและรูปแบบเอาต์พุต	`false`
`formatAssertionsEnabled`	ค่าเริ่มต้นคือการสร้างการยืนยันรูปแบบจากร่าง 4 ถึงร่าง 7 และเพื่อสร้างคำอธิบายประกอบจากร่าง 2019-09 การตั้งค่าเป็น `true` หรือ `false` จะแทนที่พฤติกรรมเริ่มต้น	`null`
`debugEnabled`	ควบคุมว่ามีการเปิดใช้งานการบันทึกการดีบักสำหรับการบันทึกข้อมูลโหนดเมื่อทำการประมวลผลหรือไม่ โปรดทราบว่าสิ่งนี้จะสร้างบันทึกจำนวนมากที่จะส่งผลกระทบต่อประสิทธิภาพ	`false`

การกำหนดค่าการตรวจสอบความถูกต้องของสคีมา

ชื่อ	คำอธิบาย	ค่าเริ่มต้น
`applyDefaultsStrategy`	กลยุทธ์สำหรับการใช้ค่าเริ่มต้นเมื่อเดินเมื่อหายไปหรือโหนดโมฆะ	`ApplyDefaultsStrategy.EMPTY_APPLY_DEFAULTS_STRATEGY`
`cacheRefs`	ไม่ว่าจะเป็น schemas ที่โหลดจาก Refs จะถูกแคชและนำกลับมาใช้ใหม่สำหรับการวิ่งครั้งต่อไป การตั้งค่าสิ่งนี้เป็น `false` จะส่งผลกระทบต่อประสิทธิภาพ แต่อาจเป็นสิ่งจำเป็นเพื่อป้องกันการใช้หน่วยความจำสูงสำหรับแคชหากมีการใช้แอปพลิเคชันที่ซ้อนกันหลายตัวเช่น `anyOf` , `oneOf` และ `allOf`	`true`
`discriminatorKeywordEnabled`	ไม่ว่าจะเป็นคำหลัก `discriminator` ได้รับการจัดการตาม OpenAPI 3 หรือไม่	`false`
`errorMessageKeyword`	คำหลักที่ใช้สำหรับข้อความแสดงข้อผิดพลาดที่กำหนดเองในสคีมา หากไม่ได้ตั้งค่าคุณสมบัตินี้จะถูกปิดใช้งาน โดยทั่วไปจะถูกตั้งค่าเป็น `errorMessage` หรือ `message`	`null`
`executionContextCustomizer`	สิ่งนี้สามารถใช้ในการปรับแต่ง `ExecutionContext` ที่สร้างโดย `JsonSchema` สำหรับการตรวจสอบแต่ละครั้ง	`null`
`failFast`	ไม่ว่าจะส่งคืนความล้มเหลวทันทีเมื่อมีการยืนยัน	`false`
`formatAssertionsEnabled`	ค่าเริ่มต้นคือการสร้างการยืนยันรูปแบบจากร่าง 4 ถึงร่าง 7 และเพื่อสร้างคำอธิบายประกอบจากร่าง 2019-09 การตั้งค่าเป็น `true` หรือ `false` จะแทนที่พฤติกรรมเริ่มต้น	`null`
`javaSemantics`	ความหมายของ Java จะใช้สำหรับคำหลัก `type` หรือไม่	`false`
`locale`	สถานที่ที่จะใช้สำหรับการสร้างข้อความในการ `ValidationMessage`	`Locale.getDefault()`
`losslessNarrowing`	ไม่ว่าจะใช้การ จำกัด การสูญเสียแบบไม่มีสำหรับคำ `type` หรือไม่	`false`
`messageSource`	สิ่งนี้ใช้เพื่อดึงข้อความเฉพาะสถานที่	`DefaultMessageSource.getInstance()`
`nullableKeywordEnabled`	ไม่ว่าจะเป็นคำหลักที่ `nullable` รับการจัดการตาม OpenAPI 3.0 หรือไม่ สิ่งนี้มีผลต่อคำหลัก `enum` และ `type`	`false`
`pathType`	ประเภทเส้นทางที่จะใช้สำหรับการรายงานตำแหน่งอินสแตนซ์และเส้นทางการประเมินผล ตั้งค่าเป็น `PathType.JSON_PATH` เพื่อใช้เส้นทาง JSON	`PathType.JSON_POINTER`
`preloadJsonSchema`	ไม่ว่าจะมีการโหลดสคีมาก่อนประมวลผลอินพุตใด ๆ สิ่งนี้จะใช้หน่วยความจำ แต่การดำเนินการตรวจสอบจะเร็วขึ้น	`true`
`preloadJsonSchemaRefMaxNestingDepth`	ความลึกสูงสุดของเส้นทางการประเมินเพื่อโหลดล่วงหน้าเมื่อโหลดการอ้างอิงล่วงหน้า	`40`
`readOnly`	ไม่ว่าจะเป็นสคีมาเท่านั้น สิ่งนี้มีผลต่อคำหลัก `readOnly`	`null`
`regularExpressionFactory`	โรงงานที่ใช้ในการสร้างนิพจน์ทั่วไปเช่น `JoniRegularExpressionFactory` หรือ `GraalJSRegularExpressionFactory` สิ่งนี้ต้องการการพึ่งพาการเพิ่มด้วยตนเองในโครงการหรือ `ClassNotFoundException` จะถูกโยนลงไป	`JDKRegularExpressionFactory.getInstance()`
`schemaIdValidator`	สิ่งนี้ใช้เพื่อปรับแต่งวิธีการตรวจสอบค่า `$id` โปรดทราบว่าการใช้งานเริ่มต้นจะอนุญาตให้มีการระบุชิ้นส่วนที่ไม่ว่างเปล่าซึ่งไม่มีการระบุ IRI ฐานและยังอนุญาตให้ค่า IRI `$id` ที่ไม่ละลายในสคีมารูท	`JsonSchemaIdValidator.DEFAULT`
`strict`	นี่คือการตั้งค่าว่าคำหลักมีความเข้มงวดในการตรวจสอบความถูกต้องหรือไม่ สิ่งนี้ขึ้นอยู่กับผู้ตรวจสอบแต่ละคน
`typeLoose`	ไม่ว่าจะตีความประเภทในลักษณะที่หลวม หากตั้งค่าเป็นจริงค่าเดียวสามารถตีความได้ว่าเป็นอาร์เรย์ขนาด 1 สตริงอาจตีความได้ว่าเป็นจำนวนเต็มหรือบูลีน	`false`
`writeOnly`	ไม่ว่าจะเป็นสคีมาเท่านั้น สิ่งนี้มีผลต่อคำหลัก `writeOnly`	`null`

ข้อควรพิจารณาด้านประสิทธิภาพ

เมื่อห้องสมุดสร้างสคีมาจากโรงงานสคีมามันจะสร้างอินสแตนซ์การตรวจสอบความถูกต้องที่แตกต่างกันสำหรับแต่ละสถานที่บนเส้นทางการประเมิน ซึ่งหมายความว่าหากมี $ref ที่แตกต่างกันซึ่งอ้างอิงตำแหน่งสคีมาเดียวกันอินสแตนซ์การตรวจสอบความถูกต้องที่แตกต่างกันจะถูกสร้างขึ้นสำหรับแต่ละเส้นทางการประเมินผล

เมื่อสคีมาถูกสร้างขึ้นไลบรารีจะทำการตรวจสอบความถูกต้องทั้งหมดโดยอัตโนมัติและแก้ไขการอ้างอิงโดยอัตโนมัติ สิ่งนี้สามารถปิดใช้งานได้ด้วยตัวเลือก preloadJsonSchema ใน SchemaValidatorsConfig ณ จุดนี้จะไม่มีข้อยกเว้นใด ๆ หากไม่สามารถแก้ไขการอ้างอิงได้ หากมีการอ้างอิงที่เป็นวงจรเฉพาะรอบแรกเท่านั้นที่จะโหลดไว้ล่วงหน้า หากคุณต้องการให้แน่ใจว่าการอ้างอิงระยะไกลสามารถแก้ไขได้ทั้งหมดจะต้องมีการเรียกใช้วิธี initializeValidators JsonSchema ซึ่งจะทำการยกเว้นหากมีการอ้างอิงที่ไม่สามารถแก้ไขได้

อินสแตนซ์สำหรับ JsonSchemaFactory และ JsonSchema ที่สร้างขึ้นจากมันถูกออกแบบมาให้มีความปลอดภัยจากเธรดหากการกำหนดค่าไม่ได้รับการแก้ไขและควรแคชและนำกลับมาใช้ใหม่ การไม่ใช้ JsonSchema ซ้ำหมายความว่าข้อมูลสคีมาจะต้องแยกวิเคราะห์ซ้ำด้วยอินสแตนซ์ของการตรวจสอบความถูกต้องและการอ้างอิงที่ได้รับการแก้ไข เมื่อการอ้างอิงได้รับการแก้ไขตัวตรวจสอบที่สร้างขึ้นจะถูกแคช สำหรับ schemas ที่มีการอ้างอิงที่ซ้อนกันอย่างลึกซึ้งหน่วยความจำที่จำเป็นสำหรับผู้ตรวจสอบอาจสูงมากซึ่งในกรณีนี้การแคชอาจต้องปิดการใช้งานโดยใช้ตัวเลือก cacheRefs ใน SchemaValidatorsConfig การปิดการใช้งานสิ่งนี้จะหมายถึงตัวตรวจสอบจากการอ้างอิงจะต้องมีการสร้างใหม่สำหรับการตรวจสอบแต่ละครั้งซึ่งจะส่งผลกระทบต่อประสิทธิภาพ

การรวบรวมคำอธิบายประกอบจะส่งผลเสียต่อประสิทธิภาพการตรวจสอบ

ข้อมูลจำเพาะร่างก่อนหน้านี้มีคำหลักน้อยกว่าซึ่งอาจส่งผลกระทบต่อประสิทธิภาพ ตัวอย่างเช่นการใช้คำหลัก unevaluatedProperties หรือ unevaluatedItems จะเรียกรวบรวมคำอธิบายประกอบในตัวตรวจสอบที่เกี่ยวข้องเช่น properties หรือ items ตรวจสอบรายการ

นี่ไม่ได้หมายความว่าการใช้สคีมาที่มีข้อมูลจำเพาะร่างในภายหลังจะทำให้เกิดผลกระทบโดยอัตโนมัติ ตัวอย่างเช่นตัวตรวจสอบ properties จะทำการตรวจสอบเพื่อตรวจสอบว่าจำเป็นต้องรวบรวมคำอธิบายประกอบหรือไม่และตรวจสอบว่า meta-schema มีคำหลัก unevaluatedProperties ตรวจสอบและไม่ได้รับการประเมินและคำหลัก unevaluatedProperties ผ่านการประเมิน

ข้อควรพิจารณาด้านความปลอดภัย

ห้องสมุดสันนิษฐานว่า schemas ที่โหลดนั้นเชื่อถือได้ รูปแบบความปลอดภัยนี้จะถือว่ากรณีการใช้งานที่ schemas ถูกรวมกับแอปพลิเคชันบน classpath

ปัญหา	คำอธิบาย	การบรรเทา
การโหลดสคีมา	ไลบรารีโดยค่าเริ่มต้นจะโหลด schemas จาก classpath และผ่านอินเทอร์เน็ตหากจำเป็น	`DisallowSchemaLoader` สามารถกำหนดค่าให้ไม่อนุญาตให้ดึงสคีมา อีกทางเลือกหนึ่งที่อนุญาตให้มีการกำหนด `AllowSchemaLoader` เพื่อ จำกัด ม่านตาดึงที่ได้รับอนุญาต
การแคชสคีมา	ไลบรารีโดยค่าเริ่มต้นและการอ้างอิงแคชเมื่อโหลด schemas ในขณะที่มีความลึกของการทำรังสูงสุดเมื่อ schemas การโหลดล่วงหน้ายังคงเป็นไปได้ที่จะสร้างสคีมาที่มีพัดลมที่ใช้หน่วยความจำจำนวนมากจากเซิร์ฟเวอร์	ตั้งค่าตัวเลือก `cacheRefs` ใน `SchemaValidatorsConfig` เป็นเท็จ
การแสดงออกปกติ	ห้องสมุดไม่ได้ตรวจสอบว่านิพจน์ปกติที่กำหนดนั้นมีความอ่อนไหวต่อการปฏิเสธการบริการ (redos)	สามารถกำหนดค่าการตรวจสอบความถูก `AllowRegularExpressionFactory` ในนิพจน์ทั่วไปที่อนุญาต
ข้อผิดพลาดการตรวจสอบความถูกต้อง	ไลบรารีโดยค่าเริ่มต้นพยายามส่งคืนข้อผิดพลาดการตรวจสอบทั้งหมด การใช้แอพพลิเคชั่นเช่น `allOf` ที่มี schemas จำนวนมากอาจส่งผลให้เกิดข้อผิดพลาดการตรวจสอบจำนวนมากที่ทำให้หน่วยความจำ	ตั้งค่าตัวเลือก `failFast` ใน `SchemaValidatorsConfig` เพื่อส่งคืนทันทีเมื่อพบข้อผิดพลาดครั้งแรก สามารถใช้ `OutputFormat.BOOLEAN` หรือ `OutputFormat.FLAG` ได้

เริ่มต้นอย่างรวดเร็ว

ปรับแต่งสคีมาดึง

การปรับแต่ง meta-schemas คำศัพท์คำหลักและรูปแบบ

ข้อกำหนด OpenAPI

ผู้ตรวจสอบ

การกำหนดค่า

รุ่นสเปค

การตรวจสอบ Yaml

บริบทนักสะสม

JSON Schema Walkers และ WalkListeners

การแสดงออกปกติ

ข้อความแสดงข้อผิดพลาดที่กำหนดเอง

ภาษาหลายภาษา

การตรวจสอบ Metaschema

การตรวจสอบระยะเวลา RFC 3339

โครงการ

Light-Rest-4J, Light-GraPHQL-4J และ Light-Hybrid-4J ใช้ไลบรารีนี้เพื่อตรวจสอบความถูกต้องของคำขอและการตอบสนองตามข้อกำหนด หากคุณใช้เฟรมเวิร์กอื่น ๆ เช่น Spring Boot คุณสามารถใช้ OpenApivalIdator ซึ่งเป็นตัวตรวจสอบ OpenAPI 3.0 ทั่วไปตามข้อกำหนดของ OpenAPI 3.0

หากคุณมีโครงการที่ใช้ห้องสมุดนี้โปรดส่ง PR เพื่อเพิ่มโครงการของคุณด้านล่าง