XML: mi ez, a dokumentum felépítése és működési elve

Mi az XML?

XML egy jelölőnyelv, amely szabályokat határoz meg dokumentumok kódolására ember és gép által olvasható formátumban. A HTML-lel ellentétben az XML-nek nincs rögzített címkekészlete — a fejlesztő saját, az adatszerkezetnek megfelelő címkéket hoz létre.

Az XML-t a W3C konzorcium fejlesztette ki 1996-ban az SGML (Standard Generalized Markup Language) egyszerűsített részhalmazaként. Az XML fő célja a tartalom és az adatok megjelenítésének szétválasztása. A HTML-lel ellentétben, amely a megjelenést írja le, az XML az adatok szerkezetét és jelentését írja le.

Az XML kulcsfontosságú tulajdonsága a bővíthetőség. Ha új adattípusok jelennek meg a projektben, a fejlesztő egyszerűen új címkéket ad hozzá a meglévő szerkezet megváltoztatása nélkül. Ez teszi az XML-t alkalmassá az adatok hosszú távú tárolására és különböző rendszerek közötti cseréjére.

Az XML fő alkalmazási területei

• Android-fejlesztés — elrendezés fájlok, manifest, erőforrások (strings, colors, themes)
• Konfiguráció — Maven POM, Ant build, webes konfigurációk (web.xml)
• Webszolgáltatások — SOAP, XML-RPC, RSS/Atom hírcsatornák
• Dokumentumforgalom — SVG, DocBook, Office Open XML
• Adatbázisok — SQL Server (XML type), Oracle, PostgreSQL

XML szintaxis és szerkezet

Az XML szintaxis szigorúbb, mint a HTML-é. Minden nyitó címkének rendelkeznie kell egy megfelelő záró címkével, az attribútumok idézőjelek között vannak, a címkenevek kis- és nagybetűérzékenyek. A dokumentumnak pontosan egy gyökérelemmel kell rendelkeznie, amely tartalmazza az összes többi elemet.

Az XML dokumentum kezdődhet egy deklarációval, amely megadja az XML verzióját és kódolását. Ezután következik a gyökérelem, amelyen belül lehetnek beágyazott elemek, attribútumok, szöveges tartalom és megjegyzések. Az üres elemeket formában írjuk.

<?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>

A jól formázott XML szabályai

A well-formed XML alapvető szabályokat kell betartania: a záró címkék kötelezőek minden nyitó címkéhez, a beágyazás szigorú (a címkék kereszteződése tilos), az attribútumértékek mindig idézőjelek között vannak. Bármely szabály megsértése érvénytelenné teszi a dokumentumot, és nem elemezhető.

1. Egy gyökérelem — a dokumentumnak pontosan egy gyökere van
2. Helyes beágyazás — a címkék nem kereszteződhetnek
3. Záró címkék — kötelezőek minden elemnél, kivéve az önzárókat
4. Kis- és nagybetűérzékenység — a <Book> és <book> különböző elemek
5. Idézőjelek az attribútumokban — attribútumértékek dupla vagy szimpla idézőjelek között

XML névterek és sémák

Az XML névterek (XML Namespaces) megoldják a névütközések problémáját, amikor egy dokumentumban különböző szótárakból származó elemeket használnak. A névteret az xmlns attribútum határozza meg egy URI-val, amely egyedileg azonosítja a szótárat.

XML Schema (XSD) egy nyelv az XML-dokumentum szerkezetének leírására. Az XSD meghatározza, hogy mely elemek és attribútumok megengedettek, azok adattípusait, kötelezőségét és korlátait. A sémák lehetővé teszik a dokumentum automatikus érvényesítését a feldolgozás előtt, ami kritikus fontosságú az integrációs megoldásoknál.

XML a mobilfejlesztésben

XML kulcsszerepet játszik az Android-fejlesztésben. Az Android operációs rendszer XML-t használ a felhasználói felület leírására (elrendezés fájlok), az alkalmazás konfigurációjára (AndroidManifest.xml), erőforrásokra (karakterláncok, színek, témák) és vektorgrafikára (VectorDrawable). iOS-en az XML ritkábban használatos, főként Storyboard-hoz és plist konfigurációs fájlokhoz.

Androidban az alkalmazás minden képernyőjét egy XML-fájl írja le a View-komponensek hierarchiájával: ConstraintLayout, LinearLayout, TextView, Button. Ez a megközelítés elválasztja az alkalmazáslogikát a megjelenítéstől, egyszerűsítve a karbantartást és a különböző képernyőkhöz való alkalmazkodást. Az erőforrás XML-fájlok lehetővé teszik az alkalmazás lokalizációját a kód módosítása nélkül.

Android elrendezés példa

Egy tipikus elrendezés fájl tartalmaz egy gyökér ConstraintLayout-ot beágyazott elemekkel, amelyek mindegyike rendelkezik pozíció, méret és stílus attribútumokkal. Az Android bináris AXML formátumba fordítja az XML-t a teljesítmény optimalizálása érdekében indításkor.

<?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>

XML elemzés mobil platformokon

Az XML elemzése mobil platformokon két fő megközelítéssel történik: a DOM (Document Object Model) a teljes dokumentumot fába tölti a memóriában, a SAX (Simple API for XML) adatfolyam-szerűen olvassa a dokumentumot, eseménykezelőket hívva. A DOM kis dokumentumokhoz kényelmes, a SAX — nagy fájlokhoz memória korlátozásokkal.

Androidon beépített elemzők érhetők el: XmlPullParser adatfolyam-elemzéshez és DocumentBuilder a DOM megközelítéshez. iOS-en a Foundation XMLParser delegált protokollal használatos. Objektumok XML-be sorosításához gyakran használnak olyan könyvtárakat, mint a SimpleXML PHP-ban vagy a Jackson XML Javában.

XML elemzés Androidon (Kotlin)

Androidon ajánlott az XmlPullParser használata hatékony XML elemzéshez. Az elemző esemény módban működik: meghívja a next()-et a következő elemre lépéshez, és visszaadja az esemény típusát (START_TAG, TEXT, END_TAG). Ez lehetővé teszi bármilyen méretű dokumentum feldolgozását minimális memóriafelhasználással.

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
}

XML példák alkalmazásokban

Használati példák XML mutatják a szerepét valós projektekben. Az Android-fejlesztés mellett az XML-t használják fordítási konfigurációhoz, adatleíráshoz és dokumentumforgalomhoz. Az XML szintaxisának ismerete szükséges a Maven, SOAP szolgáltatások és számos enterprise eszköz használatához.

Maven konfiguráció (POM)

A pom.xml fájl írja le a Maven projektet: függőségek, beépülő modulok, verziók és fordítási profilok. Minden függőséget a groupId, artifactId és version címkék határoznak meg. A Maven automatikusan betölti a megadott könyvtárakat a tárolókból.

<?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: mikor mit válasszunk

A választás XML és JSON között a projekt konkrét követelményeitől függ. A JSON alkalmas REST API-khoz, mobilalkalmazásokhoz és konfigurációkhoz, ahol fontos a tömörség és a sebesség. Az XML pótolhatatlan a vállalati rendszerekben, dokumentumforgalomban és Android-fejlesztésben, ahol szigorú érvényesítésre, névterekre és adatátalakításra van szükség.

Az XML a hosszú távú dokumentumtárolás forgatókönyveiben nyer. Az XSD sémáknak köszönhetően az XML dokumentumok automatikusan érvényesíthetők, ami kritikus az orvosi, pénzügyi és jogi rendszerekben. Az XSLT transzformációk lehetővé teszik HTML, PDF és más formátumok generálását egyetlen XML forrásból, egyszerűsítve a dokumentumforgalmat.

A JSON viszont a web API-k és mobilalkalmazások szabványává vált. A JavaScript egyszerű integrációja, kisebb mérete és nagy elemzési sebessége a JSON-t preferált választássá teszik REST API-khoz, WebSocket üzenetekhez és konfigurációs fájlokhoz. A legtöbb új projektnél ajánlott JSON-nal kezdeni, és csak speciális követelmények megjelenésekor áttérni XML-re.