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 TutorAspire .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 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

JSON Validator Java

Next TopicPseudocode Java

JSON Validator Java

JSON Validator Java

Java String indexOf() method

JavaScript String indexOf() Method

You may also like