XML: cos'è, struttura del documento e principio di funzionamento

Cos'è XML?

XML è un linguaggio di markup che definisce un insieme di regole per codificare documenti in un formato leggibile sia dall'uomo che dalla macchina. A differenza di HTML, XML non ha un insieme fisso di tag — gli sviluppatori creano i propri tag che corrispondono alla struttura dei dati.

XML è stato sviluppato dal consorzio W3C nel 1996 come sottoinsieme semplificato di SGML (Standard Generalized Markup Language). L'obiettivo principale di XML è separare il contenuto dalla presentazione dei dati. A differenza di HTML, che descrive l'aspetto, XML descrive la struttura e il significato dei dati.

La proprietà chiave di XML è l'estensibilità. Se emergono nuovi tipi di dati in un progetto, lo sviluppatore aggiunge semplicemente nuovi tag senza modificare la struttura esistente. Ciò rende XML conveniente per l'archiviazione a lungo termine dei dati e lo scambio tra sistemi diversi.

Principali aree di applicazione di XML

• Sviluppo Android — file layout, manifest, risorse (strings, colors, themes)
• Configurazione — Maven POM, Ant build, configurazioni web (web.xml)
• Servizi web — SOAP, XML-RPC, feed RSS/Atom
• Flusso documentale — SVG, DocBook, Office Open XML
• Database — SQL Server (tipo XML), Oracle, PostgreSQL

Sintassi e struttura di XML

La sintassi XML è più rigorosa di quella HTML. Ogni tag di apertura deve avere un corrispondente tag di chiusura, gli attributi sono racchiusi tra virgolette e i nomi dei tag distinguono tra maiuscole e minuscole. Il documento deve avere esattamente un elemento radice che contiene tutti gli altri.

Un documento XML può iniziare con una dichiarazione che specifica la versione XML e la codifica. Segue l'elemento radice, che può contenere elementi annidati, attributi, contenuto testuale e commenti. Gli elementi vuoti si scrivono come .

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

Regole per XML ben formato

XML ben formato (Well-formed XML) deve seguire regole di base: i tag di chiusura sono obbligatori per ogni tag di apertura, l'annidamento è rigoroso (la sovrapposizione dei tag è vietata), i valori degli attributi sono sempre tra virgolette. Violare qualsiasi regola rende il documento non valido e non analizzabile.

1. Un elemento radice — il documento contiene esattamente una radice
2. Annidamento corretto — i tag non devono sovrapporsi
3. Tag di chiusura — obbligatori per tutti gli elementi tranne quelli auto-chiusi
4. Distinzione maiuscole/minuscole — <Book> e <book> sono elementi diversi
5. Virgolette negli attributi — valori degli attributi tra virgolette doppie o singole

Spazi dei nomi e schemi XML

Gli spazi dei nomi XML risolvono il problema dei conflitti di nomi quando elementi di vocabolari diversi vengono utilizzati in un documento. Uno spazio dei nomi è definito dall'attributo xmlns con un URI che identifica univocamente il vocabolario.

XML Schema (XSD) è un linguaggio per descrivere la struttura di un documento XML. XSD definisce quali elementi e attributi sono consentiti, i loro tipi di dati, obbligatorietà e vincoli. Gli schemi consentono la validazione automatica del documento prima dell'elaborazione, il che è fondamentale per le soluzioni di integrazione.

XML nello sviluppo mobile

XML gioca un ruolo chiave nello sviluppo Android. Il sistema operativo Android utilizza XML per descrivere l'interfaccia utente (file layout), la configurazione dell'applicazione (AndroidManifest.xml), le risorse (strings, colors, themes) e la grafica vettoriale (VectorDrawable). Su iOS, XML viene utilizzato meno frequentemente, principalmente per Storyboard e file di configurazione plist.

In Android, ogni schermata dell'applicazione è descritta da un file XML con una gerarchia di componenti View: ConstraintLayout, LinearLayout, TextView, Button. Questo approccio separa la logica dell'applicazione dalla presentazione, semplificando la manutenzione e l'adattamento a schermi diversi. I file XML delle risorse consentono di localizzare l'applicazione senza modificare il codice.

Esempio di layout Android

Un tipico file layout contiene un ConstraintLayout radice con elementi annidati, ciascuno con attributi di posizione, dimensione e stile. Android compila XML nel formato binario AXML per ottimizzare le prestazioni all'avvio.

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

Parsing di XML su piattaforme mobili

Il parsing XML su piattaforme mobili viene eseguito con due approcci principali: DOM (Document Object Model) carica l'intero documento in memoria come albero, SAX (Simple API for XML) legge il documento in streaming, chiamando gestori di eventi. DOM è conveniente per documenti piccoli, SAX per file grandi con limitazioni di memoria.

Android dispone di parser integrati: XmlPullParser per il parsing in streaming e DocumentBuilder per l'approccio DOM. iOS utilizza Foundation XMLParser con un protocollo delegato. Per serializzare oggetti in XML, vengono spesso utilizzate librerie come SimpleXML in PHP o Jackson XML in Java.

Parsing XML su Android (Kotlin)

Android raccomanda l'uso di XmlPullParser per un parsing XML efficiente. Il parser opera in modalità guidata dagli eventi: chiama next() per passare all'elemento successivo e restituisce il tipo di evento (START_TAG, TEXT, END_TAG). Ciò consente di elaborare documenti di qualsiasi dimensione con un consumo minimo di memoria.

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
}

Esempi di XML nelle applicazioni

Esempi di utilizzo di XML dimostrano il suo ruolo in progetti reali. Oltre allo sviluppo Android, XML viene utilizzato per la configurazione di build, descrizione dei dati e flusso documentale. Comprendere la sintassi XML è necessario per lavorare con Maven, servizi SOAP e molti strumenti aziendali.

Configurazione Maven (POM)

Il file pom.xml descrive un progetto Maven: dipendenze, plugin, versioni e profili di build. Ogni dipendenza è specificata con i tag groupId, artifactId e version. Maven scarica automaticamente le librerie specificate dai repository.

<?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: quando scegliere cosa

La scelta tra XML e JSON dipende dai requisiti specifici del progetto. JSON è adatto per API REST, applicazioni mobili e configurazioni dove compattezza e velocità sono importanti. XML è insostituibile in sistemi aziendali, flusso documentale e sviluppo Android, dove sono necessari validazione rigorosa, spazi dei nomi e trasformazione dei dati.

XML vince negli scenari di archiviazione a lungo termine dei documenti. Grazie agli schemi XSD, i documenti XML possono essere validati automaticamente, il che è fondamentale per sistemi medici, finanziari e legali. Le trasformazioni XSLT consentono di generare HTML, PDF e altri formati da una singola fonte XML, semplificando il flusso documentale.

JSON, a sua volta, è diventato lo standard per le API web e le applicazioni mobili. La facilità di integrazione con JavaScript, le dimensioni ridotte e l'elevata velocità di parsing rendono JSON la scelta preferita per API REST, messaggi WebSocket e file di configurazione. Per la maggior parte dei nuovi progetti, si consiglia di iniziare con JSON e passare a XML solo quando emergono requisiti specifici.