JSON Schema Validation

JSON Schema Validation ব্যবহার করে আমরা JSON ডেটার কাঠামো এবং মান যাচাই করতে পারি। এটি REST API-এর ইনপুট এবং আউটপুট ভ্যালিডেশন নিশ্চিত করার জন্য একটি গুরুত্বপূর্ণ পদ্ধতি। Jackson-এর সাথে JSON Schema ব্যবহার করে আমরা JSON ডেটা স্বয়ংক্রিয়ভাবে স্কিমা অনুযায়ী যাচাই করতে পারি।

JSON Schema Validation এর মূল ধারণা

• JSON Schema: JSON ডেটার কাঠামো (structure) এবং ভ্যালিডেশন নিয়ম নির্ধারণ করে।
• Validation: JSON ডেটা স্কিমার বিরুদ্ধে যাচাই করা হয়।

Jackson ব্যবহার করে JSON Schema তৈরি করা

Maven ডিপেন্ডেন্সি

<dependencies>
    <!-- Jackson -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.15.2</version>
    </dependency>

    <!-- Jackson Module for JSON Schema -->
    <dependency>
        <groupId>com.github.victools</groupId>
        <artifactId>jsonschema-generator</artifactId>
        <version>4.28.0</version>
    </dependency>
</dependencies>

Step 1: JSON Schema তৈরি

উদাহরণ:

import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.victools.jsonschema.generator.*;

public class GenerateJsonSchemaExample {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();

        // JSON Schema Generator সেটআপ
        SchemaGeneratorConfig config = new SchemaGeneratorConfigBuilder(
                objectMapper,
                SchemaVersion.DRAFT_7,
                OptionPreset.PLAIN_JSON)
                .build();
        SchemaGenerator generator = new SchemaGenerator(config);

        // JSON Schema তৈরি
        JsonNode jsonSchema = generator.generateSchema(User.class);

        // Schema প্রিন্ট করা
        System.out.println(objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(jsonSchema));
    }
}

// User ক্লাস
class User {
    public int id;
    public String name;
    public String email;
}

আউটপুট:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "id": {
      "type": "integer"
    },
    "name": {
      "type": "string"
    },
    "email": {
      "type": "string"
    }
  },
  "required": ["id", "name", "email"]
}

Step 2: JSON Schema অনুযায়ী Validation

Jackson সরাসরি JSON Schema ভ্যালিডেশনের জন্য বিল্ট-ইন সাপোর্ট প্রদান করে না, তবে এটি NetworkNT JSON Schema Validator-এর মাধ্যমে সহজে ইন্টিগ্রেট করা যায়।

Maven ডিপেন্ডেন্সি:

<dependency>
    <groupId>com.github.java-json-tools</groupId>
    <artifactId>json-schema-validator</artifactId>
    <version>2.2.14</version>
</dependency>

উদাহরণ:

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.fge.jsonschema.core.report.ProcessingReport;
import com.github.fge.jsonschema.core.report.ReportProvider;
import com.github.fge.jsonschema.core.report.StdoutReportProvider;
import com.github.fge.jsonschema.core.report.Verbosity;
import com.github.fge.jsonschema.core.util.JsonLoader;
import com.github.fge.jsonschema.main.JsonSchemaFactory;
import com.github.fge.jsonschema.main.JsonValidator;

public class JsonSchemaValidationExample {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();

        // JSON Schema
        String schema = "{"
                + " \"$schema\": \"http://json-schema.org/draft-07/schema#\","
                + " \"type\": \"object\","
                + " \"properties\": {"
                + "     \"id\": {\"type\": \"integer\"},"
                + "     \"name\": {\"type\": \"string\"},"
                + "     \"email\": {\"type\": \"string\"}"
                + " },"
                + " \"required\": [\"id\", \"name\", \"email\"]"
                + "}";

        // JSON ডেটা
        String json = "{ \"id\": 1, \"name\": \"John Doe\", \"email\": \"john@example.com\" }";

        // JSON Schema Validator
        JsonNode schemaNode = JsonLoader.fromString(schema);
        JsonNode jsonNode = JsonLoader.fromString(json);

        JsonValidator validator = JsonSchemaFactory.byDefault().getValidator();
        ProcessingReport report = validator.validate(schemaNode, jsonNode);

        // Validation ফলাফল প্রিন্ট করা
        if (report.isSuccess()) {
            System.out.println("JSON is valid.");
        } else {
            System.out.println("JSON is invalid.");
            System.out.println(report);
        }
    }
}

আউটপুট (Valid JSON):

JSON is valid.

আউটপুট (Invalid JSON):

JSON is invalid.
error: instance failed to match required schema
  level: "error"
  schema: {...}
  instance: {...}
  domain: "validation"
  keyword: "required"
  required: ["id", "name", "email"]
  missing: ["name"]

Step 3: Spring Boot এর সাথে Integration

Spring Boot-এ Jackson এবং JSON Schema Validation সহজে REST API-তে ইন্টিগ্রেট করা যায়।

Controller উদাহরণ:

import com.fasterxml.jackson.databind.JsonNode;
import com.github.fge.jsonschema.main.JsonSchema;
import com.github.fge.jsonschema.main.JsonSchemaFactory;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/validate")
public class SchemaValidationController {

    private static final String SCHEMA = "{"
            + " \"$schema\": \"http://json-schema.org/draft-07/schema#\","
            + " \"type\": \"object\","
            + " \"properties\": {"
            + "     \"id\": {\"type\": \"integer\"},"
            + "     \"name\": {\"type\": \"string\"},"
            + "     \"email\": {\"type\": \"string\"}"
            + " },"
            + " \"required\": [\"id\", \"name\", \"email\"]"
            + "}";

    @PostMapping
    public ResponseEntity<String> validateJson(@RequestBody JsonNode json) throws Exception {
        JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
        JsonSchema schema = factory.getJsonSchema(SCHEMA);

        if (schema.validate(json).isSuccess()) {
            return ResponseEntity.ok("JSON is valid");
        } else {
            return ResponseEntity.badRequest().body("JSON is invalid");
        }
    }
}

1. Jackson এবং JSON Schema Integration JSON ডেটা ভ্যালিডেশনের জন্য অত্যন্ত কার্যকর।
2. NetworkNT JSON Schema Validator ব্যবহার করে JSON ডেটা স্কিমার বিরুদ্ধে যাচাই করা যায়।
3. REST API-তে ইনপুট ভ্যালিডেশনের জন্য Spring Boot-এ সহজেই এটি ইন্টিগ্রেট করা সম্ভব।
4. JSON ডেটার কাঠামো এবং বৈধতা নিশ্চিত করার জন্য এই পদ্ধতি খুবই কার্যকর।

JSON Schema Validation কি?

JSON Schema Validation হলো JSON ডেটার কাঠামো এবং কনটেন্ট যাচাই করার একটি প্রক্রিয়া। এটি JSON Schema ব্যবহার করে করা হয়, যা JSON ডেটার কাঠামো, ডেটাটাইপ, এবং কনস্ট্রেইন্ট নির্ধারণ করে।

JSON Schema হলো একটি স্ট্যান্ডার্ডাইজড ফরম্যাট যা JSON ডেটার জন্য:

• কাঠামো (structure),
• ডেটাটাইপ (data types),
• এবং বৈধতা (validity) যাচাই করে।

JSON Schema Validation কেন প্রয়োজন?

1. ডেটা ইন্টিগ্রিটি নিশ্চিত করা: ইনপুট বা আউটপুট JSON ডেটা সঠিক কাঠামো এবং মান মেনে চলছে কিনা তা যাচাই করে।
2. ব্যবহারকারীর ভুল রোধ করা: ডেভেলপার এবং ব্যবহারকারীর কাছ থেকে আসা ভুল ডেটা সরাসরি চেক করা যায়।
3. API ডকুমেন্টেশন: JSON Schema ব্যবহার করে API এর কাঠামো এবং বৈধতার একটি পরিষ্কার ডকুমেন্ট তৈরি করা যায়।
4. ডায়নামিক ডেটা যাচাই: JSON ডেটা প্রসেস করার আগে তার কাঠামো এবং ডেটা টাইপ যাচাই করে কোডের বাগ বা ভুল এড়ানো যায়।
5. অ্যাপ্লিকেশন সুরক্ষা: নিরাপদ ডেটা ট্রান্সমিশন নিশ্চিত করে।

JSON Schema এর মূল কাঠামো

JSON Schema একটি JSON অবজেক্ট যা ডেটার কনস্ট্রেইন্ট এবং কাঠামো বর্ণনা করে। উদাহরণস্বরূপ:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 3
    },
    "age": {
      "type": "integer",
      "minimum": 18
    },
    "email": {
      "type": "string",
      "format": "email"
    }
  },
  "required": ["name", "age"]
}

Jackson এবং JSON Schema Validation এর Integration

Jackson লাইব্রেরি এবং JSON Schema ব্যবহার করে JSON ডেটা যাচাই করা সম্ভব। সাধারণত networknt JSON Schema Validator ব্যবহার করা হয়।

Maven ডিপেন্ডেন্সি

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

JSON Schema Validation এর উদাহরণ

১. JSON Schema এবং JSON ডেটা প্রস্তুত করুন

JSON Schema:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 3
    },
    "age": {
      "type": "integer",
      "minimum": 18
    },
    "email": {
      "type": "string",
      "format": "email"
    }
  },
  "required": ["name", "age"]
}

JSON ডেটা:

{
  "name": "Jo",
  "age": 15,
  "email": "invalid-email"
}

২. কোড উদাহরণ

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;

import java.io.File;
import java.util.Set;

public class JsonSchemaValidationExample {
    public static void main(String[] args) throws Exception {
        // JSON Schema এবং JSON ডেটা লোড করা
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode schemaNode = objectMapper.readTree(new File("schema.json"));
        JsonNode jsonData = objectMapper.readTree(new File("data.json"));

        // JSON Schema তৈরি
        JsonSchemaFactory schemaFactory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7);
        JsonSchema schema = schemaFactory.getSchema(schemaNode);

        // Validation
        Set<ValidationMessage> validationMessages = schema.validate(jsonData);

        if (validationMessages.isEmpty()) {
            System.out.println("JSON is valid!");
        } else {
            System.out.println("JSON validation errors:");
            for (ValidationMessage message : validationMessages) {
                System.out.println(message.getMessage());
            }
        }
    }
}

৩. আউটপুট

JSON validation errors:
$.name: must be at least 3 characters long
$.age: must be greater than or equal to 18
$.email: must be a valid email address

JSON Schema Validation এর মূল বৈশিষ্ট্য

1. ডেটা টাইপ যাচাই: string, integer, boolean ইত্যাদি।
2. নির্ধারিত ফিল্ড বাধ্যতামূলক করা: required প্রপার্টি ব্যবহার করে।
3. মিনিমাম এবং ম্যাক্সিমাম ভ্যালু: minLength, maxLength, minimum, maximum।
4. প্যাটার্ন মিলানো: pattern ব্যবহার করে রেগুলার এক্সপ্রেশন যাচাই।
5. ইমেইল এবং URL যাচাই: format ব্যবহার করে।
6. এনেস্টেড অবজেক্ট এবং অ্যারে যাচাই: properties এবং items ব্যবহার করে।

JSON Schema Validation এর উপকারিতা

1. API সঠিকতা নিশ্চিত করা: RESTful API ডেটা যাচাইয়ের জন্য খুব কার্যকর।
2. ডেভেলপার এবং ক্লায়েন্টদের মধ্যে সিঙ্ক্রোনাইজেশন: ডকুমেন্টেশন এবং ডেটা কাঠামোর মধ্যে মিল রাখে।
3. ডায়নামিক ডেটা যাচাই: ডেটা প্রসেসিংয়ের পূর্বে অটোমেটিক ভ্যালিডেশন।
4. কোডের জটিলতা হ্রাস: ভ্যালিডেশন লজিক JSON Schema-তে সংজ্ঞায়িত করার মাধ্যমে।
5. ইন্টারঅপারেবিলিটি: JSON Schema একটি স্ট্যান্ডার্ড হওয়ায় এটি বিভিন্ন প্ল্যাটফর্মে ব্যবহার করা যায়।

JSON Schema Validation একটি স্ট্যান্ডার্ড পদ্ধতি যা JSON ডেটার কাঠামো এবং কনটেন্ট যাচাই করতে ব্যবহৃত হয়। Jackson এবং JSON Schema Validator লাইব্রেরি ব্যবহার করে এটি Java অ্যাপ্লিকেশনে সহজেই ইন্টিগ্রেট করা যায়। এটি API ডেভেলপমেন্টে ডেটা ইন্টিগ্রিটি এবং সিকিউরিটি নিশ্চিত করার একটি অত্যন্ত কার্যকর পদ্ধতি।

Jackson লাইব্রেরি JSON ডেটার সাথে কাজ করার জন্য অসাধারণ একটি টুল। JSON Schema Validation একটি গুরুত্বপূর্ণ ফিচার, যা নিশ্চিত করে যে JSON ডেটা নির্দিষ্ট একটি স্কিমার (structure, type, constraints) সাথে সামঞ্জস্যপূর্ণ।

Jackson ব্যবহার করে JSON Schema Validation করতে json-schema-validator মডিউল ব্যবহৃত হয়। এটি Jackson এবং JSON Schema Draft-4/7/2020 সমর্থন করে।

JSON Schema Validation সেটআপ

প্রয়োজনীয় Maven ডিপেনডেন্সি:

<dependency>
    <groupId>com.github.java-json-tools</groupId>
    <artifactId>json-schema-validator</artifactId>
    <version>2.2.14</version> <!-- সর্বশেষ ভার্সন -->
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version> <!-- Jackson এর জন্য -->
</dependency>

Step-by-Step JSON Schema Validation উদাহরণ

১. JSON Schema তৈরি করা

JSON Schema একটি স্ট্যান্ডার্ড ফরম্যাট যা ডেটার কাঠামো এবং কন্ট্রেইন্ট নির্ধারণ করে।

Example Schema (user-schema.json):

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "User",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1
    },
    "age": {
      "type": "integer",
      "minimum": 0
    },
    "email": {
      "type": "string",
      "format": "email"
    }
  },
  "required": ["name", "age"]
}

২. JSON ডেটা প্রস্তুত করা

{
  "name": "Alice",
  "age": 25,
  "email": "alice@example.com"
}

৩. Jackson এবং json-schema-validator ব্যবহার করে Validation

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

import java.io.File;
import java.io.IOException;

public class JsonSchemaValidationExample {
    public static void main(String[] args) {
        try {
            // ObjectMapper তৈরি
            ObjectMapper mapper = new ObjectMapper();

            // JSON Schema এবং JSON ডেটা লোড করা
            JsonNode schemaNode = mapper.readTree(new File("user-schema.json"));
            JsonNode dataNode = mapper.readTree(new File("user-data.json"));

            // JSON SchemaFactory তৈরি
            JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
            JsonSchema schema = factory.getJsonSchema(schemaNode);

            // Validation প্রক্রিয়া
            ProcessingReport report = schema.validate(dataNode);

            // Validation রিপোর্ট প্রিন্ট করা
            if (report.isSuccess()) {
                System.out.println("JSON is valid.");
            } else {
                System.out.println("JSON is invalid.");
                System.out.println(report);
            }
        } catch (IOException | ProcessingException e) {
            e.printStackTrace();
        }
    }
}

আউটপুট

Valid JSON:

JSON is valid.

Invalid JSON:

Input JSON:

{
  "name": "",
  "age": -5
}

Output:

JSON is invalid.
--- BEGIN MESSAGES ---
error: string [\"\"] is too short
    level: "error"
    schema: {...}
    instance: {...}

error: number [-5] is less than the minimum of 0
    level: "error"
    schema: {...}
    instance: {...}
--- END MESSAGES ---

৪. Runtime Schema Validation

JSON Schema ফাইল ছাড়াই প্রোগ্রামটিকভাবে স্কিমা তৈরি করা সম্ভব।

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

public class RuntimeSchemaValidationExample {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();

        // JSON Schema প্রোগ্রামটিকভাবে তৈরি
        String schemaString = """
                {
                  "$schema": "http://json-schema.org/draft-07/schema#",
                  "type": "object",
                  "properties": {
                    "name": {"type": "string", "minLength": 1},
                    "age": {"type": "integer", "minimum": 0}
                  },
                  "required": ["name", "age"]
                }
                """;
        JsonNode schemaNode = mapper.readTree(schemaString);

        // JSON ডেটা
        String jsonString = """
                {
                  "name": "Alice",
                  "age": 25
                }
                """;
        JsonNode dataNode = mapper.readTree(jsonString);

        // JSON Schema Validation
        JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
        JsonSchema schema = factory.getJsonSchema(schemaNode);

        ProcessingReport report = schema.validate(dataNode);

        if (report.isSuccess()) {
            System.out.println("JSON is valid.");
        } else {
            System.out.println("JSON is invalid.");
            System.out.println(report);
        }
    }
}

৫. Spring Boot এ JSON Schema Validation

Spring Boot এর REST API তে JSON Schema Validation সহজে সংযুক্ত করা যায়।

Controller:

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

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

import java.io.IOException;

@RestController
@RequestMapping("/api/validate")
public class SchemaValidationController {

    @PostMapping
    public ResponseEntity<String> validateJson(@RequestBody String jsonData) {
        try {
            ObjectMapper mapper = new ObjectMapper();

            // JSON Schema লোড করা
            JsonNode schemaNode = mapper.readTree(new File("user-schema.json"));

            // JSON Data লোড করা
            JsonNode dataNode = mapper.readTree(jsonData);

            // Validation
            JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
            JsonSchema schema = factory.getJsonSchema(schemaNode);

            ProcessingReport report = schema.validate(dataNode);

            if (report.isSuccess()) {
                return ResponseEntity.ok("JSON is valid.");
            } else {
                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Invalid JSON:\n" + report.toString());
            }
        } catch (IOException | com.github.fge.jsonschema.core.exceptions.ProcessingException e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Error: " + e.getMessage());
        }
    }
}

API Call:

• Request (Valid):

{
  "name": "Bob",
  "age": 30
}

• Response:

"JSON is valid."

• Request (Invalid):

{
  "name": "",
  "age": -1
}

• Response:

"Invalid JSON:
error: string [\"\"] is too short
error: number [-1] is less than the minimum of 0"

• Jackson এর মাধ্যমে JSON Schema Validation করা সম্ভব json-schema-validator লাইব্রেরি ব্যবহার করে।
• এটি API ডেভেলপমেন্টে JSON ডেটার গুণমান নিশ্চিত করার একটি অত্যন্ত কার্যকর পদ্ধতি।
• Spring Boot এর সাথে সহজেই ইন্টিগ্রেট করে REST API তে স্কিমা ভিত্তিক ভ্যালিডেশন প্রয়োগ করা যায়।

Jackson লাইব্রেরি ব্যবহার করে JSON ডেটার জন্য Schema Generation এবং Data Validation কার্যকরভাবে পরিচালনা করা সম্ভব। Schema Generation সাধারণত JSON ডেটার কাঠামো বর্ণনা করার জন্য ব্যবহৃত হয়, যা API ডেভেলপমেন্ট এবং ডেটা ইন্টিগ্রেশনে সাহায্য করে। Schema অনুযায়ী ডেটা ভ্যালিডেশন নিশ্চিত করে যে ডেটা কাঠামো সঠিক এবং প্রত্যাশিত মানদণ্ড পূরণ করে।

1. Schema Generation

Jackson-এর jackson-module-jsonSchema ব্যবহার করে JSON Schema তৈরি করা যায়। এই Schema ডেটার কাঠামো এবং বিধিনিষেধ বর্ণনা করতে ব্যবহৃত হয়।

ডিপেন্ডেন্সি:

<dependency>
    <groupId>com.fasterxml.jackson.module</groupId>
    <artifactId>jackson-module-jsonSchema</artifactId>
    <version>2.15.2</version>
</dependency>

মডেল ক্লাস:

import com.fasterxml.jackson.annotation.JsonProperty;

public class User {
    @JsonProperty("id")
    public int id;

    @JsonProperty("name")
    public String name;

    @JsonProperty("email")
    public String email;

    @JsonProperty("age")
    public int age;
}

Schema Generation Example:

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.module.jsonSchema.JsonSchema;
import com.fasterxml.jackson.module.jsonSchema.factories.SchemaFactoryWrapper;

public class Main {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();

        // Schema Factory Wrapper
        SchemaFactoryWrapper schemaFactoryWrapper = new SchemaFactoryWrapper();
        objectMapper.acceptJsonFormatVisitor(User.class, schemaFactoryWrapper);
        JsonSchema schema = schemaFactoryWrapper.finalSchema();

        // Print JSON Schema
        String schemaJson = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(schema);
        System.out.println("Generated Schema:");
        System.out.println(schemaJson);
    }
}

আউটপুট:

{
  "type": "object",
  "id": "urn:jsonschema:User",
  "properties": {
    "id": {
      "type": "integer"
    },
    "name": {
      "type": "string"
    },
    "email": {
      "type": "string"
    },
    "age": {
      "type": "integer"
    }
  }
}

2. Data Validation

Jackson-এ JSON Schema Validation সাধারণত JSON ডেটা Schema অনুযায়ী যাচাই করতে ব্যবহৃত হয়।

Validation Library ডিপেন্ডেন্সি:

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

Validation Example:

Schema Definition:

{
  "type": "object",
  "properties": {
    "id": {
      "type": "integer"
    },
    "name": {
      "type": "string"
    },
    "email": {
      "type": "string",
      "format": "email"
    },
    "age": {
      "type": "integer",
      "minimum": 18
    }
  },
  "required": ["id", "name", "email", "age"]
}

Java কোড:

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

import java.util.Set;

public class Main {
    public static void main(String[] args) throws Exception {
        // JSON Schema
        String schemaJson = """
        {
          "type": "object",
          "properties": {
            "id": {
              "type": "integer"
            },
            "name": {
              "type": "string"
            },
            "email": {
              "type": "string",
              "format": "email"
            },
            "age": {
              "type": "integer",
              "minimum": 18
            }
          },
          "required": ["id", "name", "email", "age"]
        }
        """;

        // Input JSON
        String inputJson = """
        {
          "id": 101,
          "name": "John Doe",
          "email": "john.doe@example",
          "age": 16
        }
        """;

        ObjectMapper objectMapper = new ObjectMapper();

        // Load Schema
        JsonSchemaFactory factory = JsonSchemaFactory.getInstance();
        JsonSchema schema = factory.getSchema(schemaJson);

        // Validate JSON
        Set<ValidationMessage> errors = schema.validate(objectMapper.readTree(inputJson));

        // Print Validation Errors
        if (!errors.isEmpty()) {
            System.out.println("Validation Errors:");
            errors.forEach(error -> System.out.println(error.getMessage()));
        } else {
            System.out.println("JSON is valid!");
        }
    }
}

আউটপুট:

Validation Errors:
$.email: string "john.doe@example" is not a valid email
$.age: integer value 16 is less than minimum 18

3. Combining Schema Generation and Validation

একটি সিস্টেমে একই মডেল ব্যবহার করে Schema Generation এবং JSON Validation একত্রে করতে পারেন।

ধাপসমূহ:

1. Schema Generate করুন।
2. JSON ডেটা ভ্যালিডেট করুন Schema অনুযায়ী।

Key Features:

1. Schema Generation:
   • JSON Schema ডেভেলপমেন্ট সহজ এবং দ্রুত।
   • ডেটা ফরম্যাট বা কাঠামো ডকুমেন্ট করার জন্য আদর্শ।
2. Data Validation:
   • JSON ডেটার সঠিকতা এবং সম্পূর্ণতা যাচাই।
   • ভ্যালিডেশন ভুল হলে সুনির্দিষ্ট ত্রুটি বার্তা প্রদান।
3. Spring Boot Integration:
   • Spring Boot অ্যাপ্লিকেশনে Schema Generation এবং Validation সহজেই সংযুক্ত করা যায়।

ব্যবহারিক ক্ষেত্র:

1. API Development:
   • API রিকোয়েস্ট বা রেসপন্স যাচাই।
   • ডেটা কনফিগারেশন ডায়নামিকভাবে যাচাই।
2. Data Migration:
   • বিভিন্ন সিস্টেমে ডেটার সামঞ্জস্য নিশ্চিত।
3. Integration with Frontend:
   • Frontend এবং Backend-এর মধ্যে ডেটা ফরম্যাটের সামঞ্জস্য বজায় রাখা।

উপকারিতা:

• উন্নত ভ্যালিডেশন মেকানিজম।
• JSON Schema ব্যবহার করে ডেটার কাঠামো বর্ণনা।
• ডেটা ইন্টিগ্রেশন এবং API ডেভেলপমেন্টে সময় সাশ্রয়।

এই পদ্ধতিগুলো ব্যবহার করে আপনি সহজেই Jackson-এর সাহায্যে JSON Schema Generation এবং Data Validation পরিচালনা করতে পারবেন।

JSON ডেটার Integrity এবং Consistency নিশ্চিত করা মানে হল ডেটা সঠিক, নির্ভরযোগ্য, এবং পূর্বনির্ধারিত কাঠামো বা নিয়ম অনুসারে বৈধ কিনা তা যাচাই করা। Jackson লাইব্রেরি JSON serialization এবং deserialization-এ গুরুত্বপূর্ণ ভূমিকা পালন করে এবং ডেটার মান যাচাই করার বিভিন্ন উপায় সরবরাহ করে।

JSON Data-এর Integrity এবং Consistency নিশ্চিত করার উদ্দেশ্য

1. ডেটা ভ্যালিডেশন: নিশ্চিত করা যে JSON ডেটার কাঠামো এবং মান সঠিক।
2. ডেটা নিরাপত্তা: JSON ডেটার মাধ্যমে অনাকাঙ্ক্ষিত পরিবর্তন বা ত্রুটি প্রতিরোধ।
3. Error Handling: ডেটার ত্রুটি সনাক্ত এবং যথাযথ ত্রুটি বার্তা প্রদান।
4. API Integration: ভিন্ন সিস্টেম থেকে প্রাপ্ত ডেটার বৈধতা পরীক্ষা।

Jackson ব্যবহার করে JSON Data Integrity এবং Consistency নিশ্চিত করার পদ্ধতি

1. Java Bean Validation (JSR 380)

Java Bean Validation annotations (@NotNull, @Size, @Pattern, ইত্যাদি) ব্যবহার করে ডেটা ভ্যালিডেশন করা সম্ভব।

উদাহরণ:

import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.constraints.Size;

public class User {
    @NotNull(message = "Name cannot be null")
    @Size(min = 2, max = 50, message = "Name must be between 2 and 50 characters")
    private String name;

    @NotNull(message = "Email cannot be null")
    @Pattern(regexp = ".+@.+\\..+", message = "Invalid email format")
    private String email;

    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

Validation Integration:

import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;

public class DataIntegrityExample {
    public static void main(String[] args) {
        try {
            String json = """
                          {
                              "name": "John",
                              "email": "invalid-email"
                          }
                          """;

            ObjectMapper mapper = new ObjectMapper();
            User user = mapper.readValue(json, User.class);

            // Validator তৈরি
            ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
            Validator validator = factory.getValidator();

            var violations = validator.validate(user);
            if (!violations.isEmpty()) {
                violations.forEach(violation -> System.out.println(violation.getMessage()));
            } else {
                System.out.println("Valid User: " + user.getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

আউটপুট:

Invalid email format

2. Custom Deserialization দিয়ে Integrity নিশ্চিত করা

কাস্টম deserializer ব্যবহার করে JSON ডেটার integrity যাচাই করা যায়।

উদাহরণ:

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;

import java.io.IOException;

class Product {
    private String name;

    @JsonDeserialize(using = PriceDeserializer.class)
    private double price;

    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
}

class PriceDeserializer extends JsonDeserializer<Double> {
    @Override
    public Double deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        double price = p.getDoubleValue();
        if (price < 0) {
            throw new IOException("Price cannot be negative: " + price);
        }
        return price;
    }
}

ব্যবহার:

public class CustomDeserializerExample {
    public static void main(String[] args) {
        try {
            String json = """
                          {
                              "name": "Smartphone",
                              "price": -100.50
                          }
                          """;

            ObjectMapper mapper = new ObjectMapper();
            Product product = mapper.readValue(json, Product.class);

            System.out.println("Product: " + product.getName() + ", Price: " + product.getPrice());
        } catch (Exception e) {
            System.err.println("Validation Error: " + e.getMessage());
        }
    }
}

আউটপুট:

Validation Error: Price cannot be negative: -100.5

3. Schema Validation

JSON Schema ব্যবহার করে ডেটার কাঠামো এবং মান যাচাই করা যায়।

Dependency (NetworkNT JSON Schema Validator):

<dependency>
    <groupId>com.github.java-json-tools</groupId>
    <artifactId>json-schema-validator</artifactId>
    <version>2.2.14</version>
</dependency>

উদাহরণ:

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

public class SchemaValidationExample {
    public static void main(String[] args) {
        try {
            String schemaJson = """
                                 {
                                     "$schema": "http://json-schema.org/draft-07/schema#",
                                     "type": "object",
                                     "properties": {
                                         "name": {
                                             "type": "string"
                                         },
                                         "age": {
                                             "type": "integer",
                                             "minimum": 18
                                         }
                                     },
                                     "required": ["name", "age"]
                                 }
                                 """;

            String jsonData = """
                              {
                                  "name": "John",
                                  "age": 17
                              }
                              """;

            ObjectMapper mapper = new ObjectMapper();
            JsonNode schemaNode = mapper.readTree(schemaJson);
            JsonNode dataNode = mapper.readTree(jsonData);

            JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
            JsonSchema schema = factory.getJsonSchema(schemaNode);

            ProcessingReport report = schema.validate(dataNode);

            if (report.isSuccess()) {
                System.out.println("JSON Data is valid.");
            } else {
                System.out.println("Validation Errors:");
                System.out.println(report);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

আউটপুট:

Validation Errors:
error: instance failed to match at least one required condition
    required property "age" is missing

4. Nested Validation

Nested JSON ডেটার consistency নিশ্চিত করতে @Valid annotations ব্যবহার করা যায়।

উদাহরণ:

import jakarta.validation.Valid;
import jakarta.validation.constraints.NotNull;

public class Order {
    @NotNull
    private String orderId;

    @Valid
    @NotNull
    private Product product;

    // Getters and Setters
    public String getOrderId() { return orderId; }
    public void setOrderId(String orderId) { this.orderId = orderId; }

    public Product getProduct() { return product; }
    public void setProduct(Product product) { this.product = product; }
}

Jackson এবং Java Bean Validation ব্যবহার করে JSON Data-এর Integrity এবং Consistency নিশ্চিত করার জন্য:

1. Basic Validation: @NotNull, @Size, @Pattern annotations ব্যবহার করুন।
2. Custom Rules: Custom deserializer দিয়ে validation করুন।
3. Schema Validation: JSON Schema-এর মাধ্যমে কাঠামো যাচাই করুন।
4. Nested Data: Nested objects-এর জন্য @Valid annotations প্রয়োগ করুন।

এই কৌশলগুলো ব্যবহার করে আপনি JSON ডেটার সঠিকতা এবং নির্ভরযোগ্যতা নিশ্চিত করতে পারবেন।