XML: wat het is, documentstructuur en werkingsprincipe

Wat is XML?

XML is een opmaaktaal die een set regels definieert voor het coderen van documenten in een formaat dat zowel voor mensen als machines leesbaar is. In tegenstelling tot HTML heeft XML geen vaste set tags — de ontwikkelaar maakt eigen tags die overeenkomen met de gegevensstructuur.

XML is in 1996 door het W3C-consortium ontwikkeld als een vereenvoudigde subset van SGML (Standard Generalized Markup Language). Het hoofddoel van XML is het scheiden van inhoud en gegevenspresentatie. In tegenstelling tot HTML, dat de weergave beschrijft, beschrijft XML de structuur en betekenis van gegevens.

De belangrijkste eigenschap van XML is uitbreidbaarheid. Als er nieuwe gegevenstypen in een project verschijnen, voegt de ontwikkelaar eenvoudig nieuwe tags toe zonder de bestaande structuur te wijzigen. Dit maakt XML geschikt voor langdurige gegevensopslag en uitwisseling tussen verschillende systemen.

Belangrijkste toepassingsgebieden van XML

• Android-ontwikkeling — layoutbestanden, manifest, bronnen (strings, colors, themes)
• Configuratie — Maven POM, Ant build, webconfiguraties (web.xml)
• Webservices — SOAP, XML-RPC, RSS/Atom-feeds
• Documentstromen — SVG, DocBook, Office Open XML
• Databases — SQL Server (XML type), Oracle, PostgreSQL

XML-syntaxis en -structuur

De XML-syntaxis is strenger dan die van HTML. Elke openende tag moet een overeenkomstige sluitende tag hebben, attributen staan tussen aanhalingstekens, tagnamen zijn hoofdlettergevoelig. Het document moet precies één root-element hebben dat alle andere elementen bevat.

Een XML-document kan beginnen met een declaratie die de XML-versie en codering aangeeft. Daarna volgt het root-element, waarbinnen geneste elementen, attributen, tekstinhoud en opmerkingen kunnen staan. Lege elementen worden geschreven als .

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

Regels voor welgevormde XML

Well-formed XML moet de basisregels volgen: sluitende tags zijn verplicht voor elke openende tag, nesting is strikt (kruising van tags is verboden), attribuutwaarden staan altijd tussen aanhalingstekens. Overtreding van een regel maakt het document ongeldig en het kan niet worden geparseerd.

1. Één root-element — het document heeft precies één root
2. Correcte nesting — tags mogen elkaar niet kruisen
3. Sluitende tags — verplicht voor alle elementen behalve self-closing
4. Hoofdlettergevoeligheid — <Book> en <book> zijn verschillende elementen
5. Aanhalingstekens in attributen — attribuutwaarden tussen dubbele of enkele aanhalingstekens

XML-naamruimten en -schema’s

XML-naamruimten (XML Namespaces) lossen het probleem van naamconflicten op wanneer in een document elementen uit verschillende woordenboeken worden gebruikt. De naamruimte wordt gedefinieerd door het xmlns-attribuut met een URI die het woordenboek uniek identificeert.

XML Schema (XSD) is een taal voor het beschrijven van de structuur van een XML-document. XSD bepaalt welke elementen en attributen zijn toegestaan, hun gegevenstypen, verplichting en beperkingen. Schema’s maken automatische validatie van het document mogelijk vóór verwerking, wat cruciaal is voor integratieoplossingen.

XML in mobiele ontwikkeling

XML speelt een sleutelrol in Android-ontwikkeling. Het Android-besturingssysteem gebruikt XML voor de beschrijving van de gebruikersinterface (layoutbestanden), applicatieconfiguratie (AndroidManifest.xml), bronnen (strings, kleuren, thema’s) en vectorafbeeldingen (VectorDrawable). Op iOS wordt XML minder gebruikt, voornamelijk voor Storyboard en plist-configuratiebestanden.

In Android wordt elk scherm van de applicatie beschreven door een XML-bestand met een hiërarchie van View-componenten: ConstraintLayout, LinearLayout, TextView, Button. Deze benadering scheidt de applicatielogica van de presentatie, wat onderhoud en aanpassing aan verschillende schermen vereenvoudigt. XML-bronbestanden maken lokalisatie van de applicatie mogelijk zonder codewijzigingen.

Voorbeeld van Android-layout

Een typisch layoutbestand bevat een root ConstraintLayout met geneste elementen, elk met attributen voor positie, grootte en stijl. Android compileert XML naar het binaire AXML-formaat voor prestatieoptimalisatie bij het opstarten.

<?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-parsen op mobiele platforms

XML-parsen op mobiele platforms gebeurt met twee hoofdbenaderingen: DOM (Document Object Model) laadt het hele document in het geheugen als een boom, SAX (Simple API for XML) leest het document streamgewijs en roept gebeurtenishandlers aan. DOM is handig voor kleine documenten, SAX — voor grote bestanden met geheugenbeperkingen.

Op Android zijn ingebouwde parsers beschikbaar: XmlPullParser voor streamgewijze analyse en DocumentBuilder voor de DOM-benadering. Op iOS wordt Foundation XMLParser met een delegatieprotocol gebruikt. Voor het serialiseren van objecten naar XML worden vaak bibliotheken zoals SimpleXML in PHP of Jackson XML in Java gebruikt.

XML-parsen op Android (Kotlin)

In Android wordt aangeraden XmlPullParser te gebruiken voor efficiënt XML-parsen. De parser werkt in gebeurtenismodus: roept next() aan om naar het volgende element te gaan en retourneert het gebeurtenistype (START_TAG, TEXT, END_TAG). Dit maakt het mogelijk documenten van elke grootte te verwerken met minimaal geheugengebruik.

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-voorbeelden in applicaties

Gebruiksvoorbeelden van XML tonen de rol ervan in echte projecten. Naast Android-ontwikkeling wordt XML gebruikt voor compilatieconfiguratie, gegevensbeschrijving en documentstromen. Kennis van XML-syntaxis is noodzakelijk voor het werken met Maven, SOAP-services en veel enterprise tools.

Maven-configuratie (POM)

Het bestand pom.xml beschrijft het Maven-project: afhankelijkheden, plug-ins, versies en compilatieprofielen. Elke afhankelijkheid wordt gespecificeerd met de tags groupId, artifactId en version. Maven laadt automatisch de opgegeven bibliotheken uit repositories.

<?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: wanneer wat te kiezen

De keuze tussen XML en JSON hangt af van de specifieke projectvereisten. JSON is geschikt voor REST API’s, mobiele applicaties en configuraties waar compactheid en snelheid belangrijk zijn. XML is onmisbaar in enterprise-systemen, documentstromen en Android-ontwikkeling waar strikte validatie, naamruimten en gegevenstransformatie nodig zijn.

XML wint in scenario’s met langdurige documentopslag. Dankzij XSD-schema’s kunnen XML-documenten automatisch worden gevalideerd, wat cruciaal is voor medische, financiële en juridische systemen. XSLT-transformaties maken het mogelijk HTML, PDF en andere formaten te genereren uit een enkele XML-bron, wat documentstromen vereenvoudigt.

JSON is op zijn beurt de standaard geworden voor web-API’s en mobiele applicaties. De eenvoud van integratie met JavaScript, het kleinere formaat en de hoge parsesnelheid maken JSON de voorkeurskeuze voor REST API’s, WebSocket-berichten en configuratiebestanden. Voor de meeste nieuwe projecten wordt aanbevolen met JSON te beginnen en alleen over te stappen op XML bij specifieke vereisten.