Validate JSON

In modern software development, JSON (JavaScript Object Notation) has become one of the main formats for data exchange due to its lightweight and easy-to-read characteristics. As JSON is widely used, it becomes especially important to ensure the legality of its format and the correctness of the data. Here are some common third-party libraries that can help developers verify the legality of the JSON format and detect errors.

Use AJV library To Validate JSON in JavaScript

AJV (Another JSON Validator) is a popular JSON validation library for Node.js. Here's an example of how to use AJV to validate a JSON object:

Step 1: Install AJV

npm install ajv

Step 2: Define the JSON Schema

Create a JSON schema that defines the structure of the JSON object you want to validate. For example:

const schema = {
  "type": "object",
  "properties": {
    "name": {"type": "string"},
    "age": {"type": "integer"}
  },
  "required": ["name", "age"]
};

Step 3: Create an AJV Instance

Create an instance of the AJV validator:

const Ajv = require('ajv');
const ajv = new Ajv();

Step 4: Compile the Schema

Compile the JSON schema using the compile() method:

const validate = ajv.compile(schema);

Step 5: Validate the JSON Object

Validate a JSON object against the compiled schema:

const data = {
  "name": "John Doe",
  "age": 30
};

const valid = validate(data);
if (!valid) {
  console.log(validate.errors);
} else {
  console.log("Data is valid");
}

In this example, the validate() function returns a boolean indicating whether the JSON object is valid according to the schema. If the object is invalid, the errors property of the validate function contains an array of error messages.

Use Jackson to Validate JSON in Java

Jackson is a popular JSON processing library for Java. Here's an example of how to use Jackson to validate a JSON object:

Step 1: Add Jackson Dependencies

Add the following dependencies to your pom.xml file (if you're using Maven) or your build.gradle file (if you're using Gradle):

<!-- Maven -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.12.3</version>
</dependency>

<!-- Gradle -->
dependencies {
  implementation 'com.fasterxml.jackson.core:jackson-databind:2.12.3'
}

Step 2: Define the JSON Schema

Create a JSON schema that defines the structure of the JSON object you want to validate. For example:

import com.fasterxml.jackson.annotation.JsonProperty;

public class User {
  @JsonProperty("name")
  private String name;

  @JsonProperty("age")
  private int age;

  // Getters and setters
  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return age;
  }

  public void setAge(int age) {
    this.age = age;
  }
}

Step 3: Create an ObjectMapper

Create an instance of the ObjectMapper class:

import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper mapper = new ObjectMapper();

Step 4: Validate the JSON Object

Validate a JSON object against the schema using the readValue() method:

String json = "{\"name\":\"John Doe\",\"age\":30}";
try {
  User user = mapper.readValue(json, User.class);
  System.out.println("User is valid: " + user.getName() + ", " + user.getAge());
} catch (JsonParseException e) {
  System.out.println("Invalid JSON: " + e.getMessage());
} catch (JsonMappingException e) {
  System.out.println("Invalid JSON mapping: " + e.getMessage());
}

In this example, the readValue() method attempts to deserialize the JSON string into an instance of the User class. If the JSON is invalid, a JsonParseException or JsonMappingException is thrown.

Using JSON Schema Validation

Alternatively, you can use JSON schema validation to validate the JSON object against a predefined schema. First, add the following dependency:

<!-- Maven -->
<dependency>
  <groupId>com.github.fge</groupId>
  <artifactId>json-schema-core</artifactId>
  <version>1.2.5</version>
</dependency>

<!-- Gradle -->
dependencies {
  implementation 'com.github.fge:json-schema-core:1.2.5'
}

Then, define the JSON schema:

import com.github.fge.json-schema.core.report.ProcessingReport;
import com.github.fge.json-schema.main.JsonSchema;
import com.github.fge.json-schema.main.JsonSchemaFactory;

String schemaJson = "{\"type\":\"object\",\"properties\":{\"name\":{\"type\":\"string\"},\"age\":{\"type\":\"integer\"}},\"required\":[\"name\",\"age\"]}";
JsonSchema schema = JsonSchemaFactory.byDefault().getJsonSchema(schemaJson);

Finally, validate the JSON object against the schema:

ProcessingReport report = schema.validate(mapper.readTree(json));
if (!report.isSuccess()) {
  System.out.println("Invalid JSON: " + report.toString());
} else {
  System.out.println("JSON is valid");
}

In this example, the validate() method checks whether the JSON object conforms to the predefined schema. If the JSON is invalid, a ProcessingReport object is returned with error messages.

Using JSONSchema to Validate JSON in Python

JSONSchema is a popular library for validating JSON data in Python. Here's an example of how to use JSONSchema to validate a JSON object:

Step 1: Install JSONSchema

Install the jsonschema library using pip:

pip install jsonschema

Step 2: Define the JSON Schema

Create a JSON schema that defines the structure of the JSON object you want to validate. For example:

import json

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer"}
    },
    "required": ["name", "age"]
}

Step 3: Create a JSONSchema Validator

Create a JSONSchema validator instance:

from jsonschema import validate

validator = validate(instance=json_data, schema=schema)

Step 4: Validate the JSON Object

Validate a JSON object against the schema:

json_data = {
    "name": "John Doe",
    "age": 30
}

try:
    validate(instance=json_data, schema=schema)
    print("JSON is valid")
except jsonschema.exceptions.ValidationError as err:
    print("Invalid JSON: {}".format(err))

In this example, the validate() function attempts to validate the JSON object against the schema. If the JSON is invalid, a ValidationError exception is raised.

Using a Validator with a Custom Schema

You can also create a custom validator with a predefined schema:

from jsonschema import Draft7Validator

class UserValidator(Draft7Validator):
    def __init__(self, schema):
        super().__init__(schema)

    def validate(self, instance):
        super().validate(instance)
        # Additional validation logic can be added here

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer"}
    },
    "required": ["name", "age"]
}

validator = UserValidator(schema)

json_data = {
    "name": "John Doe",
    "age": 30
}

try:
    validator.validate(json_data)
    print("JSON is valid")
except jsonschema.exceptions.ValidationError as err:
    print("Invalid JSON: {}".format(err))

In this example, the UserValidator class extends the Draft7Validator class and adds custom validation logic.

Example Use Case

Suppose you have a REST API that accepts JSON data in the request body. You can use JSONSchema to validate the incoming data against a predefined schema:

from flask import Flask, request, jsonify
from jsonschema import validate

app = Flask(__name__)

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer"}
    },
    "required": ["name", "age"]
}

@app.route('/api/data', methods=['POST'])
def validate_data():
    json_data = request.get_json()
    try:
        validate(instance=json_data, schema=schema)
        return jsonify({"message": "JSON is valid"}), 200
    except jsonschema.exceptions.ValidationError as err:
        return jsonify({"message": "Invalid JSON: {}".format(err)}), 400

if __name__ == '__main__':
    app.run(debug=True)

In this example, the validate_data() function validates the incoming JSON data against the predefined schema. If the JSON is invalid, a 400 error response is returned with an error message. If the JSON is valid, a 200 success response is returned.

viewjson

Validate JSON

Use AJV library To Validate JSON in JavaScript

Use Jackson to Validate JSON in Java

Using JSONSchema to Validate JSON in Python

Example Use Case