XML: vad är det, dokumentstruktur och arbetsprincip

Vad är XML?

XML är ett märkspråk som definierar en uppsättning regler för att koda dokument i ett format som är läsbart för både människor och maskiner. Till skillnad från HTML har XML ingen fast uppsättning taggar — utvecklaren skapar egna taggar som motsvarar datastrukturen.

XML utvecklades av W3C-konsortiet 1996 som en förenklad delmängd av SGML (Standard Generalized Markup Language). Huvudsyftet med XML är att separera innehåll och datapresentation. Till skillnad från HTML som beskriver utseendet, beskriver XML strukturen och innebörden av data.

Den viktigaste egenskapen hos XML är utökningsbarhet. Om nya datatyper dyker upp i projektet lägger utvecklaren helt enkelt till nya taggar utan att ändra den befintliga strukturen. Detta gör XML lämpligt för långtidslagring av data och utbyte mellan olika system.

Huvudområden för XML-tillämpning

• Android-utveckling — layoutfiler, manifest, resurser (strings, colors, themes)
• Konfiguration — Maven POM, Ant build, webbkonfigurationer (web.xml)
• Webbtjänster — SOAP, XML-RPC, RSS/Atom-flöden
• Dokumentflöde — SVG, DocBook, Office Open XML
• Databaser — SQL Server (XML type), Oracle, PostgreSQL

XML-syntax och -struktur

XML-syntaxen är strängare än HTML. Varje öppnande tagg måste ha en motsvarande stängande tagg, attribut omges av citattecken, taggnamn är skiftlägeskänsliga. Dokumentet måste ha exakt ett rotelement som innehåller alla andra element.

Ett XML-dokument kan börja med en deklaration som anger XML-version och kodning. Därefter följer rotelementet, inom vilket det kan finnas nästlade element, attribut, textinnehåll och kommentarer. Tomma element skrivs som .

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

Regler för välformad XML

Well-formed XML måste följa grundläggande regler: stängande taggar är obligatoriska för varje öppnande tagg, nästling är strikt (korsning av taggar är förbjuden), attributvärden är alltid inom citattecken. Brott mot någon regel gör dokumentet ogiltigt och det kan inte tolkas.

1. Ett rotelement — dokumentet har exakt en rot
2. Korrekt nästling — taggar får inte korsas
3. Stängande taggar — obligatoriska för alla element utom självstängande
4. Skiftlägeskänslighet — <Book> och <book> är olika element
5. Citattecken i attribut — attributvärden inom dubbla eller enkla citattecken

XML-namnrymder och -scheman

XML-namnrymder (XML Namespaces) löser problemet med namnkonflikter när element från olika ordlistor används i ett dokument. Namnrymden definieras av attributet xmlns med en URI som unikt identifierar ordlistan.

XML Schema (XSD) är ett språk för att beskriva strukturen hos ett XML-dokument. XSD anger vilka element och attribut som är tillåtna, deras datatyper, obligatoriskhet och begränsningar. Scheman möjliggör automatisk validering av dokumentet före bearbetning, vilket är avgörande för integrationslösningar.

XML i mobil utveckling

XML spelar en nyckelroll i Android-utveckling. Android-operativsystemet använder XML för att beskriva användargränssnittet (layoutfiler), applikationskonfiguration (AndroidManifest.xml), resurser (strängar, färger, teman) och vektorgrafik (VectorDrawable). På iOS används XML mer sällan, främst för Storyboard och plist-konfigurationsfiler.

I Android beskrivs varje skärm i applikationen av en XML-fil med en hierarki av View-komponenter: ConstraintLayout, LinearLayout, TextView, Button. Detta tillvägagångssätt separerar applikationslogik från presentation, vilket förenklar underhåll och anpassning till olika skärmar. XML-resursfiler möjliggör lokalisering av applikationen utan kodändringar.

Exempel på Android-layout

En typisk layoutfil innehåller ett rot-ConstraintLayout med nästlade element, var och en med attribut för position, storlek och stil. Android kompilerar XML till binärt AXML-format för att optimera prestanda vid 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>

Tolkning av XML på mobila plattformar

Tolkning av XML på mobila plattformar görs med två huvudmetoder: DOM (Document Object Model) laddar hela dokumentet i minnet som ett träd, SAX (Simple API for XML) läser dokumentet strömmande och anropar händelsehanterare. DOM är bekvämt för små dokument, SAX — för stora filer med minnesbegränsningar.

På Android finns inbyggda parser: XmlPullParser för strömmande analys och DocumentBuilder för DOM-metoden. På iOS används Foundation XMLParser med delegatprotokoll. För serialisering av objekt till XML används ofta bibliotek som SimpleXML i PHP eller Jackson XML i Java.

Tolkning av XML på Android (Kotlin)

I Android rekommenderas att använda XmlPullParser för effektiv tolkning av XML. Parser fungerar i händelseläge: anropar next() för att gå till nästa element och returnerar händelsetypen (START_TAG, TEXT, END_TAG). Detta möjliggör bearbetning av dokument av valfri storlek med minimal minnesförbrukning.

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-exempel i applikationer

Användningsexempel av XML visar dess roll i verkliga projekt. Förutom Android-utveckling används XML för kompileringskonfiguration, databeskrivning och dokumentflöde. Kännedom om XML-syntax är nödvändig för att arbeta med Maven, SOAP-tjänster och många enterprise-verktyg.

Maven-konfiguration (POM)

Filen pom.xml beskriver Maven-projektet: beroenden, plugin-program, versioner och kompileringsprofiler. Varje beroende anges med taggarna groupId, artifactId och version. Maven laddar automatiskt de angivna biblioteken från arkiv.

<?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: när ska man välja vad

Valet mellan XML och JSON beror på projektets specifika krav. JSON är lämpligt för REST API, mobilapplikationer och konfigurationer där kompakthet och hastighet är viktiga. XML är oersättligt i enterprise-system, dokumentflöde och Android-utveckling där strikt validering, namnrymder och datatransformation behövs.

XML vinner i scenarier med långtidslagring av dokument. Tack vare XSD-scheman kan XML-dokument valideras automatiskt, vilket är avgörande för medicinska, finansiella och juridiska system. XSLT-transformationer möjliggör generering av HTML, PDF och andra format från en enda XML-källa, vilket förenklar dokumentflödet.

JSON har å sin sida blivit standard för webb-API och mobilapplikationer. Enkelheten i integration med JavaScript, mindre storlek och hög tolkningshastighet gör JSON till förstahandsvalet för REST API, WebSocket-meddelanden och konfigurationsfiler. För de flesta nya projekt rekommenderas att börja med JSON och bara gå över till XML när specifika krav uppstår.