XML: ano ito, istraktura ng dokumento at prinsipyo ng paggana

Ano ang XML?

XML ay isang markup language na tumutukoy sa isang set ng mga panuntunan para sa pag-encode ng mga dokumento sa isang format na nababasa ng tao at makina. Hindi tulad ng HTML, ang XML ay walang nakapirming set ng mga tag — ang developer ay lumilikha ng sarili niyang mga tag na naaayon sa istraktura ng data.

Ang XML ay binuo ng W3C consortium noong 1996 bilang isang pinasimpleng subset ng SGML (Standard Generalized Markup Language). Ang pangunahing layunin ng XML ay paghiwalayin ang nilalaman at presentasyon ng data. Hindi tulad ng HTML na naglalarawan ng hitsura, ang XML ay naglalarawan ng istraktura at kahulugan ng data.

Ang pangunahing katangian ng XML ay ang pagpapalawak nito. Kung may lumitaw na mga bagong uri ng data sa proyekto, ang developer ay nagdaragdag lamang ng mga bagong tag nang hindi binabago ang umiiral na istraktura. Ginagawa nitong maginhawa ang XML para sa pangmatagalang pag-iimbak ng data at pagpapalitan sa pagitan ng iba’t ibang sistema.

Mga Pangunahing Lugar ng Paggamit ng XML

• Android development — mga layout file, manifest, resources (strings, colors, themes)
• Configuration — Maven POM, Ant build, mga web config (web.xml)
• Mga Web Service — SOAP, XML-RPC, RSS/Atom feeds
• Daloy ng Dokumento — SVG, DocBook, Office Open XML
• Mga Database — SQL Server (XML type), Oracle, PostgreSQL

Syntax at Istraktura ng XML

Ang syntax ng XML ay mas mahigpit kaysa sa HTML. Ang bawat pambungad na tag ay dapat may katumbas na pansarang tag, ang mga attribute ay nasa loob ng mga panipi, ang mga pangalan ng tag ay sensitibo sa malaki at maliit na titik. Ang dokumento ay dapat may eksaktong isang root element na naglalaman ng lahat ng iba pang elemento.

Ang XML na dokumento ay maaaring magsimula sa isang deklarasyon na nagpapahiwatig ng bersyon ng XML at encoding. Pagkatapos ay sumusunod ang root element, sa loob nito ay maaaring may mga nested na elemento, attribute, text content, at komento. Ang mga walang laman na elemento ay isinusulat bilang .

<?xml version="1.0" encoding="UTF-8"?>
<catalog>
    <book id="bk001">
        <title>XML Developer Guide</title>
        <author>John Smith</author>
        <price currency="USD">29.99</price>
        <published>2026-03-15</published>
    </book>
    <book id="bk002">
        <title>Advanced XML Schemas</title>
        <author>Jane Doe</author>
        <price currency="USD">49.99</price>
        </book>
</catalog>

Mga Panuntunan ng Well-formed XML

Well-formed XML ay dapat sumunod sa mga pangunahing panuntunan: ang mga pansarang tag ay sapilitan para sa bawat pambungad na tag, ang pag-nest ay mahigpit (ipinagbabawal ang pagtawid ng mga tag), ang mga halaga ng attribute ay palaging nasa panipi. Ang paglabag sa anumang panuntunan ay nagpapawalang-bisa sa dokumento at hindi ito maaaring i-parse.

1. Isang root element — ang dokumento ay may eksaktong isang root
2. Tamang pag-nest — ang mga tag ay hindi dapat mag-cross
3. Pansarang tag — sapilitan para sa lahat ng elemento maliban sa self-closing
4. Sensitibo sa malaki/maliit na titik — <Book> at <book> ay magkaibang elemento
5. Mga panipi sa attribute — mga halaga ng attribute sa doble o solong panipi

Mga Namespace at Schema ng XML

Ang XML namespaces ay lumulutas sa problema ng mga salungatan sa pangalan kapag sa isang dokumento ay ginagamit ang mga elemento mula sa iba’t ibang diksyunaryo. Ang namespace ay tinutukoy ng xmlns attribute na may URI na natatanging tumutukoy sa diksyunaryo.

XML Schema (XSD) ay isang wika para sa paglalarawan ng istraktura ng isang XML na dokumento. Tinutukoy ng XSD kung aling mga elemento at attribute ang pinapayagan, ang kanilang mga uri ng data, obligasyon, at mga limitasyon. Ang mga schema ay nagbibigay-daan sa awtomatikong pag-validate ng dokumento bago ang pagproseso, na kritikal para sa mga solusyon sa pagsasama.

XML sa Mobile Development

XML ay may mahalagang papel sa Android development. Ginagamit ng Android operating system ang XML para sa paglalarawan ng user interface (mga layout file), configuration ng application (AndroidManifest.xml), resources (mga string, kulay, tema) at vector graphics (VectorDrawable). Sa iOS, ang XML ay ginagamit nang mas madalas, pangunahin para sa Storyboard at mga plist configuration file.

Sa Android, ang bawat screen ng application ay inilalarawan ng isang XML file na may hierarchy ng mga View component: ConstraintLayout, LinearLayout, TextView, Button. Ang pamamaraang ito ay naghihiwalay ng lohika ng application mula sa presentasyon, pinapasimple ang pagpapanatili at pag-aangkop sa iba’t ibang screen. Ang mga XML resource file ay nagbibigay-daan sa lokalisasyon ng application nang hindi binabago ang code.

Halimbawa ng Android Layout

Ang tipikal na layout file ay naglalaman ng root ConstraintLayout na may nested na mga elemento, bawat isa ay may mga attribute ng posisyon, laki, at estilo. Ini-compile ng Android ang XML sa binary AXML format para sa pag-optimize ng performance sa pagsisimula.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/title"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/welcome"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/click"
        app:layout_constraintTop_toBottomOf="@id/title"
        app:layout_constraintStart_toStartOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Pag-parse ng XML sa Mga Mobile Platform

Ang pag-parse ng XML sa mga mobile platform ay ginagawa gamit ang dalawang pangunahing paraan: DOM (Document Object Model) ay naglo-load ng buong dokumento sa memorya bilang isang puno, SAX (Simple API for XML) ay nagbabasa ng dokumento nang streaming, na tumatawag sa mga event handler. Ang DOM ay maginhawa para sa maliliit na dokumento, ang SAX — para sa malalaking file na may limitasyon sa memorya.

Sa Android ay may mga built-in na parser: XmlPullParser para sa streaming analysis at DocumentBuilder para sa DOM approach. Sa iOS ay ginagamit ang Foundation XMLParser na may delegate protocol. Para sa serialization ng mga object sa XML ay madalas na ginagamit ang mga library tulad ng SimpleXML sa PHP o Jackson XML sa Java.

Pag-parse ng XML sa Android (Kotlin)

Sa Android ay inirerekomenda ang paggamit ng XmlPullParser para sa mahusay na pag-parse ng XML. Ang parser ay gumagana sa event mode: tumatawag ng next() upang lumipat sa susunod na elemento at nagbabalik ng uri ng event (START_TAG, TEXT, END_TAG). Ito ay nagpapahintulot sa pagproseso ng mga dokumento ng anumang laki na may minimal na pagkonsumo ng memorya.

import org.xmlpull.v1.XmlPullParser
import org.xmlpull.v1.XmlPullParserException
import java.io.IOException

fun parseCatalog(parser: XmlPullParser): List<Book> {
    val books = mutableListOf<Book>()
    var eventType = parser.getEventType()
    var currentBook: Book? = null

    while (eventType != XmlPullParser.END_DOCUMENT) {
        when (eventType) {
            XmlPullParser.START_TAG -> {
                when (parser.getName()) {
                    "book" -> currentBook = Book()
                    "title" -> parser.next()
                    "author" -> parser.next()
                }
            }
            XmlPullParser.TEXT -> {
                currentBook?.apply {
                    title = parser.getText() ?: ""
                }
            }
            XmlPullParser.END_TAG -> {
                if (parser.getName() == "book") {
                    currentBook?.let { books.add(it) }
                }
            }
        }
        eventType = parser.next()
    }
    return books
}

Mga Halimbawa ng XML sa Mga Application

Mga halimbawa ng paggamit ng XML ay nagpapakita ng papel nito sa mga tunay na proyekto. Bukod sa Android development, ang XML ay ginagamit para sa configuration ng compilation, paglalarawan ng data, at daloy ng dokumento. Ang kaalaman sa syntax ng XML ay kinakailangan para sa pagtatrabaho sa Maven, SOAP services, at maraming enterprise tools.

Configuration ng Maven (POM)

Ang file na pom.xml ay naglalarawan ng Maven project: dependencies, plugin, version, at compilation profile. Ang bawat dependency ay tinutukoy ng mga tag na groupId, artifactId, at version. Awtomatikong nilo-load ng Maven ang mga tinukoy na library mula sa mga repository.

<?xml version="1.0" encoding="UTF-8"?>
<project
    xmlns="http://maven.apache.org/POM/4.0.0"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
    http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0.0</version>
    <dependencies>
        <dependency>
            <groupId>com.squareup.retrofit2</groupId>
            <artifactId>retrofit</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>
</project>

XML vs JSON: Kailan Pumili ng Alin

Ang pagpili sa pagitan ng XML at JSON ay depende sa mga partikular na pangangailangan ng proyekto. Ang JSON ay angkop para sa REST API, mobile application, at configuration kung saan mahalaga ang pagkakasiksik at bilis. Ang XML ay hindi mapapalitan sa Enterprise system, daloy ng dokumento, at Android development kung saan kailangan ang mahigpit na pag-validate, namespace, at pagbabago ng data.

Ang XML ay nananalo sa mga senaryo ng pangmatagalang pag-iimbak ng dokumento. Salamat sa XSD schema, ang mga XML dokumento ay maaaring i-validate nang awtomatiko, na kritikal para sa medikal, pinansyal, at legal na sistema. Ang XSLT transformations ay nagbibigay-daan sa pagbuo ng HTML, PDF, at iba pang format mula sa isang XML source, na pinapasimple ang daloy ng dokumento.

Ang JSON naman ay naging pamantayan para sa web API at mobile application. Ang pagiging simple ng pagsasama sa JavaScript, mas maliit na sukat, at mataas na bilis ng pag-parse ay ginagawang mas pinipiling pagpipilian ang JSON para sa REST API, WebSocket messages, at configuration file. Para sa karamihan ng mga bagong proyekto, inirerekomenda na magsimula sa JSON at lumipat sa XML lamang kung may mga partikular na pangangailangan.