Jackson Library: Java වලින් JSON Parse කරමු - SC Guide

ආයුබෝවන් යාළුවනේ! ඉතින් කොහොමද? අද අපි කතා කරන්න යන්නේ ඔයාලා හැමෝටම ගොඩක් වැදගත් වෙන මාතෘකාවක් ගැන. මොකද අද කාලේ අපි දකින හැම software එකකම වගේ, විශේෂයෙන්ම web applications සහ APIs වලදී, data transfer කරන්න භාවිතා වෙන ප්‍රධානම format එකක් තමයි JSON කියන්නේ. JSON වලට අමතරව XML වගේ formats තිබුණත්, JSON වල සරල බව, human-readable ස්වභාවය සහ lightweight වීම නිසාම අද ඒක ගොඩක් ජනප්‍රිය වෙලා තියෙනවා.

ඉතින්, ඔයාලා Java developer කෙනෙක් නම්, මේ JSON data එක handle කරන එක හරිම අත්‍යවශ්‍ය දෙයක්. API එකකින් එන JSON response එකක් අරගෙන ඒක Java object එකකට convert කරගන්න, එහෙමත් නැත්නම් Java object එකක් JSON format එකට හදලා API request එකක් යවන්න අපිට නිතරම වගේ සිද්ධ වෙනවා. මේ වගේ වෙලාවට අපිට උදව්වට එන සුපිරිම library එකක් තමයි Jackson Library එක. අද අපි මේ Jackson Library එක ගැන, විශේෂයෙන්ම ObjectMapper එක use කරලා කොහොමද JSON data Java objects වලට convert කරගන්නේ කියලා පියවරෙන් පියවර කතා කරමු.

JSON කියන්නේ මොකක්ද?

මුලින්ම බලමු මේ JSON (JavaScript Object Notation) කියන්නේ හරියටම මොකක්ද කියලා. සරලවම කිව්වොත්, JSON කියන්නේ human-readable data interchange format එකක්. key-value pairs විදිහට තමයි මේකේ data organize වෙන්නේ. JavaScript වල object syntax එකට ගොඩක් සමාන නිසා තමයි මේ නම ලැබිලා තියෙන්නේ. හැබැයි මේක programming language එකකට සීමා වෙන්නේ නැහැ, ඕනෑම language එකකදී use කරන්න පුළුවන්.

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

• Key-Value Pairs: Data organize වෙන්නේ key-value pairs විදිහට. Key එක හැමවිටම String එකක් වෙන්න ඕනේ, double quotes ඇතුලේ. Value එක String, Number, Boolean, Array, Object, එහෙමත් නැත්නම් null වෙන්න පුළුවන්.
• Objects: Curly braces {} ඇතුලේ තියෙනවා. Key-value pairs එකතු කරලා Object එකක් හැදෙනවා.
• Arrays: Square brackets [] ඇතුලේ තියෙනවා. Values list එකක් වගේ තියාගන්න පුළුවන්.

පහලින් තියෙන්නේ පොඩි JSON example එකක්:

{
  "name": "කමල් පෙරේරා",
  "age": 30,
  "isStudent": false,
  "courses": ["Software Engineering", "Data Science"],
  "address": {
    "street": "123 Galle Road",
    "city": "කොළඹ"
  }
}

දැක්කනේ කොච්චර සරලද කියලා? මේ වගේ format එකක තියෙන data තමයි අපි Java වලට convert කරගන්න යන්නේ.

Jackson Library එක ඇයි වැදගත් වෙන්නේ?

Java වල JSON data handle කරන්න libraries ගොඩක් තියෙනවා. GSON, JSON-B වගේ ඒවා ඒ අතරින් ප්‍රධානයි. හැබැයි ඒ හැම එකක්ම අභිබවා ගිහින් අද ගොඩක් අය use කරන්නේ Jackson Library එක. ඒකට ප්‍රධාන හේතු කීපයක් තියෙනවා:

• Performance: Jackson කියන්නේ ගොඩක් වේගවත් library එකක්. Large JSON files handle කරනකොට මේක ගොඩක් වාසියි.
• Flexibility: Customization options ගොඩක් තියෙනවා. ඔයාලට ඕන විදිහට JSON mapping adjust කරගන්න පුළුවන්.
• Community Support: විශාල community එකක් තියෙනවා, ඒ නිසා ඕනෑම ප්‍රශ්නයකට විසඳුම් හොයාගන්න ලේසියි.
• Features: Streaming API, data binding, tree model වගේ ගොඩක් advanced features මේකේ තියෙනවා.

Jackson Library එකේ ප්‍රධානම component එකක් තමයි ObjectMapper class එක. මේක තමයි JSON data සහ Java objects අතර bridge එක විදිහට වැඩ කරන්නේ. JSON එක Java object එකකට convert කරන එකට deserialization කියනවා, ඒ වගේම Java object එකක් JSON එකකට convert කරන එකට serialization කියනවා. අද අපි වැඩිපුරම අවධානය දෙමු deserialization වලට, මොකද ඒක තමයි API responses handle කරනකොට ගොඩක්ම අවශ්‍ය වෙන්නේ.

Jackson Dependency එක Project එකට එකතු කරගමු

මුලින්ම අපේ Java project එකට Jackson dependency එක add කරගන්න ඕනේ. ඔයාලා Maven build tool එක use කරනවා නම්, pom.xml file එකට පහත dependency එක එකතු කරන්න:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.16.1</version><!-- Use the latest stable version -->
</dependency>

Gradle use කරනවා නම්, build.gradle file එකට මෙහෙම එකතු කරන්න:

implementation 'com.fasterxml.jackson.core:jackson-databind:2.16.1' // Use the latest stable version

ඔයාලා මේ ලිපිය කියවන වෙලාව වෙනකොට Jackson Library එකේ අලුත් version එකක් ඇවිත් තියෙන්න පුළුවන්. ඒ නිසා හැමවිටම latest stable version එක use කරන්න උත්සාහ කරන්න. (maven central repository එකෙන් බලාගන්න පුළුවන්).

JSON එක Java Object එකකට Convert කරමු (Deserialization)

හරි, දැන් අපි Jackson Library එක use කරලා JSON string එකක් Java object එකකට convert කරන්නේ කොහොමද කියලා බලමු. මේකට අපිට පොඩි Java class එකක් හදාගන්න වෙනවා. මේ class එකේ fields, අපේ JSON එකේ keys එක්ක ගැලපෙන්න ඕනේ. මේ වගේ classes වලට අපි Plain Old Java Object (POJO) එකක් කියලා කියනවා.

Step 1: POJO Class එක හදාගමු

අපි හිතමු අපිට පහත JSON string එක ලැබුණා කියලා:

{
  "studentId": "S001",
  "fullName": "ආශා ලක්මාලි",
  "age": 22,
  "major": "Computer Science",
  "isEnrolled": true
}

මේ JSON එකට අනුරූප POJO class එක මෙහෙම හදාගන්න පුළුවන්:

public class Student {
    private String studentId;
    private String fullName;
    private int age;
    private String major;
    private boolean isEnrolled;

    // Default constructor is required by Jackson
    public Student() {
    }

    // Getters and Setters (Jackson uses setters for deserialization)
    public String getStudentId() {
        return studentId;
    }

    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }

    public String getFullName() {
        return fullName;
    }

    public void setFullName(String fullName) {
        this.fullName = fullName;
    }

    public int getAge() {
        return age;
    }

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

    public String getMajor() {
        return major;
    }

    public void setMajor(String major) {
        this.major = major;
    }

    public boolean isEnrolled() {
        return isEnrolled;
    }

    public void setEnrolled(boolean enrolled) {
        isEnrolled = enrolled;
    }

    @Override
    public String toString() {
        return "Student{" +
               "studentId='" + studentId + '\'' +
               ", fullName='" + fullName + '\'' +
               ", age=" + age +
               ", major='" + major + '\'' +
               ", isEnrolled=" + isEnrolled +
               '}';
    }
}

දැක්කා නේද? POJO එකේ field names, JSON keys එක්ක හරියටම ගැලපෙන්න ඕනේ. ඒ වගේම default constructor එකක් (arguments නැති constructor එකක්) සහ getters, setters Jackson වලට අත්‍යවශ්‍යයි. Setters තමයි deserialization එකේදී values set කරන්න use වෙන්නේ.

Step 2: ObjectMapper එකෙන් JSON එක convert කරමු

දැන් අපි බලමු මේ POJO එකට JSON string එක convert කරන්නේ කොහොමද කියලා. මේකට අපි ObjectMapper class එක use කරනවා. readValue() method එක තමයි මේකට ප්‍රධාන වශයෙන් use වෙන්නේ.

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;

public class JsonToJavaConverter {

    public static void main(String[] args) {
        String jsonString = "{ \"studentId\": \"S001\", \"fullName\": \"ආශා ලක්මාලි\", \"age\": 22, \"major\": \"Computer Science\", \"isEnrolled\": true }";

        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // Convert JSON string to Student object
            Student student = objectMapper.readValue(jsonString, Student.class);

            System.out.println("Student ID: " + student.getStudentId());
            System.out.println("Full Name: " + student.getFullName());
            System.out.println("Age: " + student.getAge());
            System.out.println("Major: " + student.getMajor());
            System.out.println("Enrolled: " + student.isEnrolled());

            System.out.println("\nFull Student Object: " + student.toString());

        } catch (IOException e) {
            e.printStackTrace(); // Handle the exception properly in a real application
        }
    }
}

මේ code එක run කරලා බලන්න. JSON එකේ තියෙන data හරියටම Java object එකට mapping වෙලා ඇති. readValue() method එකට අපි දෙන්න ඕනේ JSON string එකයි, ඒක convert කරන්න ඕන Java class එකයි (Student.class වගේ).

IOException එකක් catch කරන්න මතක තියාගන්න. මොකද JSON string එක invalid නම් එහෙමත් නැත්නම් වෙනත් I/O error එකක් ආවොත් මේ exception එක throw වෙන්න පුළුවන්. Real world application එකකදී මේක proper විදිහට handle කරන්න ඕනේ.

Nested Objects සහ Arrays Handle කරන්නේ කොහොමද?

අපිට JSON එකක nested objects (object ඇතුලේ object) එහෙමත් නැත්නම් arrays තියෙන්න පුළුවන්. කලින් උදාහරණයක අපි දැක්කා address කියන nested object එකක්. ඒ වගේම courses කියන array එකක්. මේවා handle කරන්නත් හරිම ලේසියි.

මුලින්ම කලින් අපි දැක්ක JSON එකට අදාළව POJO classes හදාගමු:

{
  "name": "කමල් පෙරේරා",
  "age": 30,
  "isStudent": false,
  "courses": ["Software Engineering", "Data Science"],
  "address": {
    "street": "123 Galle Road",
    "city": "කොළඹ"
  }
}

// Person.java
import java.util.List;

public class Person {
    private String name;
    private int age;
    private boolean isStudent;
    private List<String> courses; // For the array of strings
    private Address address;      // For the nested object

    public Person() {}

    // Getters and Setters for all fields
    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 boolean isStudent() { return isStudent; }
    public void setStudent(boolean student) { isStudent = student; }
    public List<String> getCourses() { return courses; }
    public void setCourses(List<String> courses) { this.courses = courses; }
    public Address getAddress() { return address; }
    public void setAddress(Address address) { this.address = address; }

    @Override
    public String toString() {
        return "Person{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", isStudent=" + isStudent +
               ", courses=" + courses +
               ", address=" + address +
               '}';
    }
}

// Address.java (Nested POJO)
public class Address {
    private String street;
    private String city;

    public Address() {}

    // Getters and Setters
    public String getStreet() { return street; }
    public void setStreet(String street) { this.street = street; }
    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }

    @Override
    public String toString() {
        return "Address{" +
               "street='" + street + '\'' +
               ", city='" + city + '\'' +
               '}';
    }
}

දැන් මේවා convert කරන්නේ කලින් වගේමයි:

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;

public class NestedJsonConverter {
    public static void main(String[] args) {
        String jsonString = "{ \"name\": \"කමල් පෙරේරා\", \"age\": 30, \"isStudent\": false, \"courses\": [\"Software Engineering\", \"Data Science\"], \"address\": { \"street\": \"123 Galle Road\", \"city\": \"කොළඹ\" } }";

        ObjectMapper objectMapper = new ObjectMapper();

        try {
            Person person = objectMapper.readValue(jsonString, Person.class);

            System.out.println("Person Name: " + person.getName());
            System.out.println("Person Age: " + person.getAge());
            System.out.println("Courses: " + person.getCourses());
            System.out.println("Address Street: " + person.getAddress().getStreet());
            System.out.println("Address City: " + person.getAddress().getCity());

            System.out.println("\nFull Person Object: " + person.toString());

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

ඔයාලට පේනවා ඇති, Jackson Library එක ස්වයංක්‍රීයවම nested objects සහ arrays නිවැරදි Java types වලට map කරනවා. Arrays වලදී java.util.List වගේ Collection types use කරන්න පුළුවන්.

Java Object එක JSON එකකට Convert කරමු (Serialization)

JSON එක Java object එකකට convert කරන එක වගේම, Java object එකක් JSON string එකකට convert කරන එකත් (serialization) Jackson Library එකෙන් හරිම ලේසියි. මේකට අපි ObjectMapper එකේම writeValueAsString() method එක use කරනවා.

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.io.IOException;

public class JavaToJsonConverter {

    public static void main(String[] args) {
        // Create a Student object
        Student student = new Student();
        student.setStudentId("S002");
        student.setFullName("නුපුන් ප්‍රසාද්");
        student.setAge(25);
        student.setMajor("Data Science");
        student.setEnrolled(true);

        ObjectMapper objectMapper = new ObjectMapper();
        
        // Optional: Make the JSON output pretty-printed (readable)
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);

        try {
            // Convert Student object to JSON string
            String jsonOutput = objectMapper.writeValueAsString(student);

            System.out.println("Converted JSON Output:\n" + jsonOutput);

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

මේ code එක run කරාම, අපේ `Student` object එක ලස්සනට format වුණු JSON string එකක් විදිහට print වෙයි. objectMapper.enable(SerializationFeature.INDENT_OUTPUT) කියන line එකෙන් කරන්නේ JSON output එක readable විදිහට indent කරන එක.

කෙටි උපදෙස් (Tips & Tricks)

Jackson Library එක use කරනකොට ඔයාලට වැදගත් වෙන්න පුළුවන් තවත් පොඩි tips කීපයක් මෙන්න:

• Unmatched Properties Ignore කිරීම: සමහර වෙලාවට අපිට එන JSON එකේ, අපේ POJO එකේ නැති fields තියෙන්න පුළුවන්. එහෙම වෙලාවට Jackson default විදිහට error එකක් throw කරනවා. ඒක වළක්වන්න, POJO class එකට උඩින් @JsonIgnoreProperties(ignoreUnknown = true) annotation එක එකතු කරන්න.
• Field Names JSON keys එක්ක නොගැලපෙන විට: ඔයාලගේ Java field name එක JSON key එකට වඩා වෙනස් නම්, @JsonProperty("json_key_name") annotation එක use කරන්න පුළුවන්.
• Null Values Handling: JSON එකේ null values තියෙනකොට Jackson ඒවා Java object එකේ අදාළ fields වලට null විදිහටම map කරනවා. Serialization වලදී null fields exclude කරන්න ඕන නම්, objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); වගේ එකක් use කරන්න පුළුවන්.

public class Product {
    @JsonProperty("product_id")
    private String id;
    private String name;
    // ...
}

@JsonIgnoreProperties(ignoreUnknown = true)
public class Student {
    // ... fields and methods ...
}

සාරාංශය සහ ඉදිරි පියවර

ඉතින්, අද අපි Jackson Library එකේ ObjectMapper එක use කරලා JSON data Java objects වලට deserialize කරන හැටි සහ Java objects JSON වලට serialize කරන හැටි ඉගෙන ගත්තා. මේක ඔයාලගේ Java applications වල JSON data handle කරනකොට ගොඩක්ම ප්‍රයෝජනවත් වෙයි. විශේෂයෙන්ම REST APIs එක්ක වැඩ කරනකොට මේ දැනුම අත්‍යවශ්‍යයි.

Jackson කියන්නේ මේ ටිකට විතරක් සීමා වෙන library එකක් නෙවෙයි. මේකේ තව ගොඩක් advanced features තියෙනවා. Stream API, Tree Model, custom serializers/deserializers වගේ දේවල් ගැන ඔයාලට තවදුරටත් අධ්‍යනය කරන්න පුළුවන්. මේකෙන් ඔයාලට Jackson Library එකේ තවත් ගැඹුරට යන්න පුළුවන් වෙයි.

දැන් ඉතින් ඔයාලත් මේ concepts ටික ඔයාලගේ project එකක implement කරලා බලන්න. මොකද practice කරන එක තමයි හොඳම විදිහ. මේ ලිපිය ගැන ඔයාලගේ අදහස්, ප්‍රශ්න තියෙනවා නම් පහලින් comment කරන්න. එහෙමත් නැත්නම් ඔයාලා Jackson use කරපු විදිහ ගැන අත්දැකීම් බෙදාගන්නත් පුළුවන්. එහෙනම් තවත් අලුත් ලිපියකින් හමුවෙමු, හැමෝටම ජය!