XML: co to jest, struktura dokumentu i zasada działania

Czym jest XML?

XML to język znaczników, który definiuje zestaw reguł kodowania dokumentów w formacie czytelnym zarówno dla człowieka, jak i maszyny. W przeciwieństwie do HTML, XML nie ma ustalonego zestawu tagów — programista tworzy własne tagi odpowiadające strukturze danych.

XML został opracowany przez konsorcjum W3C w 1996 roku jako uproszczony podzbiór SGML (Standard Generalized Markup Language). Głównym celem XML jest oddzielenie treści od prezentacji danych. W przeciwieństwie do HTML, który opisuje wygląd, XML opisuje strukturę i znaczenie danych.

Kluczową właściwością XML jest rozszerzalność. Jeśli w projekcie pojawiają się nowe typy danych, programista po prostu dodaje nowe tagi bez zmiany istniejącej struktury. To czyni XML wygodnym do długoterminowego przechowywania danych i wymiany między różnymi systemami.

Główne obszary zastosowania XML

• Programowanie na Androida — pliki layoutów, manifest, zasoby (strings, colors, themes)
• Konfiguracja — Maven POM, Ant build, konfiguracje webowe (web.xml)
• Usługi sieciowe — SOAP, XML-RPC, kanały RSS/Atom
• Obieg dokumentów — SVG, DocBook, Office Open XML
• Bazy danych — SQL Server (XML type), Oracle, PostgreSQL

Składnia i struktura XML

Składnia XML jest bardziej rygorystyczna niż HTML. Każdy tag otwierający musi mieć odpowiadający tag zamykający, atrybuty są ujęte w cudzysłów, nazwy tagów są wrażliwe na wielkość liter. Dokument musi mieć dokładnie jeden element główny zawierający wszystkie pozostałe.

Dokument XML może zaczynać się od deklaracji określającej wersję XML i kodowanie. Następnie następuje element główny, wewnątrz którego mogą znajdować się zagnieżdżone elementy, atrybuty, treść tekstowa i komentarze. Puste elementy zapisuje się jako .

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

Zasady dobrze sformowanego XML

Well-formed XML musi przestrzegać podstawowych zasad: tagi zamykające są obowiązkowe dla każdego otwierającego, zagnieżdżanie jest ścisłe (przekraczanie tagów jest zabronione), wartości atrybutów zawsze w cudzysłowiu. Naruszenie którejkolwiek zasady czyni dokument nieprawidłowym i nie nadaje się do parsowania.

1. Jeden element główny — dokument zawiera dokładnie jeden korzeń
2. Poprawne zagnieżdżanie — tagi nie mogą się przekraczać
3. Tagi zamykające — obowiązkowe dla wszystkich elementów z wyjątkiem samozamykających
4. Wrażliwość na wielkość liter — <Book> i <book> to różne elementy
5. Cudzysłów w atrybutach — wartości atrybutów w podwójnym lub pojedynczym cudzysłowie

Przestrzenie nazw i schematy XML

Przestrzenie nazw XML (XML Namespaces) rozwiązują problem konfliktu nazw, gdy w jednym dokumencie używane są elementy z różnych słowników. Przestrzeń nazw jest określana atrybutem xmlns z URI jednoznacznie identyfikującym słownik.

XML Schema (XSD) to język opisu struktury dokumentu XML. XSD określa, które elementy i atrybuty są dozwolone, ich typy danych, obowiązkowość i ograniczenia. Schematy umożliwiają automatyczną walidację dokumentu przed przetwarzaniem, co jest kluczowe dla rozwiązań integracyjnych.

XML w programowaniu mobilnym

XML odgrywa kluczową rolę w programowaniu na Androida. System operacyjny Android używa XML do opisu interfejsu użytkownika (pliki layoutów), konfiguracji aplikacji (AndroidManifest.xml), zasobów (ciągi znaków, kolory, motywy) i grafiki wektorowej (VectorDrawable). Na iOS XML jest używany rzadziej, głównie do Storyboard i plików konfiguracyjnych plist.

W Android każdy ekran aplikacji jest opisany plikiem XML z hierarchią komponentów View: ConstraintLayout, LinearLayout, TextView, Button. To podejście oddziela logikę aplikacji od widoku, upraszczając utrzymanie i adaptację do różnych ekranów. Pliki XML z zasobami umożliwiają lokalizację aplikacji bez zmiany kodu.

Przykład layoutu Androida

Typowy plik layoutu zawiera główny ConstraintLayout z zagnieżdżonymi elementami, z których każdy ma atrybuty położenia, rozmiaru i stylu. Android kompiluje XML do binarnego formatu AXML w celu optymalizacji wydajności podczas uruchamiania.

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

Parsowanie XML na platformach mobilnych

Parsowanie XML na platformach mobilnych odbywa się dwoma głównymi podejściami: DOM (Document Object Model) ładuje cały dokument do pamięci jako drzewo, SAX (Simple API for XML) czyta dokument strumieniowo, wywołując procedury obsługi zdarzeń. DOM jest wygodny dla małych dokumentów, SAX — dla dużych plików z ograniczeniami pamięci.

Na Android dostępne są wbudowane parser: XmlPullParser do analizy strumieniowej i DocumentBuilder dla podejścia DOM. Na iOS używany jest Foundation XMLParser z protokołem delegata. Do serializacji obiektów do XML często stosuje się biblioteki takie jak SimpleXML w PHP lub Jackson XML w Javie.

Parsowanie XML na Android (Kotlin)

W Android zaleca się używanie XmlPullParser do efektywnego parsowania XML. Parser działa w trybie zdarzeniowym: wywołuje next() w celu przejścia do następnego elementu i zwraca typ zdarzenia (START_TAG, TEXT, END_TAG). Pozwala to przetwarzać dokumenty dowolnego rozmiaru przy minimalnym zużyciu pamięci.

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
}

Przykłady XML w aplikacjach

Przykłady użycia XML pokazują jego rolę w rzeczywistych projektach. Oprócz programowania na Androida, XML jest używany do konfiguracji kompilacji, opisu danych i obiegu dokumentów. Znajomość składni XML jest niezbędna do pracy z Maven, usługami SOAP i wieloma narzędziami enterprise.

Konfiguracja Maven (POM)

Plik pom.xml opisuje projekt Maven: zależności, wtyczki, wersje i profile kompilacji. Każda zależność jest określana tagami groupId, artifactId i version. Maven automatycznie pobiera wskazane biblioteki z repozytoriów.

<?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: kiedy co wybrać

Wybór między XML a JSON zależy od konkretnych wymagań projektu. JSON nadaje się do REST API, aplikacji mobilnych i konfiguracji, gdzie ważne są zwartość i szybkość. XML jest niezastąpiony w systemach Enterprise, obiegu dokumentów i programowaniu na Androida, gdzie potrzebna jest ścisła walidacja, przestrzenie nazw i transformacja danych.

XML wygrywa w scenariuszach z długoterminowym przechowywaniem dokumentów. Dzięki schematom XSD dokumenty XML można walidować automatycznie, co jest kluczowe dla systemów medycznych, finansowych i prawnych. Transformacje XSLT umożliwiają generowanie HTML, PDF i innych formatów z jednego źródła XML, co upraszcza obieg dokumentów.

Z kolei JSON stał się standardem dla web API i aplikacji mobilnych. Prostota integracji z JavaScript, mniejszy rozmiar i wysoka szybkość parsowania czynią JSON preferowanym wyborem dla REST API, komunikatów WebSocket i plików konfiguracyjnych. W przypadku większości nowych projektów zaleca się zaczynanie od JSON i przejście na XML tylko w razie pojawienia się specyficznych wymagań.