Java වල JSON: දත්ත හුවමාරුවේ හදවතට පිවිසෙමු!

කොහොමද යාලුවනේ! අද අපි කතා කරමු software engineering වලදි නැතුවම බැරි, ගොඩක්ම වැදගත් topic එකක් ගැන. ඒ තමයි JSON (JavaScript Object Notation). මේක ඇහුවම සමහරවිට ඔයාට හිතෙන්න පුළුවන් "අප්පෝ! තව අලුත් දෙයක්ද?" කියලා. ඒත් කලබල වෙන්න එපා! JSON කියන්නේ හිතන තරම් සංකීර්ණ දෙයක් නෙමෙයි. ඇත්තටම, මේක data communicate කරන්න තියෙන හරිම සරල, පහසු විදිහක්.

අද කාලේ web applications, APIs (Application Programming Interfaces) හැම තැනකම වගේ data send කරන්නයි receive කරන්නයි පාවිච්චි කරන්නේ JSON තමයි. ඉතින් ඔයා Java developer කෙනෙක් නම්, JSON එක්ක වැඩ කරන එක අනිවාර්යයෙන්ම දැනගෙන ඉන්න ඕන skill එකක්. ඒ නිසා, අද මේ blog post එකෙන් අපි JSON කියන්නේ මොකක්ද, Java වලදි ඒක කොහොමද පාවිච්චි කරන්නේ, ජනප්‍රියම libraries මොනවද, ඒවගේම practical examples කිහිපයකුත් බලමු. සූදානම්ද? එහෙනම් පටන් ගමු!

JSON කියන්නේ මොකක්ද? (What is JSON?)

නමෙන් කියවෙන විදිහටම, JSON කියන්නේ JavaScript Object Notation. ඒත් JavaScript එක්කම විතරක් නෙමෙයි මේක වැඩ කරන්නේ. Java, Python, C#, PHP වගේ ඕනම programming language එකකට මේක use කරන්න පුළුවන්. JSON කියන්නේ human-readable data format එකක්. ඒ කියන්නේ අපිට පහසුවෙන් තේරුම් ගන්න පුළුවන් විදිහට data organize කරන්න පුළුවන්.

JSON වල මූලික ලක්ෂණ:

• Lightweight: මේක XML වලට වඩා ගොඩක් light. ඒ නිසා network එකේ data send කරද්දී bandwidth එක අඩුයි, speed එක වැඩියි.
• Human-Readable: JSON format එක හරිම simple. Key-value pairs විදිහට data තියෙන නිසා, අපිට බලපු ගමන් තේරුම් ගන්න පුළුවන්.
• Language Independent: ඕනෑම programming language එකකට මේක use කරන්න පුළුවන්.

JSON වල Structure එක

JSON වල ප්‍රධාන කොටස් දෙකක් තියෙනවා:

Arrays (ආරේ): මේක square brackets [] ඇතුලේ තියෙනවා. මේක list එකක් වගේ. Values වෙන් කරන්නේ comma (,) එකකින්.

[
  "Apple",
  "Banana",
  "Orange"
]

Objects (වස්තු): මේක curly braces {} ඇතුලේ තියෙනවා. Key-value pairs වලින් හැදිලා තියෙන්නේ. Key එක String එකක් වෙන්න ඕන, Value එක ඕනෑම JSON data type එකක් වෙන්න පුළුවන්. Key එකයි Value එකයි වෙන් කරන්නේ colon (:) එකකින්. Key-value pairs වෙන් කරන්නේ comma (,) එකකින්.

{
  "name": "සුමනපාල",
  "age": 30,
  "isStudent": false
}

JSON Data Types

JSON වලට පාවිච්චි කරන්න පුළුවන් data types කිහිපයක් තියෙනවා:

• String: double quotes "" ඇතුලේ තියෙන text. උදා: "නම"
• Number: integer හෝ floating-point numbers. උදා: 25, 10.5
• Boolean: true හෝ false.
• Array: square brackets [] ඇතුලේ තියෙන values list එකක්.
• Object: curly braces {} ඇතුලේ තියෙන key-value pairs set එකක්.
• null: හිස් අගයක්.

මේ හැම data type එකක්ම එකට එකතු කරලා සංකීර්ණ data structures හදන්න පුළුවන්. පහත තියෙන JSON snippet එක බලන්න. මේකෙන් Student කෙනෙක්ගේ විස්තර representation කරන හැටි පෙන්වනවා:

{
  "studentId": "STU001",
  "name": {
    "firstName": "කමල්",
    "lastName": "පෙරේරා"
  },
  "age": 22,
  "isEnrolled": true,
  "courses": [
    {
      "courseName": "Software Engineering",
      "credits": 3
    },
    {
      "courseName": "Data Structures",
      "credits": 4
    }
  ],
  "email": "[email protected]",
  "gpa": 3.8,
  "address": null
}

දැන් ඔයාට JSON කියන්නේ මොකක්ද කියන එක ගැන හොඳ අවබෝධයක් ඇති කියලා හිතනවා. දැන් බලමු මේක Java එක්ක පාවිච්චි කරන්නේ කොහොමද කියලා.

Java වලට JSON කොහොමද? (How JSON in Java?)

අනිත් languages (JavaScript, Python වගේ) වගේ නෙමෙයි, Java වලට JSON support එකක් built-in නැහැ. ඒ කියන්නේ, අපිට Java object එකක් JSON String එකකට convert කරන්න (මේකට කියන්නේ Serialization කියලා) හෝ JSON String එකක් Java object එකකට convert කරන්න (මේකට කියන්නේ Deserialization කියලා) external libraries පාවිච්චි කරන්න වෙනවා. මේ library එකක් නැතුව Java වල JSON String manipulate කරන්න ගියොත්, ඒක හරිම අමාරු, tedious වැඩක්.

ඉතින් අපි මේ වැඩේට පාවිච්චි කරන libraries කිහිපයක් තියෙනවා. ඒවා තමයි Java වල JSON එක්ක වැඩ කරන්න තියෙන ජනප්‍රියම libraries.

ජනප්‍රියම JSON Libraries (Popular JSON Libraries)

Java ecosystem එකේ JSON එක්ක වැඩ කරන්න library කිහිපයක්ම තියෙනවා. ඒත් ඒ අතරින් ජනප්‍රියම සහ බලවත්ම libraries දෙකක් තමයි Jackson සහ Gson.

1. Jackson

Jackson කියන්නේ දැනට Java වල තියෙන powerfulම, flexibleම සහ performance අතින් ඉහලම JSON processing library එකක්. Spring Framework වගේ ගොඩක් popular frameworks වලට Jackson තමයි default JSON processor එක විදිහට පාවිච්චි කරන්නේ.

Jackson වල වාසි:

• High Performance: ගොඩක් වේගවත්. Large scale applications වලට ගොඩක් හොඳයි.
• Flexibility: Customization options ගොඩක් තියෙනවා. Annotations පාවිච්චි කරලා serialization/deserialization process එක control කරන්න පුළුවන්.
• Streaming API: විශාල JSON files handle කරන්න පුළුවන්.
• Data Binding: Java Objects සහ JSON අතර පහසුවෙන් convert කරන්න පුළුවන්.

2. Gson

Gson කියන්නේ Google එකෙන් හදපු JSON library එකක්. මේක Jackson වලට වඩා ටිකක් simple, easy to use. ඒ නිසා beginner කෙනෙක්ට පටන් ගන්න හොඳයි.

Gson වල වාසි:

• Simplicity: API එක ගොඩක් සරලයි. ඉක්මනට ඉගෙන ගන්න පුළුවන්.
• No Annotations needed: සාමාන්‍යයෙන් POJO (Plain Old Java Object) එකකට annotations නැතුවම වැඩ කරන්න පුළුවන්.
• Well-documented: හොඳ documentation එකක් තියෙනවා.

මේ දෙකම හොඳයි. ඔයාගේ project එකේ අවශ්‍යතාවය අනුව කැමති එකක් තෝරගන්න පුළුවන්. අද අපි මේ library දෙකම පාවිච්චි කරලා practical examples බලමු.

ප්‍රායෝගික උදාහරණ (Practical Examples)

Java වල JSON එක්ක වැඩ කරන්න නම්, මුලින්ම project එකට අවශ්‍ය library එක add කරගන්න ඕන. අපි Maven පාවිච්චි කරලා මේ dependencies add කරගමු. (Gradle පාවිච්චි කරනවා නම්, ඒකට අදාළ dependency එක add කරගන්න.)

Project Setup (Maven)

pom.xml file එකට පහත dependencies add කරන්න:

<dependencies>
    <!-- Jackson -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.15.2</version> <!-- නවතම version එක බලන්න -->
    </dependency>

    <!-- Gson -->
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.10.1</version> <!-- නවතම version එක බලන්න -->
    </dependency>
</dependencies>

දැන් අපි simple Student class එකක් හදාගමු. මේක තමයි අපි JSON වලට convert කරන්නයි, JSON වලින් ආපහු convert කරන්නයි පාවිච්චි කරන්නේ.

import java.util.List;

public class Student {
    private String name;
    private int age;
    private List<String> subjects;

    // Default constructor is important for deserialization
    public Student() {
    }

    public Student(String name, int age, List<String> subjects) {
        this.name = name;
        this.age = age;
        this.subjects = subjects;
    }

    // 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;
    }

    public List<String> getSubjects() {
        return subjects;
    }

    public void setSubjects(List<String> subjects) {
        this.subjects = subjects;
    }

    @Override
    public String toString() {
        return "Student{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", subjects=" + subjects +
               '}';
    }
}

Jackson Library එක පාවිච්චි කිරීම

Jackson වලින් Java Object එකක් JSON එකකට convert කරන්න ObjectMapper class එක පාවිච්චි කරනවා.

1. Java Object එකක් JSON String එකකට convert කිරීම (Serialization)

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Arrays;
import java.util.List;

public class JacksonExample {
    public static void main(String[] args) {
        // Student object එකක් හදමු
        List<String> studentSubjects = Arrays.asList("Math", "Physics", "Chemistry");
        Student student = new Student("ආරියපාල", 20, studentSubjects);

        // ObjectMapper instance එකක් හදමු
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // Student object එක JSON String එකකට convert කරමු
            String jsonString = objectMapper.writeValueAsString(student);
            System.out.println("Java Object to JSON (Jackson):\n" + jsonString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

මේ code එක run කරාම ඔයාට මේ වගේ output එකක් බලාගන්න පුළුවන්:

Java Object to JSON (Jackson):
{"name":"ආරියපාල","age":20,"subjects":["Math","Physics","Chemistry"]}

2. JSON String එකක් Java Object එකකට convert කිරීම (Deserialization)

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) {
        // JSON String එකක් හදමු
        String jsonString = "{\"name\":\"ලලිතා\",\"age\":25,\"subjects\":[\"History\",\"Geography\"]}";

        // ObjectMapper instance එකක් හදමු
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // JSON String එක Student object එකකට convert කරමු
            Student student = objectMapper.readValue(jsonString, Student.class);
            System.out.println("\nJSON to Java Object (Jackson):\n" + student);

            System.out.println("Converted Student Name: " + student.getName());
            System.out.println("Converted Student Age: " + student.getAge());
            System.out.println("Converted Student Subjects: " + student.getSubjects());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

මේ code එක run කරාම ඔයාට මේ වගේ output එකක් බලාගන්න පුළුවන්:

JSON to Java Object (Jackson):
Student{name='ලලිතා', age=25, subjects=[History, Geography]}
Converted Student Name: ලලිතා
Converted Student Age: 25
Converted Student Subjects: [History, Geography]

Gson Library එක පාවිච්චි කිරීම

Gson වලින් Java Object එකක් JSON එකකට convert කරන්න Gson class එක පාවිච්චි කරනවා. මේක Jackson වලට වඩා API එකෙන් ටිකක් සරලයි.

1. Java Object එකක් JSON String එකකට convert කිරීම (Serialization)

import com.google.gson.Gson;
import java.util.Arrays;
import java.util.List;

public class GsonExample {
    public static void main(String[] args) {
        // Student object එකක් හදමු
        List<String> studentSubjects = Arrays.asList("Art", "Dancing");
        Student student = new Student("නන්දා", 22, studentSubjects);

        // Gson instance එකක් හදමු
        Gson gson = new Gson();

        // Student object එක JSON String එකකට convert කරමු
        String jsonString = gson.toJson(student);
        System.out.println("Java Object to JSON (Gson):\n" + jsonString);
    }
}

මේ code එක run කරාම ඔයාට මේ වගේ output එකක් බලාගන්න පුළුවන්:

Java Object to JSON (Gson):
{"name":"නන්දා","age":22,"subjects":["Art","Dancing"]}

2. JSON String එකක් Java Object එකකට convert කිරීම (Deserialization)

import com.google.gson.Gson;

public class GsonExample {
    public static void main(String[] args) {
        // JSON String එකක් හදමු
        String jsonString = "{\"name\":\"සුනිල්\",\"age\":28,\"subjects\":[\"Economics\",\"Accounting\"]}";

        // Gson instance එකක් හදමු
        Gson gson = new Gson();

        // JSON String එක Student object එකකට convert කරමු
        Student student = gson.fromJson(jsonString, Student.class);
        System.out.println("\nJSON to Java Object (Gson):\n" + student);

        System.out.println("Converted Student Name: " + student.getName());
        System.out.println("Converted Student Age: " + student.getAge());
        System.out.println("Converted Student Subjects: " + student.getSubjects());
    }
}

මේ code එක run කරාම ඔයාට මේ වගේ output එකක් බලාගන්න පුළුවන්:

JSON to Java Object (Gson):
Student{name='සුනිල්', age=28, subjects=[Economics, Accounting]}
Converted Student Name: සුනිල්
Converted Student Age: 28
Converted Student Subjects: [Economics, Accounting]

දැන් ඔයාට පේනවා ඇති Jackson සහ Gson කියන libraries දෙකම කොච්චර සරලව Java Objects සහ JSON අතර conversions කරන්න උදව් වෙනවද කියලා. API එකේ සුළු වෙනස්කම් තිබුනත්, මූලික concept එක ඒ දෙකේම එකයි.

අවසන් වශයෙන් (Conclusion)

ඉතින් යාලුවනේ, අද අපි JSON කියන්නේ මොකක්ද, ඒක Java programming වලදී කොච්චර වැදගත්ද, ඒවගේම JSON එක්ක වැඩ කරන්න පුලුවන් Jackson සහ Gson කියන ජනප්‍රිය libraries දෙක කොහොමද පාවිච්චි කරන්නේ කියන එක ගැන හොඳ අවබෝධයක් ගත්තා. මේ libraries දෙකම performance සහ flexibility අතින් ගොඩක් හොඳයි. ඔයාගේ project එකේ අවශ්‍යතාවය සහ personal preference එක අනුව කැමති එකක් පාවිච්චි කරන්න පුළුවන්. Spring Boot වගේ frameworks වලට නම් Jackson තමයි default.

දැන් ඔයාට පුළුවන් මේක ප්‍රායෝගිකව කරලා බලන්න. තව data types, nested objects, arrays වගේ දේවල් එක්කත් අත්හදා බලන්න. එතකොට ඔයාට තව හොඳට මේ ගැන අවබෝධයක් ලැබෙයි.

මොකද හිතන්නේ? මොන library එකද ඔයාට ගැලපෙන්නේ? මේ ගැන තව මොනවා හරි දැනගන්න ඕන නම්, පහලින් comment එකක් දාන්න. ඔයාගේ අදහස් දැනගන්න අපි ආසයි! නැවත හමුවෙමු!