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.

—

Pending

Overview

Eval results

Files

Basic Validation

Name: tessl/maven-com-github-fge--json-schema-validator
Author: tessl

Core schema validation functionality for validating JSON instances against JSON Schema definitions. Provides both single-use validation and reusable schema instances for efficient repeated validation.

Capabilities

JsonSchemaFactory

Main factory for creating validators and schema instances with default or custom configurations.

/**
 * Main factory class for creating JSON Schema validators and schema instances
 */
public final class JsonSchemaFactory {
    /**
     * Get default factory instance with standard configuration
     * @return Default JsonSchemaFactory instance
     */
    public static JsonSchemaFactory byDefault();
    
    /**
     * Create a new factory builder for custom configuration
     * @return JsonSchemaFactoryBuilder for customization
     */
    public static JsonSchemaFactoryBuilder newBuilder();
    
    /**
     * Get a generic validator for one-off validations
     * @return JsonValidator instance
     */
    public JsonValidator getValidator();
    
    /**
     * Create a reusable schema instance from a JSON schema node
     * @param schema JsonNode containing the JSON schema
     * @return JsonSchema instance for validation
     * @throws ProcessingException if schema is invalid
     */
    public JsonSchema getJsonSchema(JsonNode schema) throws ProcessingException;
    
    /**
     * Create a schema instance from a JSON schema node with JSON Pointer
     * @param schema JsonNode containing the JSON schema
     * @param ptr JSON Pointer to specific schema location
     * @return JsonSchema instance for validation
     * @throws ProcessingException if schema is invalid or pointer is invalid
     */
    public JsonSchema getJsonSchema(JsonNode schema, String ptr) throws ProcessingException;
    
    /**
     * Load and create a schema instance from a URI
     * @param uri URI string pointing to the JSON schema
     * @return JsonSchema instance for validation
     * @throws ProcessingException if schema cannot be loaded or is invalid
     */
    public JsonSchema getJsonSchema(String uri) throws ProcessingException;
    
    /**
     * Get the raw validation processor for advanced usage
     * @return Processor for direct validation processing
     */
    public Processor<FullData, FullData> getProcessor();
    
    /**
     * Create a syntax validator for schema validation only
     * @return SyntaxValidator instance
     */
    public SyntaxValidator getSyntaxValidator();
    
    /**
     * Create a mutable copy of this factory for modification
     * @return JsonSchemaFactoryBuilder with current settings
     */
    public JsonSchemaFactoryBuilder thaw();
}

Usage Examples:

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.fge.jsonschema.main.JsonSchemaFactory;
import com.github.fge.jsonschema.main.JsonSchema;

// Create factory with default settings
JsonSchemaFactory factory = JsonSchemaFactory.byDefault();

// Load schema from JsonNode
ObjectMapper mapper = new ObjectMapper();
JsonNode schemaNode = mapper.readTree("{\n" +
    "  \"type\": \"object\",\n" +
    "  \"properties\": {\n" +
    "    \"name\": { \"type\": \"string\" },\n" +
    "    \"age\": { \"type\": \"integer\", \"minimum\": 0 }\n" +
    "  },\n" +
    "  \"required\": [\"name\"]\n" +
    "}");

JsonSchema schema = factory.getJsonSchema(schemaNode);

// Load schema from URI
JsonSchema uriSchema = factory.getJsonSchema("http://json-schema.org/draft-04/schema#");

// Use JSON Pointer to reference subschema
JsonNode complexSchema = mapper.readTree("{\n" +
    "  \"definitions\": {\n" +
    "    \"person\": {\n" +
    "      \"type\": \"object\",\n" +
    "      \"properties\": { \"name\": { \"type\": \"string\" } }\n" +
    "    }\n" +
    "  }\n" +
    "}");
JsonSchema subSchema = factory.getJsonSchema(complexSchema, "#/definitions/person");

JsonSchema

Reusable validator instance for a specific schema, optimized for repeated validation operations.

/**
 * Single-schema validator for efficient repeated validation
 */
public final class JsonSchema {
    /**
     * Validate a JSON instance against this schema
     * @param instance JsonNode to validate
     * @return ProcessingReport containing validation results
     * @throws ProcessingException if validation processing fails
     */
    public ProcessingReport validate(JsonNode instance) throws ProcessingException;
    
    /**
     * Validate with deep checking enabled for thorough validation
     * @param instance JsonNode to validate
     * @param deepCheck Enable deep validation checking
     * @return ProcessingReport containing validation results
     * @throws ProcessingException if validation processing fails
     */
    public ProcessingReport validate(JsonNode instance, boolean deepCheck) throws ProcessingException;
    
    /**
     * Validate without throwing exceptions on validation failure
     * @param instance JsonNode to validate
     * @return ProcessingReport containing validation results
     */
    public ProcessingReport validateUnchecked(JsonNode instance);
    
    /**
     * Validate unchecked with deep checking option
     * @param instance JsonNode to validate
     * @param deepCheck Enable deep validation checking
     * @return ProcessingReport containing validation results
     */
    public ProcessingReport validateUnchecked(JsonNode instance, boolean deepCheck);
    
    /**
     * Simple boolean check if instance is valid
     * @param instance JsonNode to validate
     * @return true if valid, false otherwise
     * @throws ProcessingException if validation processing fails
     */
    public boolean validInstance(JsonNode instance) throws ProcessingException;
    
    /**
     * Simple boolean check without throwing exceptions
     * @param instance JsonNode to validate
     * @return true if valid, false otherwise
     */
    public boolean validInstanceUnchecked(JsonNode instance);
}

Usage Examples:

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.fge.jsonschema.core.report.ProcessingReport;

// Reusable schema validation
JsonSchema schema = factory.getJsonSchema(schemaNode);
ObjectMapper mapper = new ObjectMapper();

// Validate multiple instances
JsonNode validData = mapper.readTree("{\"name\": \"John\", \"age\": 30}");
JsonNode invalidData = mapper.readTree("{\"age\": \"not-a-number\"}");

// Full validation with detailed report
ProcessingReport report1 = schema.validate(validData);
System.out.println("Valid: " + report1.isSuccess());

ProcessingReport report2 = schema.validate(invalidData);
if (!report2.isSuccess()) {
    for (ProcessingMessage message : report2) {
        System.out.println("Error: " + message.getMessage());
    }
}

// Simple boolean validation
boolean isValid1 = schema.validInstance(validData);  // true
boolean isValid2 = schema.validInstance(invalidData); // false

// Unchecked validation (no exceptions)
ProcessingReport uncheckedReport = schema.validateUnchecked(invalidData);
boolean uncheckedValid = schema.validInstanceUnchecked(invalidData);

// Deep validation for comprehensive checking
ProcessingReport deepReport = schema.validate(validData, true);

JsonValidator

Generic validator for one-off validations where you don't need to reuse the schema instance.

/**
 * Generic validator for one-time schema/instance validation pairs
 */
public final class JsonValidator {
    /**
     * Validate instance against schema
     * @param schema JsonNode containing the JSON schema
     * @param instance JsonNode to validate
     * @return ProcessingReport containing validation results
     * @throws ProcessingException if validation processing fails
     */
    public ProcessingReport validate(JsonNode schema, JsonNode instance) throws ProcessingException;
    
    /**
     * Validate with deep checking enabled
     * @param schema JsonNode containing the JSON schema
     * @param instance JsonNode to validate
     * @param deepCheck Enable deep validation checking
     * @return ProcessingReport containing validation results
     * @throws ProcessingException if validation processing fails
     */
    public ProcessingReport validate(JsonNode schema, JsonNode instance, boolean deepCheck) throws ProcessingException;
    
    /**
     * Validate without throwing exceptions on validation failure
     * @param schema JsonNode containing the JSON schema
     * @param instance JsonNode to validate
     * @return ProcessingReport containing validation results
     */
    public ProcessingReport validateUnchecked(JsonNode schema, JsonNode instance);
    
    /**
     * Validate unchecked with deep checking option
     * @param schema JsonNode containing the JSON schema
     * @param instance JsonNode to validate
     * @param deepCheck Enable deep validation checking
     * @return ProcessingReport containing validation results
     */
    public ProcessingReport validateUnchecked(JsonNode schema, JsonNode instance, boolean deepCheck);
}

Usage Examples:

import com.github.fge.jsonschema.main.JsonValidator;

// One-off validation without creating schema instance
JsonValidator validator = factory.getValidator();

// Validate schema/instance pairs directly
ProcessingReport result = validator.validate(schemaNode, instanceNode);
if (result.isSuccess()) {
    System.out.println("Validation passed");
} else {
    System.out.println("Validation failed:");
    for (ProcessingMessage msg : result) {
        System.out.println("  " + msg.getMessage());
    }
}

// Unchecked validation for graceful error handling
ProcessingReport uncheckedResult = validator.validateUnchecked(schemaNode, instanceNode);
boolean success = uncheckedResult.isSuccess();

// Deep validation for thorough checking
ProcessingReport deepResult = validator.validate(schemaNode, instanceNode, true);

JsonSchemaFactoryBuilder

Builder for creating customized factory instances with specific configurations.

/**
 * Builder for customizing JsonSchemaFactory configuration
 */
public final class JsonSchemaFactoryBuilder {
    /**
     * Set custom loading configuration for schema loading behavior
     * @param loadingCfg LoadingConfiguration instance
     * @return This builder for method chaining
     */
    public JsonSchemaFactoryBuilder setLoadingConfiguration(LoadingConfiguration loadingCfg);
    
    /**
     * Set validation configuration for validation behavior
     * @param validationCfg ValidationConfiguration instance
     * @return This builder for method chaining
     */
    public JsonSchemaFactoryBuilder setValidationConfiguration(ValidationConfiguration validationCfg);
    
    /**
     * Set custom report provider for validation reporting
     * @param reportProvider ReportProvider instance
     * @return This builder for method chaining
     */
    public JsonSchemaFactoryBuilder setReportProvider(ReportProvider reportProvider);
    
    /**
     * Create immutable factory instance with configured settings
     * @return JsonSchemaFactory with applied configuration
     */
    public JsonSchemaFactory freeze();
}

Usage Examples:

import com.github.fge.jsonschema.cfg.ValidationConfiguration;
import com.github.fge.jsonschema.core.load.configuration.LoadingConfiguration;

// Create custom factory with validation configuration
ValidationConfiguration validationCfg = ValidationConfiguration.newBuilder()
    .setUseFormat(false)  // Disable format validation
    .freeze();

JsonSchemaFactory customFactory = JsonSchemaFactory.newBuilder()
    .setValidationConfiguration(validationCfg)
    .freeze();

// Custom loading configuration
LoadingConfiguration loadingCfg = LoadingConfiguration.newBuilder()
    .dereferencing(Dereferencing.INLINE)
    .freeze();

JsonSchemaFactory factoryWithLoading = JsonSchemaFactory.newBuilder()
    .setLoadingConfiguration(loadingCfg)
    .setValidationConfiguration(validationCfg)
    .freeze();

Common Usage Patterns

Pattern 1: Reusable Schema Validation

// Best for validating multiple instances against the same schema
JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
JsonSchema schema = factory.getJsonSchema(schemaNode);

for (JsonNode instance : instances) {
    ProcessingReport report = schema.validate(instance);
    if (!report.isSuccess()) {
        // Handle validation failure
    }
}

Pattern 2: One-off Validation

// Best for single validations or different schemas each time
JsonValidator validator = JsonSchemaFactory.byDefault().getValidator();
ProcessingReport report = validator.validate(schemaNode, instanceNode);

Pattern 3: Boolean Validation

// When you only need pass/fail result
JsonSchema schema = factory.getJsonSchema(schemaNode);
boolean isValid = schema.validInstance(instanceNode);

Pattern 4: Error-Safe Validation

// When you want to avoid exceptions during validation
JsonSchema schema = factory.getJsonSchema(schemaNode);
ProcessingReport report = schema.validateUnchecked(instanceNode);
if (!report.isSuccess()) {
    // Process validation errors without exception handling
}

Install with Tessl CLI

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

docs

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