or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

basic-validation.mdcli.mdconfiguration.mdextensions.mdformat-validation.mdindex.mdsyntax-validation.md
tile.json

tessl/maven-com-github-fge--json-schema-validator

A comprehensive Java implementation of the JSON Schema validation specification supporting both draft v4 and v3 with complete validation capabilities and extensibility.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/com.github.fge/json-schema-validator@2.2.x

To install, run

npx @tessl/cli install tessl/maven-com-github-fge--json-schema-validator@2.2.0

index.mddocs/

JSON Schema Validator

JSON Schema Validator is a comprehensive Java implementation of the JSON Schema specification supporting both draft v4 and v3 (with hyperschema syntax support for v4). It provides complete validation capabilities for JSON documents against JSON Schema definitions, includes command-line interface functionality, supports Android development environments, and offers extensive configuration options for validation behavior.

Package Information

  • Package Name: com.github.fge:json-schema-validator
  • Package Type: maven
  • Language: Java
  • Installation: Add to Maven dependencies: 
    <dependency>
    <groupId>com.github.fge</groupId>
    <artifactId>json-schema-validator</artifactId>
    <version>2.2.6</version>
</dependency>
  • Gradle: implementation 'com.github.fge:json-schema-validator:2.2.6'

Core Imports

import com.github.fge.jsonschema.main.JsonSchemaFactory;
import com.github.fge.jsonschema.main.JsonSchema;
import com.github.fge.jsonschema.main.JsonValidator;
import com.github.fge.jsonschema.core.report.ProcessingReport;
import com.fasterxml.jackson.databind.JsonNode;

Basic Usage

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

// Basic validation using default factory
JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
JsonSchema schema = factory.getJsonSchema(schemaNode);
ProcessingReport report = schema.validate(instanceNode);

// Check if validation passed
boolean isValid = report.isSuccess();
if (!isValid) {
    System.out.println("Validation failed: " + report);
}

// One-off validation without creating schema instance
JsonValidator validator = factory.getValidator();
ProcessingReport result = validator.validate(schemaNode, instanceNode);

Architecture

JSON Schema Validator is built around several key components:

  • Factory Pattern: JsonSchemaFactory serves as the main entry point for creating validators and schemas
  • Schema Objects: JsonSchema provides reusable validation instances for specific schemas
  • Validation Engine: Configurable processors handle the validation logic with support for different JSON Schema versions
  • Configuration System: Extensive customization through ValidationConfiguration and LoadingConfiguration
  • Library System: Modular keyword and format validation through pluggable Library components
  • Report System: Detailed validation results with structured error reporting via ProcessingReport

Capabilities

Basic Validation

Core schema validation functionality for validating JSON instances against JSON Schema definitions. Supports both single-use and reusable validation patterns.

public final class JsonSchemaFactory {
    public static JsonSchemaFactory byDefault();
    public static JsonSchemaFactoryBuilder newBuilder();
    public JsonValidator getValidator();
    public SyntaxValidator getSyntaxValidator();
    public JsonSchema getJsonSchema(JsonNode schema) throws ProcessingException;
    public JsonSchema getJsonSchema(JsonNode schema, String ptr) throws ProcessingException;
    public JsonSchema getJsonSchema(String uri) throws ProcessingException;
    public Processor<FullData, FullData> getProcessor();
}

public final class JsonSchema {
    public ProcessingReport validate(JsonNode instance) throws ProcessingException;
    public ProcessingReport validate(JsonNode instance, boolean deepCheck) throws ProcessingException;
    public ProcessingReport validateUnchecked(JsonNode instance);
    public ProcessingReport validateUnchecked(JsonNode instance, boolean deepCheck);
    public boolean validInstance(JsonNode instance) throws ProcessingException;
    public boolean validInstanceUnchecked(JsonNode instance);
}

public final class JsonValidator {
    public ProcessingReport validate(JsonNode schema, JsonNode instance) throws ProcessingException;
    public ProcessingReport validate(JsonNode schema, JsonNode instance, boolean deepCheck) throws ProcessingException;
    public ProcessingReport validateUnchecked(JsonNode schema, JsonNode instance);
    public ProcessingReport validateUnchecked(JsonNode schema, JsonNode instance, boolean deepCheck);
}

Basic Validation

Configuration and Customization

Advanced configuration options for customizing validation behavior, including schema loading, validation rules, and library management.

public final class ValidationConfiguration {
    public static ValidationConfiguration byDefault();
    public static ValidationConfigurationBuilder newBuilder();
    public boolean getUseFormat();
    public Library getDefaultLibrary();
    public Map<JsonRef, Library> getLibraries();
    public MessageBundle getSyntaxMessages();
    public MessageBundle getValidationMessages();
}

public final class ValidationConfigurationBuilder {
    public ValidationConfigurationBuilder setDefaultVersion(SchemaVersion version);
    public ValidationConfigurationBuilder setUseFormat(boolean useFormat);
    public ValidationConfigurationBuilder addLibrary(String uri, Library library);
    public ValidationConfigurationBuilder setDefaultLibrary(String uri, Library library);
    public ValidationConfigurationBuilder setSyntaxMessages(MessageBundle syntaxMessages);
    public ValidationConfigurationBuilder setValidationMessages(MessageBundle validationMessages);
    public ValidationConfiguration freeze();
}

Configuration and Customization

Custom Keywords and Extensions

Extensibility system for adding custom validation keywords, format attributes, and validation logic through the library system.

public final class Library {
    public static LibraryBuilder newBuilder();
    public Dictionary<SyntaxChecker> getSyntaxCheckers();
    public Dictionary<Digester> getDigesters();
    public Dictionary<Constructor<? extends KeywordValidator>> getValidators();
    public Dictionary<FormatAttribute> getFormatAttributes();
}

public final class Keyword {
    public static KeywordBuilder newBuilder(String name);
}

public interface KeywordValidator {
    void validate(Processor<FullData, FullData> processor, ProcessingReport report, 
                 MessageBundle bundle, FullData data) throws ProcessingException;
}

Custom Keywords and Extensions

Syntax Validation

Dedicated functionality for validating JSON Schema syntax without performing instance validation.

public final class SyntaxValidator {
    public boolean schemaIsValid(JsonNode schema);
    public ProcessingReport validateSchema(JsonNode schema);
    public Processor<ValueHolder<SchemaTree>, ValueHolder<SchemaTree>> getProcessor();
}

Syntax Validation

Format Validation

Built-in format attribute validation for common data formats like email, URI, datetime, and extensible format validation system.

public interface FormatAttribute {
    EnumSet<NodeType> supportedTypes();
    void validate(ProcessingReport report, MessageBundle bundle, FullData data) 
        throws ProcessingException;
}

Format Validation

Command Line Interface

Command-line tools for JSON Schema validation from the command line with various output formats and options.

public final class Main {
    public static void main(String... args);
}

public enum RetCode {
    OK, SCHEMA_SYNTAX_ERROR, VALIDATION_FAILURE, CMD_LINE_ERROR
}

Command Line Interface

Exception Classes

public class ProcessingException extends Exception {
    public ProcessingException(ProcessingMessage message);
    public ProcessingException(ProcessingMessage message, Throwable cause);
}

public class InvalidInstanceException extends ProcessingException {
    public InvalidInstanceException(ProcessingMessage message);
}

Types

public interface ProcessingReport extends Iterable<ProcessingMessage> {
    boolean isSuccess();
    LogLevel getLogLevel();
    ProcessingMessage getMessage();
}

public final class ProcessingMessage {
    public String getMessage();
    public LogLevel getLevel();
    public JsonNode asJson();
}

public enum SchemaVersion {
    DRAFTV3("http://json-schema.org/draft-03/schema#"),
    DRAFTV4("http://json-schema.org/draft-04/schema#");
}

public enum NodeType {
    ARRAY, BOOLEAN, INTEGER, NULL, NUMBER, OBJECT, STRING
}

public interface Processor<I, O> {
    // Core processor interface for validation chains
}

public final class FullData {
    // Complete data structure containing schema and instance information
}

public final class ValueHolder<T> {
    // Generic value holder for processor chains
}

public final class SchemaTree {
    // Immutable schema tree representation
}

public interface MessageBundle {
    // Internationalized message bundle interface
}

public final class JsonRef {
    // JSON Reference implementation
}

public interface Dictionary<T> {
    // Generic dictionary interface for keyword collections
}

public enum LogLevel {
    DEBUG, INFO, WARNING, ERROR, FATAL
}