XML: o que é, estrutura do documento e princípio de funcionamento

O que é XML?

XML é uma linguagem de marcação que define um conjunto de regras para codificar documentos num formato legível tanto por humanos como por máquinas. Ao contrário do HTML, o XML não tem um conjunto fixo de tags — os programadores criam as suas próprias tags que correspondem à estrutura de dados.

O XML foi desenvolvido pelo consórcio W3C em 1996 como um subconjunto simplificado do SGML (Standard Generalized Markup Language). O principal objetivo do XML é separar o conteúdo da apresentação de dados. Ao contrário do HTML, que descreve a aparência, o XML descreve a estrutura e o significado dos dados.

A propriedade chave do XML é a extensibilidade. Se surgirem novos tipos de dados num projeto, o programador simplesmente adiciona novas tags sem alterar a estrutura existente. Isto torna o XML conveniente para armazenamento de dados a longo prazo e troca entre diferentes sistemas.

Principais áreas de aplicação do XML

• Desenvolvimento Android — ficheiros layout, manifesto, recursos (strings, colors, themes)
• Configuração — Maven POM, Ant build, configurações web (web.xml)
• Serviços web — SOAP, XML-RPC, feeds RSS/Atom
• Fluxo documental — SVG, DocBook, Office Open XML
• Bases de dados — SQL Server (tipo XML), Oracle, PostgreSQL

Sintaxe e estrutura do XML

A sintaxe XML é mais rigorosa que a do HTML. Cada tag de abertura deve ter uma tag de fecho correspondente, os atributos são colocados entre aspas e os nomes das tags distinguem maiúsculas de minúsculas. O documento deve ter exatamente um elemento raiz que contém todos os outros.

Um documento XML pode começar com uma declaração a indicar a versão do XML e a codificação. Segue-se o elemento raiz, que pode conter elementos aninhados, atributos, conteúdo textual e comentários. Elementos vazios são escritos como .

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

Regras para XML bem formado

XML bem formado deve seguir regras básicas: as tags de fecho são obrigatórias para cada tag de abertura, o aninhamento é rigoroso (sobreposição de tags é proibida), os valores de atributos estão sempre entre aspas. Violar qualquer regra torna o documento inválido e não analisável.

1. Um elemento raiz — o documento contém exatamente uma raiz
2. Aninhamento correto — as tags não devem sobrepor-se
3. Tags de fecho — obrigatórias para todos os elementos exceto os autofechados
4. Distinção maiúsculas/minúsculas — <Book> e <book> são elementos diferentes
5. Aspas em atributos — valores de atributos entre aspas duplas ou simples

Espaços de nomes e esquemas XML

Os espaços de nomes XML resolvem o problema de conflitos de nomes quando são utilizados elementos de diferentes vocabulários num documento. Um espaço de nomes é definido pelo atributo xmlns com um URI que identifica exclusivamente o vocabulário.

XML Schema (XSD) é uma linguagem para descrever a estrutura de um documento XML. O XSD define quais elementos e atributos são permitidos, os seus tipos de dados, obrigatoriedade e restrições. Os esquemas permitem a validação automática do documento antes do processamento, o que é crítico para soluções de integração.

XML no desenvolvimento móvel

XML desempenha um papel fundamental no desenvolvimento Android. O sistema operativo Android utiliza XML para descrever a interface do utilizador (ficheiros layout), configuração da aplicação (AndroidManifest.xml), recursos (strings, colors, themes) e gráficos vetoriais (VectorDrawable). No iOS, o XML é usado com menos frequência, principalmente para Storyboard e ficheiros de configuração plist.

No Android, cada ecrã da aplicação é descrito por um ficheiro XML com uma hierarquia de componentes View: ConstraintLayout, LinearLayout, TextView, Button. Esta abordagem separa a lógica da aplicação da apresentação, simplificando a manutenção e adaptação para diferentes ecrãs. Os ficheiros XML de recursos permitem localizar a aplicação sem alterar código.

Exemplo de layout Android

Um ficheiro layout típico contém um ConstraintLayout raiz com elementos aninhados, cada um com atributos de posição, tamanho e estilo. O Android compila XML para o formato binário AXML para otimizar o desempenho no arranque.

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

Análise de XML em plataformas móveis

A análise de XML em plataformas móveis é feita através de duas abordagens principais: DOM (Document Object Model) carrega todo o documento na memória como uma árvore, SAX (Simple API for XML) lê o documento em streaming, chamando manipuladores de eventos. O DOM é conveniente para documentos pequenos, o SAX para ficheiros grandes com limitações de memória.

O Android tem analisadores incorporados: XmlPullParser para análise em streaming e DocumentBuilder para a abordagem DOM. O iOS utiliza Foundation XMLParser com um protocolo delegado. Para serializar objetos para XML, são frequentemente usadas bibliotecas como SimpleXML em PHP ou Jackson XML em Java.

Análise de XML no Android (Kotlin)

O Android recomenda usar XmlPullParser para uma análise eficiente de XML. O analisador opera em modo orientado a eventos: chama next() para passar ao próximo elemento e devolve o tipo de evento (START_TAG, TEXT, END_TAG). Isto permite processar documentos de qualquer tamanho com consumo mínimo de memória.

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
}

Exemplos de XML em aplicações

Exemplos de uso do XML demonstram o seu papel em projetos reais. Além do desenvolvimento Android, o XML é usado para configuração de builds, descrição de dados e fluxo documental. Compreender a sintaxe XML é necessário para trabalhar com Maven, serviços SOAP e muitas ferramentas empresariais.

Configuração Maven (POM)

O ficheiro pom.xml descreve um projeto Maven: dependências, plugins, versões e perfis de build. Cada dependência é especificada com as tags groupId, artifactId e version. O Maven descarrega automaticamente as bibliotecas especificadas dos repositórios.

<?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 escolher cada um

A escolha entre XML e JSON depende dos requisitos específicos do projeto. O JSON é adequado para REST API, aplicações móveis e configurações onde a compacidade e velocidade são importantes. O XML é insubstituível em sistemas empresariais, fluxo documental e desenvolvimento Android, onde são necessárias validação rigorosa, espaços de nomes e transformação de dados.

O XML vence em cenários de armazenamento de documentos a longo prazo. Graças aos esquemas XSD, os documentos XML podem ser validados automaticamente, o que é crítico para sistemas médicos, financeiros e legais. As transformações XSLT permitem gerar HTML, PDF e outros formatos a partir de uma única fonte XML, simplificando o fluxo documental.

O JSON, por sua vez, tornou-se o padrão para web APIs e aplicações móveis. A facilidade de integração com JavaScript, o tamanho menor e a alta velocidade de análise fazem do JSON a escolha preferida para REST API, mensagens WebSocket e ficheiros de configuração. Para a maioria dos novos projetos, recomenda-se começar com JSON e mudar para XML apenas quando surgirem requisitos específicos.