Visão Geral do Processamento XML em Java

XML (Extensible Markup Language) é um formato de texto para representar dados estruturados e hierárquicos usando tags aninhadas. Muito antes de JSON dominar as APIs web, XML era o padrão para arquivos de configuração, formatos de documentos e troca de mensagens — e ainda está em todo lugar, desde arquivos Maven pom.xml até serviços SOAP e documentos do Office.

Java possui suporte XML rico e integrado no JDK: você não precisa de nenhuma biblioteca externa para ler ou escrever XML. Os pacotes javax.xml.parsers e org.w3c.dom, além de org.xml.sax e javax.xml.stream, oferecem três modelos de análise distintos. Este capítulo mapeia o que é XML, qual modelo de análise usar e como XML se compara ao JSON — para que o restante desta parte (DOM, SAX e JAXB) seja construído sobre uma base sólida.

Esta página aborda:

Como é um documento XML e os termos necessários (elemento, atributo, raiz, bem-formado).
Os três modelos de análise do JDK — DOM, SAX e StAX — e quando cada um é adequado.
Um exemplo DOM executável usando apenas classes do JDK.
Como XML e JSON diferem, para que você possa escolher entre eles.

Como é o XML

Um documento XML é uma árvore de elementos. Cada elemento tem um nome, atributos opcionais e texto ou elementos filhos aninhados. Sempre há exatamente um elemento raiz envolvendo tudo.

<?xml version="1.0" encoding="UTF-8"?>
<catalog>
  <book id="1" lang="en">
    <title>Effective Java</title>
    <price>45.00</price>
  </book>
</catalog>

Aqui <catalog> é a raiz, <book> é um elemento filho com dois atributos (id e lang), e <title> e <price> carregam texto. A declaração XML na primeira linha indica a versão e a codificação de caracteres. Um XML bem-formado exige que cada tag de abertura seja fechada e corretamente aninhada.

Os três modelos de análise

O JDK oferece três formas de ler XML, cada uma com uma compensação diferente entre conveniência e memória. Escolher o correto é a decisão mais importante que você tomará ao trabalhar com XML.

Modelo	Estilo	Memória	Melhor para
DOM	Carrega toda a árvore na memória	Alta	Acesso aleatório, edição, docs pequenos/médios
SAX	Empurra eventos durante a leitura (callbacks)	Baixa	Docs grandes, streaming somente leitura
StAX	Puxa eventos sob demanda (cursor)	Baixa	Docs grandes, com fluxo de controle mais simples

DOM constrói uma árvore completa em memória que você pode navegar livremente e modificar. SAX dispara callbacks (startElement, characters, endElement) durante a leitura, nunca mantendo o documento inteiro. StAX também é streaming, mas permite que seu código puxe o próximo evento quando estiver pronto, o que geralmente é mais fácil de acompanhar do que os callbacks do SAX.

DOM: a árvore em memória

DOM é o modelo mais conveniente quando os documentos são pequenos o suficiente para caber na memória. Você analisa uma vez e percorre ou consulta a árvore quantas vezes quiser.

import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
Document doc = factory.newDocumentBuilder().parse("catalog.xml");

NodeList books = doc.getElementsByTagName("book");
System.out.println("Books: " + books.getLength());

getElementsByTagName retorna uma NodeList ao vivo; você a indexa e converte os nós para Element para ler atributos e texto filho. O capítulo dedicado ao analisador DOM XML do Java percorre a navegação, modificação e escrita da árvore por completo.

Aviso

Por padrão, o analisador do JDK resolve entidades externas, o que expõe você a ataques XXE (XML External Entity) ao analisar entradas não confiáveis. Para código de produção que lê XML de fora do seu controle, desabilite DTDs com factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true); antes de criar o builder.

SAX e StAX: streaming

Quando um documento é grande demais para caber na memória, você faz streaming. SAX empurra eventos para um handler que você fornece:

import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.Attributes;

DefaultHandler handler = new DefaultHandler() {
    public void startElement(String uri, String local, String name, Attributes a) {
        System.out.println("Start: " + name);
    }
};
SAXParserFactory.newInstance().newSAXParser()
    .parse("catalog.xml", handler);

StAX oferece um cursor que você avança manualmente, o que muitos acham mais claro:

import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamConstants;
import java.io.FileReader;

XMLStreamReader r = XMLInputFactory.newInstance()
    .createXMLStreamReader(new FileReader("catalog.xml"));
while (r.hasNext()) {
    if (r.next() == XMLStreamConstants.START_ELEMENT) {
        System.out.println("Start: " + r.getLocalName());
    }
}

Veja o capítulo do analisador SAX XML do Java para um passo a passo completo do handler de eventos. Se você preferir pular a análise manual de nós e mapear XML diretamente para objetos Java, JAXB faz o binding de elementos para classes anotadas.

Um exemplo autossuficiente

O exemplo executável abaixo usa apenas classes do JDK — sem Jackson ou JAXB. Ele analisa um catálogo XML a partir de uma string em memória com DOM, percorre os elementos <book>, lê atributos e texto filho, e soma os preços.

java— editable, runs on the server

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import java.io.ByteArrayInputStream;
import java.nio.charset.StandardCharsets;

public class XmlIntroDemo {
    public static void main(String[] args) throws Exception {
        String xml = """
            <?xml version=\"1.0\" encoding=\"UTF-8\"?>
            <catalog>
              <book id=\"1\" lang=\"en\">
                <title>Effective Java</title>
                <price>45.00</price>
              </book>
              <book id=\"2\" lang=\"en\">
                <title>Clean Code</title>
                <price>38.50</price>
              </book>
            </catalog>
            """
;

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.parse(
            new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8)));
        doc.getDocumentElement().normalize();

Element root = doc.getDocumentElement();
        System.out.println("Root element: " + root.getNodeName());

NodeList books = doc.getElementsByTagName("book");
        System.out.println("Books found: " + books.getLength());

double total = 0;
        for (int i = 0; i < books.getLength(); i++) {
            Element book = (Element) books.item(i);
            String id = book.getAttribute("id");
            String title = book.getElementsByTagName("title")
                               .item(0).getTextContent();
            double price = Double.parseDouble(
                book.getElementsByTagName("price").item(0).getTextContent());
            total += price;
            System.out.printf("  #%s %s ($%.2f)%n", id, title, price);
        }
        System.out.printf("Total catalog value: $%.2f%n", total);
    }
}

O que extrair da execução:

A análise DOM não precisa de dependência externa — DocumentBuilderFactory e org.w3c.dom vêm com o JDK, por isso o programa imprime resultados sem nada no classpath.
O nome do elemento raiz impresso como catalog confirma que há exatamente uma raiz envolvendo todo o documento.
getElementsByTagName("book") retornou uma NodeList de tamanho 2, então você a indexa como uma lista e converte cada item para Element.
Atributos (id) são lidos com getAttribute, enquanto o conteúdo de texto (title, price) é lido com getTextContent — são tipos diferentes de dados no mesmo elemento.
Como toda a árvore está na memória, somar os preços de todos os livros resultando em $83.50 é apenas um loop com acesso aleatório — a conveniência que torna DOM vantajoso apesar do custo de memória.

XML ou JSON?

XML e JSON resolvem o mesmo problema — trocar dados estruturados — mas fazem compensações diferentes.

Aspecto	XML	JSON
Sintaxe	Tags verbosas, abertura e fechamento	Chaves e colchetes compactos
Atributos	Sim (`id="1"`)	Não — tudo é um par chave/valor
Comentários	Suportados (`<!-- ... -->`)	Não suportados
Schema/validação	Maduro (XSD, DTD)	JSON Schema, menos ubíquo
Suporte no JDK	Integrado (`javax.xml.*`)	Nenhum integrado — precisa de biblioteca
Uso típico hoje	Configuração, documentos, SOAP, sistemas legados	APIs web/REST, serviços modernos

Use XML quando você precisa consumir um formato XML existente (um serviço SOAP, um pom.xml, um documento do Office) ou quando precisar de atributos, comentários ou validação estrita de schema. Use JSON para novas APIs web, onde seu tamanho menor e suporte nativo nos navegadores ganham.

Próximos passos

Analisador DOM XML do Java — leia, modifique e escreva a árvore.
Analisador SAX XML do Java — faça streaming de documentos grandes com handlers de eventos.
JAXB — mapeie XML para e a partir de objetos Java anotados.
Introdução ao Java JSON — a alternativa moderna para dados web.

Prática

Qual modelo de análise XML carrega o documento inteiro na memória como uma árvore navegável?

DOM, que constrói uma árvore completa em memória que você pode navegar e modificarSAX, que empurra eventos para handlers de callbackStAX, que expõe um cursor baseado em pullNenhum deles mantém o documento na memória