JSON Validator Java

In Java, JSON, i.e., JavaScript Object Notation, plays a very important role in manipulating server-side response. In Java, we can validate JSON documents against a JSON schema. In order to perform the validation, we use the networknt JSON Schema validator library.

The reason for using this library is that it uses Jackson as a JSON library and supports the latest JSON Schema version. The networknt library is a Java implementation of the JSON Schema Core Draft v4, v6, v7, and v2019-09(Which we use in our example) specification for JSON schema validation. It has Jackson as a default JSON parser.

First, we take an example of JSON document and JSON schema, which we use in our program to perform validation.

JSON Document

{
  "name": "Emma Watson",
  "artist": "Paul Walker",
  "description": null,
  "tags": ["oil", "famous"]
}

JSON Schema

{
	"$schema": "https://json-schema.org/draft/2019-09/schema#",
	"$id+": "http://my-paintings-api.com/schemas/painting-schema.json",
	"type": "object",
	"title": "Painting",
	"description": "Painting information",
	"additionalProperties": true,
	"required": ["name", "artist", "description", "tags"],
	"properties": {
		"name": {
			"type": "string",
			"description": "Painting name"
		},
		"artist": { 
			"type": "string",
			"maxLength": 50,
			"description": "Name of the artist"
		},
		"description": {
			"type": ["string", "null"],
			"description": "Painting description"
		},
		"tags": {
			"type": "array",
			"items": { "$ref": "#/$defs/tag" }
		}
	},
	"$defs": {
		"tag": {
			"type": "string",
			"enum": ["oil", "watercolor", "digital", "famous"]
		}
	}
}

We add the following dependency in our pom.xml file.

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

We can also use the org.everit.json library for validating the JSON object. To use it, we need to add the following dependency in our pom.xml file:

<dependency>
    <groupId>org.everit.json</groupId>
    <artifactId>org.everit.json.schema</artifactId>
    <version>1.11.1</version>
</dependency>

In our case, we use the networknt library of Java.

We use the following steps to validate the JSON document:

Create a new maven project.
Add the JSON schema validator dependency in our pom.xml file.
Read the data and the schema from the JSON document using ObjectMapper.
Use validate() method of the JsonSchemaFactory to validate the JSON document.
Store the returned result in the validation set print it on the screen.

Everything is set up now, so we can implement the actual code of validating the JSON document.

JsonValidatorExample.java

//import required classes and packages
package javaTpoint.ObjectToJsonConversion;

import java.io.InputStream;	
import java.util.Set;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.networknt.schema.JsonSchema;
import com.networknt.schema.JsonSchemaFactory;
import com.networknt.schema.SpecVersion;
import com.networknt.schema.ValidationMessage;

// create class to validate JSON document
public class JsonValidatorExample {
	
	// create inputStreamFromClasspath() method to load the JSON data from the class path  
	private static InputStream inputStreamFromClasspath( String path ) {
		
		// returning stream
	    return Thread.currentThread().getContextClassLoader().getResourceAsStream( path );
	}
	
	// main() method start
	public static void main( String[] args ) throws Exception {
	    
		// create instance of the ObjectMapper class
		ObjectMapper objectMapper = new ObjectMapper();
		
		// create an instance of the JsonSchemaFactory using version flag
	    JsonSchemaFactory schemaFactory = JsonSchemaFactory.getInstance( SpecVersion.VersionFlag.V201909 );
	    
	    // store the JSON data in InputStream
	    try(
	            InputStream jsonStream = inputStreamFromClasspath( "C:\\Users\\ajeet\\eclipse-workspace\\data.json" );
	            InputStream schemaStream = inputStreamFromClasspath( "C:\\Users\\ajeet\\eclipse-workspace\\schema.json" )
	    ){
	    	
	    	// read data from the stream and store it into JsonNode
	        JsonNode json = objectMapper.readTree(jsonStream);
	        
	        // get schema from the schemaStream and store it into JsonSchema
	        JsonSchema schema = schemaFactory.getSchema(schemaStream);
	        
	        // create set of validation message and store result in it
	        Set<ValidationMessage> validationResult = schema.validate( json );
	 
	        // show the validation errors 
	        if (validationResult.isEmpty()) {
	        	
	        	// show custom message if there is no validation error 
	            System.out.println( "There is no validation errors" );
	        
	        } else {
	        	
	        	// show all the validation error
	            validationResult.forEach(vm -> System.out.println(vm.getMessage()));
	        }
	    }
	}
}

Description

In the above code, we use the VersionFlag. To obtain the JsonSchemaFactory, it is required to pass that version flag in the constructor. In our case, we use the 2019-09 version of JSON Schema.

We also use a custom helper method, i.e., inputStreamFromClasspath(), to load both the files from the classpath. We create an instance of the Jackson ObjectMapper class to read the JSON data from the InputStream. After that, we parse that InputStream data into a JsonNode object. Using the instance of the JsonSchemaFactory, we obtain the JsonSchema object to validate the JsonNode. We create a set of validation errors that contains one or more ValidationMessage objects. The validation set will be empty when there is no validation error.

Output