ආයුබෝවන් යාළුවනේ! Java වලින් XML කියවමු DOM Parser භාවිතයෙන්!

අද අපි කතා කරන්න යන්නේ Software Engineering ලෝකයේ ගොඩක් වැදගත් වෙන, දත්ත කළමනාකරණයට නැතුවම බැරි තාක්ෂණයක් ගැන. ඒ තමයි XML කියන්නේ. විශාල දත්ත ප්‍රමාණයක් structured විදිහට store කරන්න සහ විවිධ applications අතර data exchange කරන්න XML වලට තියෙන්නේ පුදුමාකාර හැකියාවක්. විශේෂයෙන්ම, Java program එකක් ඇතුලෙන් XML files read කරන්නේ කොහොමද කියලා අපි බලමු. අද අපේ ප්‍රධාන මාතෘකාව තමයි DOM Parser එක භාවිතා කරලා XML files Java වලදී read කරන හැටි. මේ ලිපියෙන් ඔයාලට XML කියන්නේ මොකද්ද, DOM Parser එක ක්‍රියා කරන විදිහ සහ Java code වලින් ඒක implement කරන්නේ කොහොමද කියන දේ සරලව තේරුම් කරලා දෙන්න මම බලාපොරොත්තු වෙනවා. එහෙනම් අපි පටන් ගමු!

1. XML කියන්නේ මොකද්ද? (What is XML?)

XML කියන්නේ eXtensible Markup Language කියන එකේ කෙටි නාමය. මේක HTML වගේම markup language එකක් වුණත්, HTML display කරන්න (web pages හදන්න) පාවිච්චි කරනකොට, XML data store කරන්න සහ transfer කරන්න පාවිච්චි කරනවා. XML එකේ තියෙන විශේෂත්වය තමයි මේක 'self-descriptive' වීම. ඒ කියන්නේ, tags වලින් data එකේ තේරුම කියන නිසා, document එක බැලුව ගමන් data එක මොකද්ද කියලා තේරුම් ගන්න පුළුවන්.

XML වලට තියෙන්නේ සරල, text-based format එකක්. ඒක නිසා විවිධ platforms සහ programming languages අතර දත්ත හුවමාරු කරගන්න මේක ගොඩක් සුදුසුයි. උදාහරණයක් විදිහට, web services (SOAP) වල, configuration files (Maven, Spring), සහ data feeds (RSS) වගේ තැන් වල XML බහුලව භාවිතා වෙනවා.

XML document එකක මූලික සංරචක කිහිපයක් තියෙනවා:

• Elements (කලමනා): මේවා tags වලින් වට වෙලා තියෙනවා. උදාහරණ: <student>, <name>.
• Attributes (ගුණාංග): Elements වලට අමතර තොරතුරු එකතු කරන්න මේවා පාවිච්චි කරනවා. උදාහරණ: <student id="001"> (id කියන්නේ attribute එකක්).
• Text Content (පෙළ අන්තර්ගතය): Elements ඇතුලේ තියෙන සත්‍ය දත්ත. උදාහරණ: <name>Nimal Perera</name> (Nimal Perera කියන්නේ text content එක).
• Root Element (මුල් කලමන): XML document එකක තියෙන්න ඕන එකම top-level element එක. අනෙක් හැම element එකක්ම මේ root element එක ඇතුලේ තමයි තියෙන්නේ.

XML documents හැමවිටම well-formed වෙන්න ඕන. ඒ කියන්නේ, tags හරියට close වෙලා තියෙන්න ඕන, nested (එකක් ඇතුලේ තව එකක්) වෙලා තියෙන්න ඕන, වගේ නීති රීති ටිකක් තියෙනවා. මේ නීති කැඩුවොත් Parser එකට document එක කියවන්න බැරි වෙනවා.

2. DOM Parser කියන්නේ මොකද්ද? (What is DOM Parser?)

DOM Parser එක කියන්නේ XML document එකක් memory එක ඇතුළේ 'tree structure' එකක් විදිහට නිරූපණය කරන විදිහක්. DOM කියන්නේ Document Object Model කියන එකට. හිතන්න, ඔයාලගේ XML file එකේ තියෙන හැම element එකක්ම, attribute එකක්ම, text එකක්ම මේ tree එකේ node එකක් විදිහට තියෙනවා කියලා.

මේ tree structure එක නිසා, XML document එකේ ඕනෑම කොටසකට පහසුවෙන් පිවිසෙන්න, වෙනස් කරන්න පුළුවන්. උදාහරණයක් විදිහට, ඔයාලට root element එකේ ඉඳන් පහළට ගිහින් (traverse කරලා) ඕන කරන element එකක් හොයාගන්න පුළුවන්. ඒ වගේම, document එකේ තියෙන data update කරන්න, අලුත් elements එකතු කරන්න, නැතිනම් තියෙන elements delete කරන්නත් පුළුවන්.

DOM Parser එකේ ක්‍රියාකාරීත්වය:

1. Loading (පැටවීම): DOM Parser එක මුලින්ම මුළු XML file එකම memory එකට load කරනවා.
2. Tree Construction (ගස් නිර්මාණය): ඊට පස්සේ, XML document එකේ structure එකට අනුව tree එකක් ගොඩනගනවා. මේ tree එකේ හැම element එකක්ම, attribute එකක්ම, text node එකක්ම Java object එකක් විදිහට නිරූපණය වෙනවා.
3. Access and Manipulation (ප්‍රවේශය සහ හැසිරවීම): Tree එක ගොඩනැගුවට පස්සේ, ඔයාලට Java API (org.w3c.dom package) එක පාවිච්චි කරලා මේ tree එකේ ඕනෑම node එකකට පිවිසෙන්න, data කියවන්න, නැතිනම් වෙනස්කම් කරන්න පුළුවන්.

DOM Parser එකේ වාසි සහ අවාසි (Pros and Cons):

වාසි (Advantages):

• Easy Navigation and Random Access (පහසු සංචලනය සහ අහඹු ප්‍රවේශය): Tree structure එකක් නිසා, document එකේ ඕනෑම තැනකට පහසුවෙන් පිවිසෙන්න (random access) පුළුවන්. Element එකක් හොයාගන්න මුළු document එකම iterate කරන්න ඕන නෑ.
• Data Manipulation (දත්ත හැසිරවීම): XML document එක memory එකේ object model එකක් විදිහට තියෙන නිසා, elements add කරන්න, remove කරන්න, modify කරන්න වගේ operations පහසුවෙන් කරන්න පුළුවන්.
• User-Friendly API (පරිශීලක-හිතකාමී API): org.w3c.dom package එකේ තියෙන classes සහ methods ඉතාම පැහැදිලියි, නිසා වැඩ කරන්න පහසුයි.

අවාසි (Disadvantages):

• Memory Consumption (මතක පරිභෝජනය): DOM Parser එක මුළු XML file එකම memory එකට load කරන නිසා, විශාල XML files සඳහා මේක memory ගොඩක් පාවිච්චි කරනවා. Gigabyte ගණන් විශාල files කියවනකොට OutOfMemoryError වගේ errors එන්න පුළුවන්.
• Performance (කාර්ය සාධනය): විශාල files සඳහා, memory එකට load කරන නිසා performance එක පොඩ්ඩක් slow වෙන්න පුළුවන්.

විශාල XML files කියවනවා නම්, Streaming Parsers (SAX Parser වගේ) DOM Parser එකට වඩා සුදුසුයි. ඒත් සාමාන්‍ය ප්‍රමාණයේ XML files සහ XML document එක modify කරන්න අවශ්‍ය නම් DOM Parser එක තමයි හොඳම විසඳුම.

3. Java වල DOM Parser පාවිච්චි කරමු (Let's Use DOM Parser in Java)

Java වල DOM Parser එක භාවිතා කරන්න නම්, අපිට Java Platform, Standard Edition (Java SE) එකේ built-in APIs පාවිච්චි කරන්න පුළුවන්. මේ සඳහා javax.xml.parsers සහ org.w3c.dom packages වල තියෙන classes අපිට උදව් වෙනවා.

පියවර 1: අවශ්‍ය XML File එක (Our Example XML File)

මුලින්ම අපි කියවන්න යන XML file එක හදාගමු. මේක students.xml කියලා save කරගන්න.

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<students>
    <student id="001">
        <name>Nimal Perera</name>
        <age>22</age>
        <major>Computer Science</major>
    </student>
    <student id="002">
        <name>Kamala Silva</name>
        <age>23</age>
        <major>Software Engineering</major>
    </student>
    <student id="003">
        <name>Amal Bandara</name>
        <age>21</age>
        <major>Data Science</major>
    </student>
</students>

පියවර 2: Java Code එක (The Java Code)

දැන් අපි මේ XML file එක කියවන්න අවශ්‍ය Java code එක ලියමු. මේක DomParserExample.java කියලා save කරගන්න.

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;

public class DomParserExample {

    public static void main(String[] args) {
        try {
            // 1. DocumentBuilderFactory එකක් හදාගන්නවා
            // මේකෙන් DocumentBuilder objects හදන්න පුදුවන්
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

            // 2. DocumentBuilder එකක් හදාගන්නවා
            // මේක XML file එක parse කරන්න පාවිච්චි කරනවා
            DocumentBuilder builder = factory.newDocumentBuilder();

            // 3. XML file එක load කරලා Document object එකක් හදාගන්නවා
            // මේක තමයි XML tree එකේ root එක
            File xmlFile = new File("students.xml");
            Document doc = builder.parse(xmlFile);

            // 4. XML document එක normalize කරනවා
            // මේක good practice එකක්. විශේෂයෙන් text nodes combine කරන්න උදව් වෙනවා.
            doc.getDocumentElement().normalize();

            // 5. Root Element එක ලබාගන්නවා
            System.out.println("Root element: " + doc.getDocumentElement().getNodeName());

            // 6. "student" tags තියෙන හැම node එකක්ම NodeList එකකට ගන්නවා
            NodeList studentList = doc.getElementsByTagName("student");

            System.out.println("----------------------------");

            // 7. NodeList එක iterate කරලා හැම student කෙනෙක්ගේම data කියවනවා
            for (int i = 0; i < studentList.getLength(); i++) {
                Node studentNode = studentList.item(i);

                // Node එක Element type එකක්ද කියලා check කරනවා
                if (studentNode.getNodeType() == Node.ELEMENT_NODE) {
                    Element studentElement = (Element) studentNode;

                    // "id" attribute එක කියවනවා
                    String id = studentElement.getAttribute("id");
                    System.out.println("Student ID : " + id);

                    // "name" element එකේ value එක කියවනවා
                    NodeList nameList = studentElement.getElementsByTagName("name");
                    if (nameList.getLength() > 0) {
                        System.out.println("Name : " + nameList.item(0).getTextContent());
                    }

                    // "age" element එකේ value එක කියවනවා
                    NodeList ageList = studentElement.getElementsByTagName("age");
                    if (ageList.getLength() > 0) {
                        System.out.println("Age : " + ageList.item(0).getTextContent());
                    }

                    // "major" element එකේ value එක කියවනවා
                    NodeList majorList = studentElement.getElementsByTagName("major");
                    if (majorList.getLength() > 0) {
                        System.out.println("Major : " + majorList.item(0).getTextContent());
                    }
                    System.out.println("----------------------------");
                }
            }

        } catch (Exception e) {
            // Parsing කරනකොට එන්න පුළුවන් errors අල්ලගන්නවා
            e.printStackTrace();
        }
    }
}

Code එක පැහැදිලි කිරීම:

• DocumentBuilderFactory.newInstance(): මේක XML parsing සඳහා DocumentBuilder objects හදන්න අවශ්‍ය factory instance එකක් හදාගන්නවා. මේක API එකේ entry point එක කියලා කියන්න පුළුවන්.
• factory.newDocumentBuilder(): Factory එකෙන් DocumentBuilder object එකක් හදනවා. මේක තමයි actual XML parsing task එක කරන්නේ.
• builder.parse(xmlFile): DocumentBuilder එකේ parse() method එකට අපේ XML file එකේ path එක හෝ File object එක දෙනවා. මේ method එක XML file එක කියවලා, memory එක ඇතුළේ DOM tree එකක් හදලා, ඒ tree එක නිරූපණය කරන Document object එකක් return කරනවා. මේ Document object එක තමයි මුළු XML document එකේම root node එක.
• doc.getDocumentElement().normalize(): මේක හොඳ practice එකක්. XML Parser එකක් document එක parse කරනකොට, සමහර වෙලාවට text content එකට අමතරව white spaces (newline characters, tabs) වගේ දේවල් වෙනම Text Nodes විදිහට create කරන්න පුළුවන්. normalize() method එකෙන් මේ වගේ contiguous text nodes එකට එකතු කරනවා, ඒ නිසා data access කරනකොට පහසු වෙනවා.
• doc.getDocumentElement(): මේකෙන් XML document එකේ root element එක (අපේ උදාහරණයේ <students>) Element object එකක් විදිහට ලබාගන්නවා.
• doc.getElementsByTagName("student"): මේ method එකෙන් document එකේ තියෙන හැම <student> element එකක්ම NodeList object එකකට එකතු කරනවා. NodeList එක කියන්නේ Nodes collection එකක්.
• NodeList.item(i): NodeList එකේ තියෙන එක් එක් Node එකට access කරන්න මේක පාවිච්චි කරනවා.
• Node.getNodeType() == Node.ELEMENT_NODE: NodeList එකේ විවිධ වර්ගයේ nodes (Element, Text, Comment, etc.) තියෙන්න පුළුවන්. අපිට අවශ්‍ය Elements නිසා, මේ condition එකෙන් Element nodes විතරක් filter කරගන්නවා.
• (Element) studentNode: Node object එක Element object එකකට cast කරනවා. Element class එකට තමයි getAttribute(), getElementsByTagName() වගේ methods තියෙන්නේ.
• studentElement.getAttribute("id"): Element එකක attribute value එක කියවන්න මේ method එක පාවිච්චි කරනවා.
• studentElement.getElementsByTagName("name").item(0).getTextContent(): මේකෙන් student element එක ඇතුලේ තියෙන <name> element එක අරගෙන, ඒකේ තියෙන text content (නම) කියවනවා. item(0) කියන්නේ list එකේ පළවෙනි item එක, මොකද <name> වගේ elements එක student කෙනෙක්ට එකක් විතරයි තියෙන්නේ.
• try-catch (Exception e): XML parsing කරනකොට විවිධ errors එන්න පුළුවන්. උදාහරණයක් විදිහට XML file එක හොයාගන්න බැරි වුණොත් (IOException), නැතිනම් XML එක well-formed නැතිනම් (SAXException), නැතිනම් DocumentBuilder එක හදන්න බැරි වුණොත් (ParserConfigurationException) මේ errors අල්ලගන්න try-catch block එකක් පාවිච්චි කරන එක අනිවාර්යයි.

පියවර 3: Code එක Compile කරලා Run කරමු!

1. students.xml සහ DomParserExample.java කියන files දෙකම එකම folder එකක save කරන්න.
2. Command Prompt (Windows) හෝ Terminal (Linux/macOS) එක open කරලා, files තියෙන folder එකට යන්න.
3. Java code එක compile කරන්න: javac DomParserExample.java
4. Program එක run කරන්න: java DomParserExample

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

Root element: students
----------------------------
Student ID : 001
Name : Nimal Perera
Age : 22
Major : Computer Science
----------------------------
Student ID : 002
Name : Kamala Silva
Age : 23
Major : Software Engineering
----------------------------
Student ID : 003
Name : Amal Bandara
Age : 21
Major : Data Science
----------------------------

4. අවසන් වශයෙන්...

ඉතින් යාළුවනේ, මේ ලිපියෙන් ඔයාලට DOM Parser එකෙන් XML files Java වලදී read කරන හැටි ගැන පැහැදිලි අවබෝධයක් ලැබෙන්න ඇති කියලා හිතනවා. XML කියන්නේ අදටත් දත්ත හුවමාරුවට බහුලව භාවිතා වන තාක්ෂණයක් නිසා, ඒක Java program එකක් ඇතුලෙන් handle කරන්නේ කොහොමද කියලා දැනගෙන ඉන්න එක ඔයාලගේ Software Engineering journey එකට ගොඩක් වැදගත් වේවි.

DOM Parser එක සාපේක්ෂව සරලයි, document එකේ ඕනෑම තැනකට පහසුවෙන් පිවිසෙන්න පුළුවන් හැකියාව වගේම document එක වෙනස් කරන්න පුළුවන් වීමත් මේකේ ප්‍රධාන වාසියක්. හැබැයි මතක තියාගන්න, විශාල XML files එක්ක වැඩ කරනකොට memory usage එක ගැන සැලකිලිමත් වෙන්න ඕන. එතකොට SAX Parser වගේ streaming parsers ගැන හිතන්න වෙනවා.

දැන් ඔයාලට පුළුවන් මේක ඔයාලගේ project වලටත් apply කරලා බලන්න. Configuration files read කරන්න, data feeds process කරන්න, වගේ ගොඩක් දේවල් වලට මේ දැනුම පාවිච්චි කරන්න පුළුවන්. මේ ගැන ඔයාලට මොනවා හරි ප්‍රශ්න තියෙනවා නම්, නැතිනම් මේ වගේ තවත් මොනවා හරි topic එකක් ගැන දැනගන්න කැමති නම්, පහලින් comment එකක් දාන්න අමතක කරන්න එපා. ඔයාලගේ අදහස් අපිට ගොඩක් වටිනවා.

තවත් මේ වගේ වැදගත් ලිපියකින් හමුවෙමු! සුභ දවසක්!