XML: Was es ist, Dokumentenstruktur und Funktionsprinzip

Was ist XML?

XML ist eine Auszeichnungssprache, die eine Reihe von Regeln zum Codieren von Dokumenten in einem sowohl für Menschen als auch für Maschinen lesbaren Format definiert. Im Gegensatz zu HTML hat XML keinen festen Satz von Tags — Entwickler erstellen eigene Tags, die der Datenstruktur entsprechen.

XML wurde 1996 vom W3C-Konsortium als vereinfachte Teilmenge von SGML (Standard Generalized Markup Language) entwickelt. Das Hauptziel von XML ist die Trennung von Inhalt und Datenpräsentation. Im Gegensatz zu HTML, das das Aussehen beschreibt, beschreibt XML die Struktur und Bedeutung von Daten.

Die wichtigste Eigenschaft von XML ist die Erweiterbarkeit. Wenn in einem Projekt neue Datentypen auftauchen, fügt der Entwickler einfach neue Tags hinzu, ohne die vorhandene Struktur zu ändern. Dies macht XML praktisch für die langfristige Datenspeicherung und den Austausch zwischen verschiedenen Systemen.

Hauptanwendungsbereiche von XML

• Android-Entwicklung — Layout-Dateien, Manifest, Ressourcen (strings, colors, themes)
• Konfiguration — Maven POM, Ant Build, Web-Konfigurationen (web.xml)
• Webdienste — SOAP, XML-RPC, RSS/Atom-Feeds
• Dokumenten-Workflow — SVG, DocBook, Office Open XML
• Datenbanken — SQL Server (XML-Typ), Oracle, PostgreSQL

XML-Syntax und -Struktur

Die XML-Syntax ist strenger als die von HTML. Jedes öffnende Tag muss ein entsprechendes schließendes Tag haben, Attribute werden in Anführungszeichen gesetzt und Tag-Namen unterscheiden zwischen Groß- und Kleinschreibung. Das Dokument muss genau ein Wurzelelement haben, das alle anderen enthält.

Ein XML-Dokument kann mit einer Deklaration beginnen, die die XML-Version und Kodierung angibt. Darauf folgt das Wurzelelement, das verschachtelte Elemente, Attribute, Textinhalte und Kommentare enthalten kann. Leere Elemente werden als geschrieben.

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

Regeln für wohlgeformtes XML

Wohlgeformtes (Well-formed) XML muss grundlegende Regeln befolgen: schließende Tags sind für jedes öffnende Tag obligatorisch, die Verschachtelung ist streng (Tag-Überlappung ist verboten), Attributwerte stehen immer in Anführungszeichen. Die Verletzung einer Regel macht das Dokument ungültig und nicht parsbar.

1. Ein Wurzelelement — das Dokument enthält genau eine Wurzel
2. Korrekte Verschachtelung — Tags dürfen sich nicht überlappen
3. Schließende Tags — obligatorisch für alle Elemente außer selbstschließenden
4. Groß-/Kleinschreibung — <Book> und <book> sind unterschiedliche Elemente
5. Anführungszeichen in Attributen — Attributwerte in doppelten oder einfachen Anführungszeichen

XML-Namespaces und -Schemas

XML-Namespaces lösen das Problem von Namenskonflikten, wenn Elemente aus verschiedenen Vokabularen in einem Dokument verwendet werden. Ein Namespace wird durch das xmlns-Attribut mit einer URI definiert, die das Vokabular eindeutig identifiziert.

XML Schema (XSD) ist eine Sprache zur Beschreibung der Struktur eines XML-Dokuments. XSD definiert, welche Elemente und Attribute erlaubt sind, ihre Datentypen, Obligatorik und Einschränkungen. Schemas ermöglichen die automatische Validierung des Dokuments vor der Verarbeitung, was für Integrationslösungen entscheidend ist.

XML in der mobilen Entwicklung

XML spielt eine Schlüsselrolle in der Android-Entwicklung. Das Android-Betriebssystem verwendet XML zur Beschreibung der Benutzeroberfläche (Layout-Dateien), der Anwendungskonfiguration (AndroidManifest.xml), von Ressourcen (strings, colors, themes) und Vektorgrafiken (VectorDrawable). Unter iOS wird XML seltener verwendet, hauptsächlich für Storyboard- und Konfigurations-plist-Dateien.

In Android wird jeder Anwendungsbildschirm durch eine XML-Datei mit einer Hierarchie von View-Komponenten beschrieben: ConstraintLayout, LinearLayout, TextView, Button. Dieser Ansatz trennt die Anwendungslogik von der Präsentation und vereinfacht die Wartung und Anpassung an verschiedene Bildschirme. Ressourcen-XML-Dateien ermöglichen die Lokalisierung der Anwendung ohne Codeänderungen.

Beispiel für ein Android-Layout

Eine typische Layout-Datei enthält ein Wurzel-ConstraintLayout mit verschachtelten Elementen, die jeweils Attribute für Position, Größe und Stil haben. Android kompiliert XML in das binäre AXML-Format zur Leistungsoptimierung beim Start.

<?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-Parsing auf mobilen Plattformen

XML-Parsing auf mobilen Plattformen erfolgt mit zwei Hauptansätzen: DOM (Document Object Model) lädt das gesamte Dokument als Baum in den Speicher, SAX (Simple API for XML) liest das Dokument streaming-artig und ruft Ereignis-Handler auf. DOM ist praktisch für kleine Dokumente, SAX für große Dateien mit Speicherbeschränkungen.

Android verfügt über integrierte Parser: XmlPullParser für das Streaming-Parsing und DocumentBuilder für den DOM-Ansatz. iOS verwendet Foundation XMLParser mit einem Delegaten-Protokoll. Zur Serialisierung von Objekten in XML werden häufig Bibliotheken wie SimpleXML in PHP oder Jackson XML in Java verwendet.

XML-Parsing auf Android (Kotlin)

Android empfiehlt die Verwendung von XmlPullParser für effizientes XML-Parsing. Der Parser arbeitet im ereignisgesteuerten Modus: Er ruft next() auf, um zum nächsten Element zu gelangen, und gibt den Ereignistyp zurück (START_TAG, TEXT, END_TAG). Dies ermöglicht die Verarbeitung von Dokumenten jeder Größe mit minimalem Speicherverbrauch.

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-Beispiele in Anwendungen

Anwendungsbeispiele von XML zeigen seine Rolle in realen Projekten. Neben der Android-Entwicklung wird XML für Build-Konfiguration, Datenbeschreibung und Dokumenten-Workflow verwendet. Das Verständnis der XML-Syntax ist für die Arbeit mit Maven, SOAP-Diensten und vielen Enterprise-Tools erforderlich.

Maven-Konfiguration (POM)

Die pom.xml-Datei beschreibt ein Maven-Projekt: Abhängigkeiten, Plugins, Versionen und Build-Profile. Jede Abhängigkeit wird mit den Tags groupId, artifactId und version angegeben. Maven lädt die angegebenen Bibliotheken automatisch aus den Repositories herunter.

<?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: Wann man was wählt

Die Wahl zwischen XML und JSON hängt von den spezifischen Anforderungen des Projekts ab. JSON eignet sich für REST-APIs, mobile Anwendungen und Konfigurationen, bei denen Kompaktheit und Geschwindigkeit wichtig sind. XML ist in Enterprise-Systemen, Dokumenten-Workflow und der Android-Entwicklung unverzichtbar, wo strenge Validierung, Namespaces und Datentransformation benötigt werden.

XML punktet in Szenarien mit langfristiger Dokumentspeicherung. Dank XSD-Schemas können XML-Dokumente automatisch validiert werden, was für medizinische, finanzielle und rechtliche Systeme entscheidend ist. XSLT-Transformationen ermöglichen die Generierung von HTML, PDF und anderen Formaten aus einer einzigen XML-Quelle, was den Dokumenten-Workflow vereinfacht.

JSON wiederum ist zum Standard für Web-APIs und mobile Anwendungen geworden. Die einfache Integration mit JavaScript, die geringere Größe und die hohe Parsing-Geschwindigkeit machen JSON zur bevorzugten Wahl für REST-APIs, WebSocket-Nachrichten und Konfigurationsdateien. Für die meisten neuen Projekte wird empfohlen, mit JSON zu beginnen und nur dann auf XML umzusteigen, wenn spezifische Anforderungen auftreten.