Skip to content

XML Folha de referência

Linguagem de marcação extensível para troca de dados estruturados.

01

Primeiros Passos

Estrutura de Documento XML

Documentos XML começam com uma declaração XML. Os elementos devem estar corretamente aninhados e fechados. Atributos fornecem metadados adicionais. xmlns declara namespaces XML para evitar conflitos de nomes.

xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- This is a comment -->
<bookstore xmlns="https://example.com/books">
  <book id="b1" category="fiction">
    <title lang="en">The Great Gatsby</title>
    <author>F. Scott Fitzgerald</author>
    <price currency="USD">12.99</price>
  </book>
  <book id="b2" category="programming">
    <title lang="en">XML Guide</title>
    <author>John Doe</author>
    <price currency="USD">29.99</price>
  </book>
</bookstore>

Declaração XML

A declaração XML é a primeira linha do prólogo. 'version' é obrigatória (1.0 ou 1.1). 'encoding' tem padrão UTF-8. 'standalone' diz aos parsers se declarações DTD externas são necessárias.

xml
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<!-- version is required; encoding and standalone are optional -->
<!-- encoding defaults to UTF-8 -->
<!-- standalone="yes" means no external markup declarations -->

<root>
  <child>text</child>
</root>

Comentários e Instruções de Processamento

Comentários usam <!-- --> e não podem aninhar nem conter '--' dentro. Instruções de Processamento (PIs) como xml-stylesheet passam informações específicas da aplicação ao parser. PIs usam <?target data?>.

xml
<?xml version="1.0"?>
<!-- a comment: ignored by the parser, cannot contain -- -->

<?xml-stylesheet type="text/xsl" href="style.xsl"?>

<root>
  <!-- comments can span
       multiple lines -->
  <item>data</item>
</root>

XML Bem Formado

Bem formado significa: um único elemento raiz, aninhamento correto, todas as tags fechadas, atributos entre aspas, sem atributos duplicados. Um documento PRECISA estar bem formado para ser analisável; validade (contra DTD/Schema) é opcional.

xml
<!-- WELL-FORMED: single root, properly nested, closed -->
<root>
  <a>
    <b>text</b>
  </a>
</root>

<!-- NOT well-formed: two roots, overlapping tags -->
<!-- <a><b></a></b> -->
<!-- <x></x><y></y>   (no single root) -->

<!-- All attributes must be quoted -->
<item id='1' type="x"/>

Prólogo XML e Espaços em Branco

O prólogo inclui a declaração XML e um DOCTYPE opcional. xml:space='preserve' diz aos parsers para manter os espaços em branco; 'default' permite o tratamento normal. Espaços entre elementos geralmente são insignificantes.

xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root SYSTEM "root.dtd">
<root xml:space="preserve">
  <item>  spaced  text  </item>
  <item xml:space="default">  trimmed  </item>
</root>

Visão Geral de CDATA

Seções CDATA marcam texto que o parser não deve interpretar como marcação. Dentro de CDATA, caracteres como <, > e & não precisam de escape. CDATA não pode ser aninhada nem conter o literal ']]>'.

xml
<?xml version="1.0"?>
<root>
  <code><![CDATA[
    if (a < b && c > d) {
      console.log("no escaping needed: < > & ");
    }
  ]]></code>
</root>
02

Elementos e Atributos

Elementos vs Atributos

Atributos servem para metadados (ids, tipos, flags); elementos servem para dados com estrutura ou valores repetidos. Um atributo aparece uma vez por elemento e não pode conter estrutura aninhada. Não há regra estrita—consistência é o que mais importa.

xml
<!-- Attributes: metadata/identifiers; Elements: data -->
<person id="p1">
  <name>Alice</name>
  <age>30</age>
</person>

<!-- vs. putting everything in attributes -->
<person id="p1" name="Alice" age="30"/>

<!-- Rule of thumb: use elements for data you display,
     attributes for IDs, types, and metadata -->

Elementos Vazios

Um elemento vazio não tem conteúdo. A forma auto-fechada <tag/> é abreviação de <tag></tag>. O espaço antes de '/>' é uma convenção de estilo, por legibilidade e compatibilidade com XHTML.

xml
<!-- Three equivalent empty-element forms -->
<br></br>
<br/>
<br />

<!-- empty element with attributes -->
<img src="logo.png" alt="Logo" width="200" height="100"/>

<!-- self-closing with namespace -->
<xlink:link xmlns:xlink="http://www.w3.org/1999/xlink" href="#sec1"/>

Elementos Aninhados

Elementos se aninham hierarquicamente e devem fechar em ordem inversa—não podem se sobrepor. O aninhamento expressa estrutura. Árvores profundamente aninhadas são válidas, mas podem prejudicar a leitura e o desempenho de análise.

xml
<library>
  <section name="fiction">
    <book>
      <title>Book A</title>
      <authors>
        <author>Author 1</author>
        <author>Author 2</author>
      </authors>
    </book>
  </section>
</library>

<!-- WRONG: tags must not overlap -->
<!-- <a><b></a></b> -->

Valores de Atributos e Aspas

Valores de atributos devem estar entre aspas simples ou duplas. Aspas duplas dentro de valores com aspas duplas devem ser escapadas como &quot;. Um atributo pode aparecer apenas uma vez por elemento—use elementos filhos para valores repetidos.

xml
<!-- Both single and double quotes are allowed -->
<item id="q1" name='quick'/>
<msg text="He said &quot;hi&quot;"/>
<msg text='She said &apos;hi&apos;'/>

<!-- attribute values MUST be quoted -->
<!-- <item id=q1/>  is NOT well-formed -->

<!-- an attribute can appear at most once per element -->
<point x="1" y="2" z="3"/>

Atributos Default e Fixed

Declarações de atributos em DTD suportam #REQUIRED (deve aparecer), #IMPLIED (opcional), #FIXED (valor constante) e um literal padrão. Um atributo #FIXED deve sempre igualar seu valor declarado ou o documento é inválido.

xml
<!-- In a DTD, attributes can have defaults -->
<!ATTLIST item
    type    CDATA     "standard"
    status  CDATA     #REQUIRED
    version CDATA     #FIXED "1.0"
    note    CDATA     #IMPLIED>

<item status="active"/>
<!-- 'type' defaults to "standard", 'version' is fixed,
     'note' is optional (#IMPLIED) -->

Regras de Nomeação de Elementos

Nomes de elementos devem começar com letra ou underscore e podem conter letras, dígitos, hífens, underscores e pontos. Nomes não podem começar com 'xml' (qualquer caixa). XML diferencia maiúsculas, então <Tag> e <tag> são diferentes.

xml
<!-- Names: start with a letter or underscore,
     continue with letters, digits, hyphens, underscores, dots -->
<my-element>ok</my-element>
<my.element>ok</my.element>
<my_element>ok</my_element>
<_private>ok</_private>
<x-1>ok</x-1>

<!-- NOT allowed: starting with a digit or 'xml', containing spaces -->
<!-- <2way/> -->
<!-- <my element/> -->
<!-- <XmlTag/>  (names are case-sensitive; 'xml' prefix is reserved) -->
03

Namespaces

Namespace Padrão

Um namespace padrão (xmlns=URI) vale para o elemento em que é declarado e cada um dos descendentes sem prefixo. Elementos filhos o herdam, a menos que seja sobrescrito. Atributos nunca usam o namespace padrão.

xml
<?xml version="1.0"?>
<table xmlns="http://www.w3.org/1999/xhtml">
  <tr>
    <td>Cell content</td>
    <td>More content</td>
  </tr>
</table>
<!-- All elements without a prefix use the default namespace -->

Prefixo de Namespace

Um prefixo de namespace é declarado com xmlns:prefixo=URI e usado como prefixo:elemento. O prefixo é só um apelido—apenas a URI importa para a identidade. Prefixos diferenciam maiúsculas.

xml
<?xml version="1.0"?>
<root xmlns:bk="https://example.com/books"
      xmlns:au="https://example.com/authors">
  <bk:book bk:id="b1">
    <au:author au:name="Jane Doe"/>
    <bk:title>XML Guide</bk:title>
  </bk:book>
</root>

Múltiplos Namespaces

Um único documento pode misturar muitos namespaces. Declare cada prefixo uma vez (geralmente na raiz) e reutilize-o. Declarar um namespace num elemento vale para esse elemento e seus descendentes.

xml
<?xml version="1.0"?>
<soap:Envelope
    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <soap:Body>
    <m:GetPrice xsi:type="xsd:string"
                xmlns:m="https://example.com/pricing">
      <m:Item>Apples</m:Item>
    </m:GetPrice>
  </soap:Body>
</soap:Envelope>

Escopo de Namespace

Declarações de namespace têm escopo no elemento em que aparecem e em seus descendentes. Uma redeclaração dentro de um filho sobrescreve o mapeamento de prefixo do pai naquela subárvore. O mapeamento original é restaurado depois que o filho fecha.

xml
<?xml version="1.0"?>
<root xmlns:a="http://a.example">
  <a:item>A</a:item>
  <child xmlns:a="http://b.example">
    <!-- here 'a' is REBOUND to the b.example URI -->
    <a:item>B</a:item>
  </child>
  <!-- outside child, 'a' is back to a.example -->
  <a:item>A again</a:item>
</root>

Namespaces Comuns

Essas URIs são identificadores conhecidos, não URLs que precisam ser baixadas. O namespace xsi fornece atributos de schema-instance (type, nil, schemaLocation). XSD, XSL, SVG, SOAP, Atom e Dublin Core (dc) têm URIs padrão.

xml
<!-- Frequently used namespace URIs -->
xmlns:xsi  = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd  = "http://www.w3.org/2001/XMLSchema"
xmlns:xsl  = "http://www.w3.org/1999/XSL/Transform"
xmlns:svg  = "http://www.w3.org/2000/svg"
xmlns:html = "http://www.w3.org/1999/xhtml"
xmlns:soap = "http://schemas.xmlsoap.org/soap/envelope/"
xmlns:atom = "http://www.w3.org/2005/Atom"
xmlns:dc   = "http://purl.org/dc/elements/1.1/"

Target Namespace em XSD

O targetNamespace de um schema é o namespace dos elementos que ele define. elementFormDefault='qualified' significa que elementos declarados localmente estão no namespace alvo. O prefixo tns é uma convenção para 'este namespace'.

xml
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="https://example.com/orders"
           xmlns:tns="https://example.com/orders"
           elementFormDefault="qualified">
  <xs:element name="order" type="tns:OrderType"/>
  <xs:complexType name="OrderType">
    <xs:sequence>
      <xs:element name="item" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>
</xs:schema>
04

CDATA e Entidades

Entidades Predefinidas

XML predefine cinco entidades: &lt; (<), &gt; (>), &amp; (&), &apos; ('), &quot; ("). & deve SEMPRE ser escapado (mesmo em texto sem CDATA); < deve ser escapado, exceto como início de tag; aspas importam principalmente em atributos.

xml
<?xml version="1.0"?>
<root>
  <lt>less than: &lt;</lt>
  <gt>greater than: &gt;</gt>
  <amp>ampersand: &amp;</amp>
  <apos>apostrophe: &apos;</apos>
  <quot>quote: &quot;</quot>
  <!-- &lt; &gt; &amp; &apos; &quot; are the 5 built-in entities -->
</root>

Referências de Caracteres

Referências de caracteres usam um ponto de código Unicode: &#169; (decimal) ou &#xA9; (hex) para ©. Funcionam no texto de elementos e em valores de atributos e não são afetadas pela codificação. Podem representar qualquer caractere Unicode.

xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <decimal>&#169; 2024 Company</decimal>
  <hex>&#xA9; 2024 Company</hex>
  <euro>Price: &#x20AC;10</euro>
  <emoji>Smile: &#x1F600;</emoji>
</root>
<!-- &#NNN;  decimal code point -->
<!-- &#xHHH; hexadecimal code point -->

Seções CDATA

Seções CDATA permitem incluir <, > e & sem escape—úteis para código e marcação. CDATA não pode conter ']]>' literalmente; para embuti-lo, divida a seção como mostrado. CDATA é dado de caracteres, não analisado como elementos.

xml
<?xml version="1.0"?>
<root>
  <script><![CDATA[
    function check(a, b) {
      if (a < b && b > 0) {
        return a & b;
      }
    }
  ]]></script>
  <!-- to include ]]> inside CDATA, split it -->
  <data><![CDATA[foo]]]]><![CDATA[>bar]]></data>
</root>

Entidades Personalizadas (DTD)

Entidades internas são declaradas numa DTD e expandidas onde forem referenciadas. Funcionam como macros de texto e podem referenciar outras entidades. Úteis para textos repetidos. Cuidado: entidades externas/gerais podem ser um risco de segurança XXE.

xml
<?xml version="1.0"?>
<!DOCTYPE root [
  <!ENTITY company "Acme Corp.">
  <!ENTITY version "2.0">
  <!ENTITY copyright "Copyright © 2024 &company;">
]>
<root>
  <product>&company; Toolkit v&version;</product>
  <footer>&copyright;</footer>
</root>
<!-- Entities are expanded during parsing -->

Escape em Atributos

Dentro de valores de atributos você deve escapar & como &amp; e escapar o caractere de aspas usado para delimitar o valor (&quot; ou &apos;). < também deve ser escapado. Quebras de linha e tabs em atributos são normalizadas para espaços pelo parser.

xml
<?xml version="1.0"?>
<root>
  <link url="https://example.com?a=1&amp;b=2"/>
  <msg text="Say &quot;hello&quot; &amp; smile"/>
  <path value='C:\Users\name'/>
  <data value="&lt;tagged&gt;"/>
</root>

Entidades de Parâmetro

Entidades de parâmetro (declaradas com %) são usadas apenas dentro de DTDs para construir modelos de conteúdo reutilizáveis. São referenciadas como %nome; (com ponto e vírgula). Entidades gerais (&nome;) são usadas no conteúdo do documento.

xml
<?xml version="1.0"?>
<!DOCTYPE root [
  <!ENTITY % inline " (#PCDATA | em | strong)* ">
  <!ELEMENT p %inline;>
  <!ELEMENT em %inline;>
  <!ELEMENT strong %inline;>
  <!ELEMENT root (p)*>
]>
<root>
  <p>Hello <em>world</em> and <strong>XML</strong>.</p>
</root>
05

DTD (Document Type Definition)

DTD Interna

Uma DTD interna é declarada inline no DOCTYPE, entre colchetes. Ela define a estrutura: quais elementos existem, seus modelos de conteúdo e atributos. DTDs internas são autocontidas, mas valem só para aquele documento.

xml
<?xml version="1.0"?>
<!DOCTYPE note [
  <!ELEMENT note (to, from, heading, body)>
  <!ELEMENT to (#PCDATA)>
  <!ELEMENT from (#PCDATA)>
  <!ELEMENT heading (#PCDATA)>
  <!ELEMENT body (#PCDATA)>
]>
<note>
  <to>Alice</to>
  <from>Bob</from>
  <heading>Reminder</heading>
  <body>Don't forget the meeting</body>
</note>

DTD Externa

Uma DTD externa vive num arquivo .dtd separado, referenciado por SYSTEM (privado) ou PUBLIC (identificador público + URI). DTDs externas permitem que muitos documentos compartilhem uma definição. SYSTEM 'file.dtd' é a forma mais comum.

xml
<!-- File: note.dtd -->
<!ELEMENT note (to, from, body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT body (#PCDATA)>

<!-- File: note.xml -->
<?xml version="1.0"?>
<!DOCTYPE note SYSTEM "note.dtd">
<note>
  <to>Alice</to>
  <from>Bob</from>
  <body>Hello</body>
</note>

Declarações de Elementos

Modelos de conteúdo usam , (sequência), | (escolha), ? (0-1), * (0+), + (1+). #PCDATA é texto; conteúdo misto permite texto intercalado com elementos. EMPTY significa sem conteúdo; ANY desativa a verificação (evite em produção).

xml
<!ELEMENT root (child1, child2*)>
<!-- content model operators -->
<!ELEMENT list (item+)>            <!-- one or more item -->
<!ELEMENT opt (item?)>             <!-- zero or one item   -->
<!ELEMENT any (item1 | item2)*>    <!-- choice, any number  -->
<!ELEMENT text (#PCDATA)>          <!-- parsed character data -->
<!ELEMENT mixed (#PCDATA | em)*>   <!-- mixed content -->
<!ELEMENT empty EMPTY>             <!-- no content -->
<!ELEMENT any ANY>                 <!-- any content -->

Declarações de Atributos

ATTLIST declara o tipo e o padrão de um atributo. ID é um identificador único; IDREF/IDREFS referenciam IDs (para links cruzados). NMTOKEN é um token de nome. Tipos enumerados listam valores permitidos. Padrões: #REQUIRED, #IMPLIED, #FIXED ou um literal.

xml
<!ATTLIST book
    id      ID         #REQUIRED
    category CDATA     #IMPLIED
    lang    NMTOKEN    "en"
    status  (draft|final) "draft"
    version CDATA      #FIXED "1.0">

<!-- Types: CDATA, ID, IDREF, IDREFS, NMTOKEN, NMTOKENS,
     NOTATION, enumerated (a|b|c) -->
<!ATTLIST link ref IDREF #REQUIRED>

Declarações de Entidades

Entidades gerais (&nome;) expandem no conteúdo; entidades de parâmetro (%nome;) expandem na DTD. Entidades externas analisadas incluem outros XML; entidades não analisadas (com NDATA) apontam para dados não XML referenciados via NOTATION. Entidades externas podem causar injeção XXE.

xml
<!DOCTYPE root [
  <!-- internal general entity -->
  <!ENTITY name "Alice">
  <!-- external parsed entity -->
  <!ENTITY chap1 SYSTEM "chapter1.xml">
  <!-- unparsed entity (binary, e.g. image) -->
  <!ENTITY logo SYSTEM "logo.png" NDATA image>
  <!-- notation declaration for unparsed entities -->
  <!NOTATION image SYSTEM "image/png">
  <!-- parameter entity (DTD-only) -->
  <!ENTITY % block "(p | list)+">
]>
<root>&name;</root>

Validação de DTD

A validação verifica se um documento corresponde à sua DTD (ordem de elementos, atributos permitidos, unicidade de IDs). Parsers DOM padrão como o minidom NÃO validam por padrão—use lxml (Python), xmllint (linha de comando) ou um parser validador.

xml
<?xml version="1.0"?>
<!DOCTYPE root SYSTEM "schema.dtd">
<root>
  <item id="x1">valid</item>
</root>

<!-- Validate with Python: -->
<!-- import xml.dom.minidom as m
dom = m.parse("file.xml")
# minidom does NOT validate; use lxml: -->
<!-- from lxml import etree
dtd = etree.DTD("schema.dtd")
tree = etree.parse("file.xml")
print(dtd.validate(tree)) -->
06

XML Schema (XSD)

Estrutura do Schema

Um XSD é ele próprio um documento XML. A raiz <schema> declara o namespace XSD e um namespace alvo para os elementos que define. elementFormDefault='qualified' coloca os elementos locais no namespace alvo.

xml
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="https://example.com/order"
           xmlns:tns="https://example.com/order"
           elementFormDefault="qualified">

  <xs:element name="order" type="tns:OrderType"/>

  <xs:complexType name="OrderType">
    <xs:sequence>
      <xs:element name="customer" type="xs:string"/>
      <xs:element name="total" type="xs:decimal"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:ID" use="required"/>
  </xs:complexType>
</xs:schema>

Tipos Simples

Um simpleType restringe um tipo base com facets (pattern, minInclusive, enumeration, length, etc.). Tipos simples têm apenas conteúdo de texto e atributos—sem elementos filhos. São reutilizáveis em o schema inteiro.

xml
<xs:simpleType name="emailType">
  <xs:restriction base="xs:string">
    <xs:pattern value="[^@]+@[^@]+.[^@]+"/>
  </xs:restriction>
</xs:simpleType>

<xs:simpleType name="ageType">
  <xs:restriction base="xs:integer">
    <xs:minInclusive value="0"/>
    <xs:maxInclusive value="120"/>
  </xs:restriction>
</xs:simpleType>

<xs:element name="email" type="tns:emailType"/>
<xs:element name="age" type="tns:ageType"/>

Tipos Complexos

Um complexType pode conter elementos filhos e atributos. sequence impõe ordem; choice permite um de vários; all permite qualquer ordem (cada um no máximo uma vez). Compositores podem se aninhar para expressar estruturas ricas.

xml
<xs:complexType name="AddressType">
  <xs:sequence>
    <xs:element name="street" type="xs:string"/>
    <xs:element name="city" type="xs:string"/>
    <xs:element name="zip" type="xs:string"/>
  </xs:sequence>
  <xs:attribute name="country" type="xs:string" default="US"/>
</xs:complexType>

<!-- Content model indicators: sequence, choice, all -->
<xs:complexType name="ContactType">
  <xs:choice>
    <xs:element name="phone" type="xs:string"/>
    <xs:element name="email" type="xs:string"/>
  </xs:choice>
</xs:complexType>

Tipos Embutidos

XSD fornece uma rica hierarquia de tipos: strings, números (integer, decimal, float), datas/horas, boolean, anyURI, ID/IDREF e QName. Cada um suporta facets como length, pattern e enumeration para restrições adicionais.

xml
<!-- Common XSD built-in types -->
<xs:element name="count"  type="xs:integer"/>
<xs:element name="price"  type="xs:decimal"/>
<xs:element name="flag"   type="xs:boolean"/>
<xs:element name="name"   type="xs:string"/>
<xs:element name="date"   type="xs:date"/>        <!-- 2024-01-15 -->
<xs:element name="time"   type="xs:time"/>        <!-- 13:45:00 -->
<xs:element name="dt"     type="xs:dateTime"/>    <!-- 2024-01-15T13:45:00 -->
<xs:element name="id"     type="xs:ID"/>
<xs:element name="ref"    type="xs:IDREF"/>
<xs:element name="uri"    type="xs:anyURI"/>

Restrições (Facets)

Facets restringem tipos simples: enumeration (valores permitidos), pattern (regex), length/minLength/maxLength, min/maxInclusive/Exclusive, totalDigits, fractionDigits e whiteSpace (preserve/replace/collapse).

xml
<xs:simpleType name="ColorType">
  <xs:restriction base="xs:string">
    <xs:enumeration value="red"/>
    <xs:enumeration value="green"/>
    <xs:enumeration value="blue"/>
  </xs:restriction>
</xs:simpleType>

<xs:simpleType name="PasswordType">
  <xs:restriction base="xs:string">
    <xs:minLength value="8"/>
    <xs:maxLength value="32"/>
    <xs:pattern value="[A-Za-z0-9!@#]+"/>
  </xs:restriction>
</xs:simpleType>

Elementos e Atributos em XSD

minOccurs/maxOccurs controlam a cardinalidade (padrão 1); maxOccurs='unbounded' permite qualquer quantidade. O 'use' do atributo é required/optional/prohibited, com valor default ou fixed opcional. Tipos complexos anônimos embutem a definição.

xml
<xs:element name="product">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="name" type="xs:string"
                  minOccurs="1" maxOccurs="1"/>
      <xs:element name="tag" type="xs:string"
                  minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="sku" type="xs:string" use="required"/>
    <xs:attribute name="weight" type="xs:decimal" use="optional"
                  default="0.0"/>
  </xs:complexType>
</xs:element>
07

XPath

Expressões de Caminho

XPath usa expressões semelhantes a caminhos. '/' seleciona a partir da raiz; '//' seleciona descendentes em qualquer profundidade. '*' é um curinga para qualquer elemento; '@' seleciona atributos. Uma expressão que começa com '/' é absoluta.

xml
<!-- Sample: <bookstore><book><title>..</title></book></bookstore> -->

/bookstore/book/title       <!-- absolute path -->
bookstore/book/title        <!-- relative path -->
//title                     <!-- any title, anywhere -->
/bookstore//title           <!-- title anywhere under bookstore -->
bookstore/*                 <!-- all children of bookstore -->
//@lang                     <!-- all lang attributes -->
//@*                        <!-- all attributes -->

Predicados

Predicados entre [ ] filtram um conjunto de nós. A indexação começa em 1. last() e position() referem-se à posição do nó em seu contexto. Predicados podem testar texto de elementos, atributos (@nome) ou valores calculados.

xml
//book[1]                  <!-- first book -->
//book[last()]            <!-- last book -->
//book[position() <= 3]   <!-- first three books -->
//book[price > 25]        <!-- books with price > 25 -->
//book[@category='web']   <!-- books in the web category -->
//book[author='Smith']    <!-- books authored by Smith -->
//book[@lang][2]          <!-- 2nd book that has a lang attr -->

Eixos

Eixos definem direções de navegação: child (padrão), descendant, parent (..), ancestor, following-sibling, preceding-sibling, attribute (@), self (.), descendant-or-self (//). A maioria tem formas abreviadas usadas na prática.

xml
child::book            <!-- default axis: children named book -->
descendant::title      <!-- all title descendants -->
parent::*              <!-- the parent element (shorthand: ..) -->
ancestor::section      <!-- all section ancestors -->
following-sibling::p   <!-- p elements after this one -->
preceding::item        <!-- items before this in document order -->
attribute::id          <!-- the id attribute (shorthand: @id) -->
self::node()           <!-- the current node (shorthand: .) -->

Funções

XPath 1.0 tem funções embutidas: count, sum, string-length, contains, starts-with, normalize-space, name, concat, substring, round e mais. XPath 2.0+ expande muito a biblioteca de funções e adiciona tipagem.

xml
count(//book)                  <!-- number of book elements -->
string-length(//title)        <!-- length of first title's text -->
contains(//name, 'Ali')       <!-- true if name contains 'Ali' -->
starts-with(@id, 'b')         <!-- true if id starts with 'b' -->
normalize-space(//summary)    <!-- collapse whitespace -->
name(//*[1])                  <!-- name of the first element -->
concat(/a, /b)                <!-- concatenate strings -->
sum(//price)                  <!-- sum of all price values -->

Operadores

XPath usa = para igualdade (= único, não ==) e os operadores 'and'/'or' para lógica (não && / ||). 'div' é divisão e 'mod' é módulo, já que '/' é reservado para caminhos. '|' calcula a união de conjuntos de nós.

xml
<!-- Comparison: =, !=, <, >, <=, >= -->
//book[price = 29.99]
//book[price < 20]

<!-- Logical: and, or -->
//book[price > 10 and price < 30]
//book[@cat='a' or @cat='b']

<!-- Arithmetic: + - * div mod -->
//item[price * quantity > 100]
5 div 2        <!-- 2.5 -->
5 mod 2        <!-- 1 -->

<!-- Union: | -->
//book | //magazine

Exemplos de XPath

Esses padrões combinam caminhos, predicados e funções para consultas reais. text() seleciona o nó de texto; min() exige XPath 2.0+. O curinga //* com predicado é uma forma comum de achar elementos por atributo em toda a árvore.

xml
<!-- Select all book titles priced over 20 -->
//book[price > 20]/title/text()

<!-- The category of the cheapest book -->
//book[price = min(//book/price)]/@category

<!-- Authors of books in the 'programming' category -->
//book[@category='programming']/author

<!-- Every 2nd item in each list -->
//list/item[position() mod 2 = 0]

<!-- Elements with a specific attribute value -->
//*[@lang='fr']
08

Transformações XSLT

Transformação Básica

Uma folha de estilo XSLT é XML. Templates casam nós com XPath; apply-templates processa recursivamente os nós selecionados. value-of extrai texto. O template match='/' roda primeiro, na raiz do documento.

xml
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:template match="/">
    <html>
      <body>
        <h2>Book List</h2>
        <xsl:apply-templates select="bookstore/book"/>
      </body>
    </html>
  </xsl:template>

  <xsl:template match="book">
    <p><xsl:value-of select="title"/> - <xsl:value-of select="price"/></p>
  </xsl:template>
</xsl:stylesheet>

xsl:template e apply-templates

Templates com match disparam quando o processador visita nós que casam; templates nomeados são chamados explicitamente com call-template. apply-templates sem select processa cada um dos filhos, permitindo transformações recursivas dirigidas por regras.

xml
<xsl:template match="book">
  <div class="book">
    <xsl:apply-templates select="title"/>
    <xsl:apply-templates select="author"/>
  </div>
</xsl:template>

<xsl:template match="title">
  <h3><xsl:apply-templates/></h3>
</xsl:template>

<!-- named template (like a function) -->
<xsl:template name="divider">
  <hr/>
</xsl:template>

xsl:value-of e xsl:for-each

xsl:for-each itera um conjunto de nós, mudando o nó de contexto. Costuma ser mais simples que templates para saída plana, mas o excesso torna a folha de estilo procedural. Prefira templates e apply-templates para estruturas recursivas.

xml
<xsl:template match="/">
  <ul>
    <xsl:for-each select="bookstore/book">
      <li>
        <xsl:value-of select="title"/>
        (<xsl:value-of select="@category"/>)
      </li>
    </xsl:for-each>
  </ul>
</xsl:template>

<!-- value-of outputs the string value of an expression -->

xsl:if e xsl:choose

xsl:if não tem else—use xsl:choose para ramificações múltiplas. A expressão 'test' segue as regras booleanas do XPath: um conjunto de nós não vazio é verdadeiro, vazio é falso, números diferentes de zero são verdadeiros.

xml
<xsl:for-each select="bookstore/book">
  <xsl:if test="price > 25">
    <premium><xsl:value-of select="title"/></premium>
  </xsl:if>

  <xsl:choose>
    <xsl:when test="@category='fiction'">F</xsl:when>
    <xsl:when test="@category='programming'">P</xsl:when>
    <xsl:otherwise>?</xsl:otherwise>
  </xsl:choose>
</xsl:for-each>

<!-- test uses XPath; non-empty node-sets and non-zero numbers are true -->

xsl:sort e xsl:variable

xsl:sort reordena o conjunto de nós atual por uma ou mais chaves; data-type é 'text' ou 'number'. Variáveis (xsl:variable) são imutáveis e têm escopo. Lembre de escapar < como &lt; dentro de valores de atributos no XML da folha de estilo.

xml
<xsl:variable name="max-price" select="50"/>

<xsl:for-each select="bookstore/book[price &lt; $max-price]">
  <xsl:sort select="price" data-type="number" order="descending"/>
  <xsl:sort select="title" order="ascending"/>
  <p>
    <xsl:value-of select="title"/>: <xsl:value-of select="price"/>
  </p>
</xsl:for-each>

<!-- Note: in XSLT, < must be written &lt; inside test attributes -->

xsl:apply-templates e modes

Modes permitem que um mesmo conjunto de nós de origem seja processado de formas diferentes (ex.: um sumário vs entradas completas). O atributo mode deve casar tanto no template quanto no apply-templates. Sem mode, apenas templates sem modo se aplicam.

xml
<!-- A template can have a 'mode' for different outputs -->
<xsl:template match="book" mode="list">
  <li><xsl:value-of select="title"/></li>
</xsl:template>

<xsl:template match="book" mode="detail">
  <div><h3><xsl:value-of select="title"/></h3>
       <p><xsl:value-of select="author"/></p></div>
</xsl:template>

<!-- Invoke a specific mode -->
<xsl:apply-templates select="bookstore/book" mode="list"/>
<xsl:apply-templates select="bookstore/book" mode="detail"/>
09

XQuery

Expressões FLWOR

FLWOR é a construção central do XQuery: for vincula variáveis a itens de sequência, let vincula valores calculados, where filtra, order by ordena e return molda a saída. Lembra o SELECT-FROM-WHERE do SQL.

xml
for $b in /bookstore/book
let $discount := $b/price * 0.9
where $b/price > 20
order by $b/price descending
return
  <book>
    <title>{ $b/title/text() }</title>
    <salePrice>{ $discount }</salePrice>
  </book>

<!-- FLWOR = For, Let, Where, Order by, Return -->

Expressões de Caminho

XQuery embute XPath diretamente. doc('file.xml') carrega um documento; collection('uri') consulta múltiplos documentos. Expressões de caminho retornam sequências de nós, que expressões FLWOR podem iterar.

xml
(: XQuery uses XPath for navigation :)
/bookstore/book/title/text()
/bookstore/book[@category='web']
//author[contains(., 'Smith')]

(: Use doc() to open an external document :)
doc('catalog.xml')//book[price < 30]

(: collection() queries a set of documents :)
collection('/db/books')//title

Predicados e Joins

Múltiplas cláusulas 'for' formam um join (como o JOIN do SQL). XQuery faz joins iterando combinações e filtrando com where. Para bases grandes, joins explícitos via predicados ou chaves são mais eficientes que loops aninhados.

xml
(: Join books to authors by id :)
for $b in doc('books.xml')//book
for $a in doc('authors.xml')//author
where $b/@author-id = $a/@id
return
  <entry>
    <title>{ $b/title/text() }</title>
    <author>{ $a/name/text() }</author>
  </entry>

(: Equivalent join with a predicate :)
for $b in doc('books.xml')//book
return
  <entry>{ $b/title, $b/@author-id }</entry>

Condicional e Quantificado

XQuery tem if-then-else (o else é obrigatório), expressões quantificadas (some/every ... satisfies) e typeswitch para ramificar por tipo de nó. As condições usam semântica booleana estilo XPath.

xml
(: if-then-else :)
for $b in //book
return
  if ($b/price > 30) then <expensive>{ $b/title }</expensive>
  else <cheap>{ $b/title }</cheap>

(: quantified expressions :)
some $a in //author satisfies contains($a, 'Smith')
every $p in //price satisfies $p > 0

(: typeswitch for type-based dispatch :)
typeswitch($node)
  case element(book) return "book"
  case element(author) return "author"
  default return "other"

Funções

XQuery reutiliza funções XPath e adiciona muitas (string-join, distinct-values, avg, min, max). Funções do usuário são declaradas no módulo com tipos de parâmetro e de retorno, no namespace local: por convenção.

xml
(: Built-in functions :)
concat('a', 'b', 'c')
string-join(//title, ', ')
count(//book)
distinct-values(//book/@category)
avg(//book/price)
max(//book/price)

(: User-defined function :)
declare function local:discount($price as xs:decimal)
  as xs:decimal {
  $price * 0.9
};

local:discount(29.99)

Construindo XML

XQuery constrói XML com construtores diretos (tags literais com { } para expressões embutidas) ou construtores computados (element name { ... }). Chaves avaliam as expressões envolvidas; atributos podem embutir valores inline.

xml
(: Direct element construction :)
<result>
  <count>{ count(//book) }</count>
  <books>
    { for $b in //book return <book title="{ $b/title/text() }"/> }
  </books>
</result>

(: Computed constructors :)
element result {
  attribute total { count(//book) },
  for $b in //book
  return element book { $b/title/text() }
}

(: Enclosed expressions use { } to embed values -->
10

Análise com DOM

Carregando XML (JavaScript)

DOMParser transforma uma string XML numa árvore DOM no navegador; erros de análise aparecem como um elemento <parsererror> em vez de exceção. Node.js não tem XML DOM embutido—use xmldom, @xmldom/xmldom ou um parser de streaming.

xml
// Browser: parse an XML string
const parser = new DOMParser();
const doc = parser.parseFromString(xmlString, "application/xml");

const errorNode = doc.querySelector("parsererror");
if (errorNode) {
  console.error("Parse error:", errorNode.textContent);
}

const books = doc.getElementsByTagName("book");
for (const book of books) {
  console.log(book.getAttribute("id"));
}

// Node.js: use xmldom or fast-xml-parser instead

Travessia do DOM

A API DOM expõe documentElement, children, childNodes e nextSibling para travessia. nodeType 1 é elemento, 3 é texto, 8 é comentário. document.evaluate roda XPath nos navegadores (Node precisa de bibliotecas xpath).

xml
// JavaScript DOM API (also works for XML documents)
const root = doc.documentElement;        // <bookstore>
const firstBook = root.children[0];      // first <book>
const titles = doc.getElementsByTagName("title");

// walk children
let node = root.firstChild;
while (node) {
  if (node.nodeType === 1) {             // Element node
    console.log(node.tagName);
  }
  node = node.nextSibling;
}

// XPath against the DOM
const it = doc.evaluate("//book[@id='b1']", doc, null,
                        XPathResult.ANY_TYPE, null);
const found = it.iterateNext();

Modificando o DOM

createElement/setAttribute/appendChild constroem e anexam nós; textContent define texto. XMLSerializer converte o DOM de volta em string. O DOM é vivo—mutações refletem imediatamente em qualquer referência.

xml
const book = doc.createElement("book");
book.setAttribute("id", "b3");

const title = doc.createElement("title");
title.textContent = "New Book";
book.appendChild(title);

root.appendChild(book);                  // add to tree

// change an existing element
const price = doc.querySelector("book:nth-child(2) price");
price.textContent = "19.99";
price.setAttribute("currency", "EUR");

// serialize back to a string
const xml = new XMLSerializer().serializeToString(doc);

Criando Elementos

minidom permite construir um documento do zero: createDocument para a raiz, createElement/setAttribute/createTextNode para o conteúdo, appendChild para ligar. toprettyxml serializa com indentação. minidom é simples, mas lento para árvores grandes.

xml
// Python: xml.dom.minidom
from xml.dom import minidom

impl = minidom.getDOMImplementation()
doc = impl.createDocument(None, "root", None)
root = doc.documentElement

item = doc.createElement("item")
item.setAttribute("id", "1")
item.appendChild(doc.createTextNode("Hello"))
root.appendChild(item)

print(doc.toprettyxml(encoding="UTF-8").decode())

Análise DOM em Java

O DOM do JAXP em Java carrega o documento inteiro na memória via DocumentBuilder. setNamespaceAware(true) mantém os prefixos de namespace. O DOM é conveniente para acesso aleatório, mas pesado em memória para arquivos grandes—prefira StAX/SAX nesses casos.

xml
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.*;

DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
f.setNamespaceAware(true);
Document doc = f.newDocumentBuilder().parse(new File("data.xml"));

Element root = doc.getDocumentElement();
NodeList books = root.getElementsByTagName("book");
for (int i = 0; i < books.getLength(); i++) {
  Element b = (Element) books.item(i);
  String id = b.getAttribute("id");
  String title = b.getElementsByTagName("title")
                      .item(0).getTextContent();
  System.out.println(id + ": " + title);
}

lxml (Python)

lxml é um binding Python rápido e rico para libxml2. Suporta XPath completo, XSLT, validação (DTD/XSD/RelaxNG) e análise incremental. Seu ElementPath (find/findall) é um subconjunto do XPath; use xpath() para XPath completo.

xml
from lxml import etree

# parse and validate against a schema
tree = etree.parse("data.xml")
root = tree.getroot()

# XPath with namespaces
ns = {"bk": "https://example.com/books"}
for book in root.xpath("//bk:book", namespaces=ns):
    print(book.get("id"), book.find("bk:title", namespaces=ns).text)

# build an element tree
root = etree.Element("root")
child = etree.SubElement(root, "item", id="1")
child.text = "Hello"
print(etree.tostring(root, pretty_print=True, encoding="unicode"))
11

Análise com SAX

Handler SAX (Python)

SAX é orientado a eventos e em streaming: o parser chama startElement, characters e endElement conforme lê, nunca construindo uma árvore completa. É eficiente em memória para arquivos enormes. Você mesmo deve acompanhar o estado (ex.: elemento atual).

xml
import xml.sax

class BookHandler(xml.sax.ContentHandler):
    def startElement(self, name, attrs):
        if name == "book":
            print("Book id:", attrs.getValue("id"))
        self.current = name

    def characters(self, content):
        if self.current == "title":
            print("Title:", content.strip())

    def endElement(self, name):
        self.current = None

xml.sax.parse("books.xml", BookHandler())

Handlers de Evento SAX

Os callbacks do ContentHandler marcam os limites de documento e elemento. characters() pode dividir um único nó de texto em várias chamadas—acumule num buffer. startPrefixMapping/endPrefixMapping reportam declarações de namespace.

xml
class Handler(xml.sax.ContentHandler):
    def startDocument(self):
        print("parsing started")

    def endDocument(self):
        print("parsing done")

    def startElement(self, name, attrs):
        # attrs: get via attrs.getValue('id') or attrs['id']
        pass

    def endElement(self, name):
        pass

    def characters(self, text):
        # may be called multiple times for one text node
        pass

    def startPrefixMapping(self, prefix, uri):
        print("namespace:", prefix, uri)

startElement / endElement

Acompanhar o caminho de elementos (uma pilha) é a forma padrão de saber sua posição durante o streaming. Bufferize a saída de characters() e descarregue no endElement, porque characters pode disparar mais de uma vez por nó de texto.

xml
class Handler(xml.sax.ContentHandler):
    def __init__(self):
        self.path = []
        self.text = []

    def startElement(self, name, attrs):
        self.path.append(name)
        self.text = []
        if "id" in attrs:
            print("/".join(self.path), "id =", attrs["id"])

    def endElement(self, name):
        if self.path[-1] == "title":
            print("title:", "".join(self.text).strip())
        self.path.pop()

    def characters(self, content):
        self.text.append(content)

Parser SAX em Java

SAX em Java estende DefaultHandler. startElement recebe URI de namespace, nome local, nome qualificado e um objeto Attributes. characters(ch, start, len) fornece uma fatia de chars—bufferize, pois um nó de texto pode se estender por várias chamadas.

xml
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.*;
import javax.xml.parsers.*;

class BookHandler extends DefaultHandler {
    private StringBuilder buf = new StringBuilder();

    public void startElement(String uri, String local,
                             String qName, Attributes attrs) {
        buf.setLength(0);
        if ("book".equals(qName))
            System.out.println("id=" + attrs.getValue("id"));
    }

    public void characters(char[] ch, int start, int len) {
        buf.append(ch, start, len);
    }

    public void endElement(String uri, String local, String qName) {
        if ("title".equals(qName))
            System.out.println("title=" + buf);
    }
}
// SAXParserFactory.newInstance().newSAXParser().parse(file, new BookHandler());

SAX vs DOM

SAX transmite eventos com memória constante, ideal para arquivos enormes e extração em uma passada. DOM carrega a árvore inteira, permitindo XPath e mutação aleatória, mas usando memória proporcional ao tamanho do arquivo. Escolha pelo padrão de acesso e pelo tamanho do arquivo.

xml
<!-- SAX: event-driven, streaming, low memory
     DOM:  full tree in memory, random access

     SAX is best for:
       - large files that won't fit in memory
       - read-only filtering / extraction
       - simple state machines over the document

     DOM is best for:
       - random access to many parts of the tree
       - repeated queries / XPath
       - editing and re-serializing -->

<!-- Memory: SAX ~ O(1); DOM ~ O(file size) -->
<!-- Speed:  SAX often faster for one-pass scans -->

Tratamento de Erros (SAX)

Um ErrorHandler recebe avisos, erros recuperáveis e erros fatais. Por padrão, erros fatais lançam exceção e param a análise. Implementar error() permite registrar problemas de validação não fatais sem abortar toda a análise.

xml
import xml.sax

class Handler(xml.sax.ContentHandler):
    pass

# ErrorHandler: warning, error, fatalError
class ErrHandler(xml.sax.ErrorHandler):
    def error(self, exception):
        print("ERROR:", exception)
    def fatalError(self, exception):
        print("FATAL:", exception)
        raise exception
    def warning(self, exception):
        print("WARN:", exception)

parser = xml.sax.make_parser()
parser.setContentHandler(Handler())
parser.setErrorHandler(ErrHandler())
parser.parse("data.xml")
12

StAX (Análise Pull)

API Cursor do StAX

StAX é um parser pull: seu código puxa o próximo evento com next(), então você controla o loop. A API de cursor (XMLStreamReader) avança pelos eventos um a um. É mais rápido e usa menos memória que DOM, e mais flexível que o modelo push do SAX.

xml
import javax.xml.stream.*;
import java.io.*;

XMLInputFactory factory = XMLInputFactory.newInstance();
// defend against XXE
factory.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
factory.setProperty(XMLInputFactory.SUPPORT_DTD, false);

XMLStreamReader r = factory.createXMLStreamReader(new FileInputStream("data.xml"));
while (r.hasNext()) {
    int event = r.next();
    if (event == XMLStreamConstants.START_ELEMENT) {
        System.out.println("start: " + r.getLocalName());
    } else if (event == XMLStreamConstants.END_ELEMENT) {
        System.out.println("end: " + r.getLocalName());
    }
}
r.close();

Eventos do XMLStreamReader

Os tipos de evento incluem START_ELEMENT, END_ELEMENT, CHARACTERS, COMMENT, PROCESSING_INSTRUCTION e START/END_DOCUMENT. getText() retorna o texto atual; isWhiteSpace() filtra indentação. O cursor avança um evento por chamada de next().

xml
XMLStreamReader r = factory.createXMLStreamReader(in);
while (r.hasNext()) {
    switch (r.next()) {
        case XMLStreamConstants.START_ELEMENT:
            // r.getLocalName(), r.getAttributeValue(i), r.getNamespaceURI()
            break;
        case XMLStreamConstants.END_ELEMENT:
            break;
        case XMLStreamConstants.CHARACTERS:
            if (!r.isWhiteSpace()) {
                String text = r.getText();
            }
            break;
        case XMLStreamConstants.START_DOCUMENT:
            break;
        case XMLStreamConstants.END_DOCUMENT:
            break;
        case XMLStreamConstants.PROCESSING_INSTRUCTION:
            break;
    }
}

Lendo Elementos e Atributos

getAttributeValue(namespaceURI, localName) lê atributos pelo nome (passe null para sem namespace). getElementText() é uma conveniência que lê o texto de um elemento só de texto e avança além do seu END_ELEMENT—mais limpo que bufferizar characters você mesmo.

xml
while (r.hasNext()) {
    int event = r.next();
    if (event == XMLStreamConstants.START_ELEMENT
            && "book".equals(r.getLocalName())) {
        String id = r.getAttributeValue(null, "id");
        String category = r.getAttributeValue(null, "category");
        System.out.println("Book " + id + " (" + category + ")");
    }
    if (event == XMLStreamConstants.START_ELEMENT
            && "title".equals(r.getLocalName())) {
        String title = r.getElementText();   // consumes until END_ELEMENT
        System.out.println("Title: " + title);
    }
}

Writer do StAX

XMLStreamWriter constrói XML sequencialmente. writeStartDocument, writeStartElement/writeEndElement, writeAttribute, writeCharacters e writeNamespace devem ficar balanceados. Faça flush/close no fim para garantir a saída completa.

xml
XMLOutputFactory out = XMLOutputFactory.newInstance();
XMLStreamWriter w = out.createXMLStreamWriter(System.out, "UTF-8");

w.writeStartDocument("UTF-8", "1.0");
w.writeStartElement("books");
w.writeNamespace("bk", "https://example.com/books");

w.writeStartElement("bk", "book", "https://example.com/books");
w.writeAttribute("id", "b1");
w.writeStartElement("bk", "title", "https://example.com/books");
w.writeCharacters("XML Guide");
w.writeEndElement();   // title
w.writeEndElement();   // book

w.writeEndElement();   // books
w.writeEndDocument();
w.close();

StAX vs SAX

SAX empurra eventos ao seu handler; StAX deixa você puxar eventos sob demanda. O modelo pull do StAX facilita pular subárvores e gerenciar estado, e adiciona uma API de escrita. Ambos evitam construir uma árvore DOM completa, então servem para documentos grandes.

xml
<!-- StAX: PULL model  (client calls next())
     SAX:  PUSH model  (parser calls your handlers)

     StAX advantages:
       - client controls parsing (easy to skip sections)
       - simpler state management for many tasks
       - supports both reading and writing
       - can pause/resume naturally

     SAX advantages:
       - slightly lower overhead in pure streaming
       - mature, widely available
       - filters/chains via XMLFilter

     Both are streaming and memory-efficient. -->

Event Reader (API Iterator)

A API de iterator (XMLEventReader) retorna objetos XMLEvent que você pode espiar e consumir. É mais orientada a objetos que a API de cursor e mais fácil para filtrar ou dividir, mas um pouco mais pesada pela alocação de objetos de evento.

xml
import javax.xml.stream.*;
import javax.xml.stream.events.*;

XMLEventReader reader = XMLInputFactory.newInstance()
        .createXMLEventReader(in);

while (reader.hasNext()) {
    XMLEvent e = reader.peek();              // look without consuming
    if (e.isStartElement()) {
        StartElement se = e.asStartElement();
        System.out.println(se.getName());
    }
    XMLEvent consumed = reader.nextEvent();   // consume it
    if (consumed.isEndElement()) {
        System.out.println("closed");
    }
}
reader.close();
13

Conversão XML e JSON

XML para JSON (JavaScript)

fast-xml-parser converte XML para JSON em Node.js. Atributos recebem prefixo (padrão @_) e elementos repetidos viram arrays. A biblioteca é JavaScript puro e rápida, com opções para controlar arrays, números e booleanos.

xml
// Node.js with fast-xml-parser
const { XMLParser } = require("fast-xml-parser");

const xml = "<book id='b1'><title>XML</title><price>29.99</price></book>";
const parser = new XMLParser({
  ignoreAttributes: false,
  attributeNamePrefix: "@_",
});

const json = parser.parse(xml);
console.log(json.book["@_id"]);   // b1
console.log(json.book.title);     // XML
console.log(json.book.price);     // 29.99

JSON para XML (JavaScript)

XMLBuilder reverte a conversão. O prefixo @_ marca atributos e objetos aninhados viram elementos filhos. Arrays produzem elementos repetidos. A regra de raiz única do XML significa que o objeto JSON de nível superior deve mapear para um elemento raiz.

xml
const { XMLBuilder } = require("fast-xml-parser");

const json = {
  book: {
    "@_id": "b1",
    title: "XML Guide",
    price: 29.99,
  },
};

const builder = new XMLBuilder({
  format: true,
  attributeNamePrefix: "@_",
  ignoreAttributes: false,
});

const xml = builder.build(json);
console.log(xml);
// <book id="b1">
//   <title>XML Guide</title>
//   <price>29.99</price>
// </book>

xmltodict em Python

xmltodict trata XML como estruturas dict/list: atributos usam '@nome', texto usa '#text'. parse() lê XML, unparse() escreve. Ótimo para idas e voltas rápidas, mas perde ordem e alguns casos extremos de schemas complexos.

xml
import xmltodict, json

xml = """<book id="b1"><title>XML</title><price>29.99</price></book>"""

# XML -> dict
data = xmltodict.parse(xml)
print(data["book"]["@id"])      # b1
print(data["book"]["title"])    # XML

# dict -> JSON
print(json.dumps(data, indent=2))

# dict -> XML
xml_out = xmltodict.unparse({"book": {"@id": "b2", "title": "New"}})
print(xml_out)

Tratamento de Atributos e Texto

Converter XML para JSON força decisões sobre atributos (prefixo @_), texto (#text) e conteúdo misto. Conteúdo misto—texto intercalado com elementos filhos—não mapeia limpo para JSON e com frequência perde fidelidade. Escolha convenções e mantenha-as consistentes.

xml
<!-- XML with mixed attributes and text -->
<product sku="A1" stock="5">Widget<note>sale</note></product>

// fast-xml-parser output:
// {
//   product: {
//     "@_sku": "A1",
//     "@_stock": "5",
//     "#text": "Widget",
//     note: "sale"
//   }
// }

// Round-trip carefully: mixed content (text + elements)
// is hard to represent losslessly in JSON -->

Desafios da Conversão

Armadilhas comuns de conversão: filho único vs múltiplos (array vs string), ordem de elementos, prefixos de namespace (que são apelidos), a restrição de raiz única e a tipagem primitiva (XML não tem números nem booleanos nativos). Documente suas convenções.

xml
<!-- 1. Repeated elements -> array -->
<list><item>a</item><item>b</item></list>
// { list: { item: ["a", "b"] } }   (or single string if only one)

<!-- 2. Order is significant in XML but not in JSON objects -->
<a><x/><y/></a>   vs   <a><y/><x/></a>   // may differ

<!-- 3. Namespaces -->
<ns:elem xmlns:ns="http://x"/>   // prefixes are aliases

<!-- 4. Single root: JSON top-level must be one object -->
<!-- 5. Numbers/booleans: XML is all text; typing is heuristic -->

Exemplo de Ida e Volta

Ida e volta (XML -> JSON -> XML) funciona para dados bem estruturados, mas pode descartar comentários, instruções de processamento, limites de CDATA e espaços exatos. Para edição sem perdas, use uma API de DOM/árvore em vez de conversão via JSON.

xml
// Parse, modify, and re-serialize with fast-xml-parser
const { XMLParser, XMLBuilder } = require("fast-xml-parser");

const opts = { ignoreAttributes: false, attributeNamePrefix: "@_" };
const parser = new XMLParser(opts);
const builder = new XMLBuilder({ ...opts, format: true });

const obj = parser.parse(xmlString);
// mutate
obj.book.price = 19.99;
obj.book["@_onSale"] = "true";

const newXml = builder.build(obj);
console.log(newXml);
14

Feeds RSS e Atom

Estrutura do RSS 2.0

RSS 2.0 tem uma raiz <rss> com um <channel>. Campos obrigatórios do canal: title, link, description. Cada <item> tem title, link, description, guid, pubDate. As datas seguem RFC 822 (ex.: 'Wed, 02 Oct 2024 13:00:00 GMT').

xml
<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>My Blog</title>
    <link>https://example.com</link>
    <description>Recent posts</description>
    <language>en-us</language>
    <pubDate>Wed, 02 Oct 2024 13:00:00 GMT</pubDate>
    <item>
      <title>First Post</title>
      <link>https://example.com/1</link>
      <description>A short summary</description>
      <pubDate>Wed, 02 Oct 2024 12:00:00 GMT</pubDate>
      <guid>https://example.com/1</guid>
    </item>
  </channel>
</rss>

Canal e Item do RSS

Campos no nível do canal descrevem o feed (title, link, description, language, ttl, image). Campos do item descrevem cada entrada; enclosure suporta podcasts/mídia com URL, tamanho em bytes e tipo MIME. category pode carregar um atributo domain.

xml
<channel>
  <title>Site Title</title>
  <link>https://example.com</link>
  <description>What the feed is about</description>
  <category>Technology</category>
  <ttl>60</ttl>                          <!-- cache minutes -->
  <image>
    <url>https://example.com/logo.png</url>
    <title>Site Title</title>
    <link>https://example.com</link>
  </image>
  <item>
    <title>Post Title</title>
    <link>https://example.com/post</link>
    <description>Summary text</description>
    <author>[email protected]</author>
    <category domain="https://example.com/tags">xml</category>
    <enclosure url="https://example.com/p.mp3" length="12345"
               type="audio/mpeg"/>
  </item>
</channel>

Feed Atom

Atom (RFC 4287) usa uma raiz <feed> no namespace Atom. Obrigatórios: id, title, updated. Entradas precisam de id, title, updated. IDs devem ser globalmente únicos (URNs ou URIs tag:). As datas usam RFC 3339 (ISO 8601) com fuso horário.

xml
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <title>Example Feed</title>
  <link href="https://example.com/feed.atom" rel="self"/>
  <link href="https://example.com"/>
  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
  <updated>2024-10-02T13:00:00Z</updated>
  <author><name>Jane Doe</name></author>
  <entry>
    <title>Atom Entry</title>
    <id>tag:example.com,2024:/post/1</id>
    <updated>2024-10-02T12:00:00Z</updated>
    <summary>A short summary</summary>
    <content type="html">&lt;p&gt;Full post body&lt;/p&gt;</content>
  </entry>
</feed>

Detalhes das Entradas Atom

Entradas Atom suportam conteúdo rico: texto, html ou xhtml via o atributo type. link usa atributos rel (alternate, self, enclosure, related). category tem term/scheme/label. published é a data original; updated é a última alteração.

xml
<entry>
  <title type="text">Post Title</title>
  <id>tag:example.com,2024:/posts/42</id>
  <updated>2024-10-02T12:00:00Z</updated>
  <published>2024-10-01T09:00:00Z</published>
  <author>
    <name>Jane Doe</name>
    <email>[email protected]</email>
    <uri>https://example.com/jane</uri>
  </author>
  <link href="https://example.com/posts/42" rel="alternate"/>
  <category term="xml" scheme="https://example.com/tags" label="XML"/>
  <summary type="text">A teaser.</summary>
  <content type="xhtml">
    <div xmlns="http://www.w3.org/1999/xhtml"><p>Body</p></div>
  </content>
</entry>

Namespaces Comuns de Feeds

RSS costuma ser estendido com módulos: Dublin Core (dc:creator, dc:date), content (content:encoded para HTML completo), Media RSS (media:content) e o atom:link rel='self' que ajuda leitores a achar a URL do feed. Namespaces permitem que feeds misturem vocabulários.

xml
<?xml version="1.0"?>
<rss version="2.0"
     xmlns:content="http://purl.org/rss/1.0/modules/content/"
     xmlns:dc="http://purl.org/dc/elements/1.1/"
     xmlns:media="http://search.yahoo.com/mrss/"
     xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Feed</title>
    <link>https://example.com</link>
    <description>desc</description>
    <atom:link href="https://example.com/feed.xml" rel="self"
               type="application/rss+xml"/>
    <item>
      <title>Post</title>
      <dc:creator>Jane Doe</dc:creator>
      <content:encoded><![CDATA[<p>HTML body</p>]]></content:encoded>
      <media:content url="https://example.com/img.png" medium="image"/>
    </item>
  </channel>
</rss>

Validação de Feeds

Use o W3C Feed Validator para checar RSS/Atom. Erros comuns: campos obrigatórios faltando, formatos de data ruins, IDs não únicos, XML inválido (& não escapado) e self link ausente. Feeds válidos garantem que agregadores os analisem com confiabilidade.

xml
<!-- RSS: dates must be RFC 822, e.g. -->
<pubDate>Wed, 02 Oct 2024 13:00:00 GMT</pubDate>

<!-- Atom: dates must be RFC 3339, e.g. -->
<updated>2024-10-02T13:00:00Z</updated>

<!-- Validate online with https://validator.w3.org/feed/ -->
<!-- Required RSS channel fields: title, link, description -->
<!-- Required Atom feed fields: id, title, updated -->
<!-- GUIDs/IDs should be unique and permanent -->
15

SVG e XML

Estrutura de Documento SVG

SVG é um vocabulário XML para gráficos vetoriais. A raiz <svg> declara o namespace SVG e um viewBox para o sistema de coordenadas. Cada um dos elementos gráficos (rect, circle, text) são elementos XML com atributos de apresentação.

xml
<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink"
     width="200" height="200" viewBox="0 0 200 200">
  <rect x="10" y="10" width="180" height="180"
        fill="#005FAD" stroke="black" stroke-width="2"/>
  <circle cx="100" cy="100" r="40" fill="white"/>
  <text x="100" y="105" text-anchor="middle">SVG</text>
</svg>
<!-- SVG is an XML application; it must be well-formed -->

Namespace SVG e Imports

Elementos SVG vivem no namespace http://www.w3.org/2000/svg. xlink é usado para referências href (no SVG 1.1); o SVG 2 prefere href puro. defs guardam gradientes, patterns e symbols reutilizáveis, referenciados por id via url(#id).

xml
<?xml version="1.0"?>
<svg xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink"
     version="1.1">
  <defs>
    <linearGradient id="g1">
      <stop offset="0%" stop-color="red"/>
      <stop offset="100%" stop-color="blue"/>
    </linearGradient>
  </defs>
  <rect width="100" height="100" fill="url(#g1)"/>
</svg>

Formas SVG

Elementos de forma SVG: rect (com rx/ry para cantos arredondados), circle, ellipse, line, polyline (aberta) e polygon (fechada). As coordenadas estão nas unidades do usuário definidas pelo viewBox. stroke e fill são atributos de apresentação comuns.

xml
<svg xmlns="http://www.w3.org/2000/svg" width="300" height="200">
  <rect x="10" y="10" width="80" height="50" rx="10" fill="teal"/>
  <circle cx="150" cy="60" r="40" fill="orange"/>
  <ellipse cx="220" cy="60" rx="50" ry="20" fill="purple"/>
  <line x1="10" y1="120" x2="290" y2="120" stroke="black"/>
  <polyline points="10,180 50,140 90,180 130,140" fill="none" stroke="red"/>
  <polygon points="200,180 250,140 280,200" fill="green"/>
</svg>

Texto e Paths SVG

Texto SVG usa font-family, font-size, font-weight, font-style. tspan permite estilos mistos dentro de um elemento text. O atributo 'd' do elemento path usa comandos: M (mover), L (linha), C (Bézier cúbica), Q (quadrática), A (arco), Z (fechar caminho).

xml
<svg xmlns="http://www.w3.org/2000/svg" width="300" height="150">
  <text x="10" y="40" font-family="Arial" font-size="24"
        font-weight="bold" fill="navy">Hello SVG</text>

  <text x="10" y="80">
    <tspan font-size="16">Normal</tspan>
    <tspan font-size="16" font-style="italic"> italic</tspan>
  </text>

  <path d="M10 100 L 100 100 L 55 140 Z"
        fill="none" stroke="black" stroke-width="2"/>
</svg>
<!-- Path commands: M=move, L=line, H/V, C=cubic, Q=quad, A=arc, Z=close -->

Agrupamento e Reuso SVG

O elemento <g> agrupa formas para estilo e transformações compartilhados. <use> referencia um elemento por id (href='#id' no SVG 2, xlink:href no 1.1) e o clona numa nova posição. <symbol> define gráficos reutilizáveis que só são renderizados via <use>.

xml
<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200">
  <g id="node" stroke="black" fill="lightblue">
    <circle cx="50" cy="50" r="20"/>
    <circle cx="100" cy="50" r="20"/>
  </g>

  <use href="#node" x="0" y="100"/>
  <use href="#node" x="0" y="150" opacity="0.5"/>

  <symbol id="star" viewBox="0 0 24 24">
    <polygon points="12,2 15,9 22,9 17,14 19,21 12,17 5,21 7,14 2,9 9,9"/>
  </symbol>
  <use href="#star" width="24" height="24"/>
</svg>

Validação de SVG

Documentos SVG podem ser validados contra a DTD ou XSD do W3C. Problemas comuns: esquecer o namespace SVG, prefixos não declarados, atributos no namespace errado e dados de path malformados. xmllint é o validador padrão de linha de comando.

xml
<?xml version="1.0"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" version="1.1">
  <rect width="100" height="100"/>
</svg>

<!-- Validate with xmllint: -->
<!-- xmllint --noout --valid file.svg        (DTD) -->
<!-- xmllint --noout --schema svg11.xsd file.svg   (XSD) -->

<!-- Common errors: wrong namespace, undeclared prefixes,
     text outside a text element, invalid path data -->
16

SOAP e WSDL

Envelope SOAP

Uma mensagem SOAP é um documento XML com raiz <Envelope> no namespace SOAP. O <Header> opcional carrega metadados (auth, roteamento); o <Body> obrigatório guarda o payload real da mensagem. SOAP 1.1 e 1.2 usam namespaces diferentes.

xml
<?xml version="1.0"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Header>
    <auth xmlns="https://example.com/auth">
      <token>abc123</token>
    </auth>
  </soap:Header>
  <soap:Body>
    <m:GetPrice xmlns:m="https://example.com/pricing">
      <m:Item>Apples</m:Item>
    </m:GetPrice>
  </soap:Body>
</soap:Envelope>
<!-- Envelope is the root; Header is optional, Body is required -->

Header SOAP

Headers carregam informações fora da banda, como autenticação, endereçamento (WS-Addressing) e transações. soap:mustUnderstand='1' diz ao receptor que ele DEVE processar este header ou retornar uma SOAP fault—isso garante aderência ao contrato.

xml
<soap:Header xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <wsa:Action xmlns:wsa="http://www.w3.org/2005/08/addressing">
    http://example.com/GetPrice
  </wsa:Action>
  <wsa:MessageID>urn:uuid:1234</wsa:MessageID>
  <auth xmlns="https://example.com/auth"
        soap:mustUnderstand="1">
    <token>secret</token>
  </auth>
</soap:Header>
<!-- mustUnderstand="1" forces the receiver to process the header -->

Body e Fault SOAP

O Body carrega o payload da requisição ou resposta. Em erro, o Body contém um <Fault> com faultcode (Client/Server), um faultstring legível e detail opcional. SOAP 1.2 renomeia esses elementos e adiciona uma estrutura Code/Reason.

xml
<!-- Request body -->
<soap:Body>
  <m:GetPrice xmlns:m="https://example.com/pricing">
    <m:Item>Apples</m:Item>
  </m:GetPrice>
</soap:Body>

<!-- Fault (error response) -->
<soap:Body>
  <soap:Fault>
    <faultcode>soap:Client</faultcode>
    <faultstring>Unknown item: Apples</faultstring>
    <detail>
      <m:Error xmlns:m="https://example.com/pricing">
        <code>404</code>
      </m:Error>
    </detail>
  </soap:Fault>
</soap:Body>

Estrutura do WSDL

WSDL descreve um serviço web: <types> (schemas XSD), <message> (payloads de entrada/saída), <portType> (a interface—operações e suas mensagens), <binding> (protocolo/codificação) e <service> (URL do endpoint). WSDL 2.0 simplifica isso em interfaces e bindings.

xml
<?xml version="1.0"?>
<definitions xmlns="http://schemas.xmlsoap.org/wsdl/"
             xmlns:xs="http://www.w3.org/2001/XMLSchema"
             targetNamespace="https://example.com/pricing">
  <types>
    <xs:schema targetNamespace="https://example.com/pricing">
      <xs:element name="GetPriceRequest" type="xs:string"/>
      <xs:element name="GetPriceResponse" type="xs:decimal"/>
    </xs:schema>
  </types>
  <message name="GetPriceInput">
    <part name="item" element="tns:GetPriceRequest"/>
  </message>
  <portType name="PricingPort">
    <operation name="GetPrice">
      <input message="tns:GetPriceInput"/>
      <output message="tns:GetPriceOutput"/>
    </operation>
  </portType>
</definitions>

Binding e Service do WSDL

O binding mapeia um portType para um protocolo concreto (SOAP sobre HTTP) e um estilo (document/literal é o padrão moderno). O elemento service lista endpoints (soap:address). Document/literal envolve o payload num elemento definido pelo schema.

xml
<binding name="PricingSOAP" type="tns:PricingPort">
  <soap:binding style="document"
                transport="http://schemas.xmlsoap.org/soap/http"/>
  <operation name="GetPrice">
    <soap:operation soapAction="http://example.com/GetPrice"/>
    <input><soap:body use="literal"/></input>
    <output><soap:body use="literal"/></output>
  </operation>
</binding>

<service name="PricingService">
  <port name="PricingPort" binding="tns:PricingSOAP">
    <soap:address location="https://example.com/pricing"/>
  </port>
</service>
<!-- style: rpc or document; use: encoded or literal -->

SOAP vs REST

SOAP é um protocolo com envelope XML estrito, contrato WSDL e padrões WS-* (segurança, transações); melhor para integrações corporativas que exigem confiabilidade e contratos formais. REST é um estilo leve baseado em HTTP, geralmente com JSON, que domina as APIs públicas.

xml
<!-- SOAP: protocol with envelope, strict contract (WSDL),
     built-in error model (Fault), WS-* extensions.
     Heavier, XML-only, common in enterprise/B2B. -->

<!-- REST: architectural style using HTTP verbs (GET/POST/...),
     flexible payloads (often JSON), no built-in contract.
     Lighter, browser-friendly, dominant on the web. -->

<!-- When to use SOAP:
     - you need strict contracts and tooling
     - transactional reliability (WS-ReliableMessaging)
     - standardized security (WS-Security)
     - existing SOAP-based infrastructure -->

<!-- When to use REST:
     - public APIs, mobile/web clients
     - JSON payloads, HTTP caching
     - simpler, faster iteration -->
17

Assinatura Digital XML

Estrutura da Assinatura

A raiz <Signature> de uma XML Signature contém <SignedInfo> (o que é assinado e como), <SignatureValue> (a assinatura criptográfica sobre o SignedInfo canonizado), <KeyInfo> opcional e <Object>s com os dados referenciados.

xml
<?xml version="1.0"?>
<Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
  <SignedInfo>
    <CanonicalizationMethod Algorithm="..."/>
    <SignatureMethod Algorithm="..."/>
    <Reference URI="#data">
      <DigestMethod Algorithm="..."/>
      <DigestValue>...</DigestValue>
    </Reference>
  </SignedInfo>
  <SignatureValue>...</SignatureValue>
  <KeyInfo>...</KeyInfo>
  <Object Id="data">signed content</Object>
</Signature>
<!-- A signature = SignedInfo + SignatureValue + optional KeyInfo -->

SignedInfo

SignedInfo especifica a canonicalização (para que a assinatura byte a byte sobreviva à re-serialização do XML), o algoritmo de assinatura e uma ou mais References. Cada Reference aponta para dados via URI, lista Transforms e dá um DigestValue desses dados.

xml
<SignedInfo xmlns="http://www.w3.org/2000/09/xmldsig#">
  <CanonicalizationMethod
      Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
  <SignatureMethod
      Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
  <Reference URI="">
    <Transforms>
      <Transform Algorithm="...enveloped-signature"/>
    </Transforms>
    <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
    <DigestValue>base64digest==</DigestValue>
  </Reference>
</SignedInfo>

Reference e Transforms

Cada Reference identifica o que assinar (URI), aplica Transforms (canonicalização, filtragem XPath, remoção de enveloped-signature) e então gera o hash com DigestMethod. A transform enveloped-signature exclui o próprio elemento Signature do seu próprio hash.

xml
<Reference URI="#order">
  <Transforms>
    <Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
    <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
    <XPath xmlns="...">not(ancestor-or-self::ds:Signature)</XPath>
  </Transforms>
  <DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/>
  <DigestValue>abc123base64==</DigestValue>
</Reference>

<!-- Reference types:
     - same-document (URI="#id")
     - external (URI="https://...")
     - detached (URI pointing elsewhere) -->

SignatureValue e KeyInfo

SignatureValue é o resultado base64 de assinar o SignedInfo canonizado com a chave privada do assinante. KeyInfo é OPCIONAL e só dá uma dica de como achar a chave de verificação (certificado X.509, chave pública RSA, nome da chave ou URL de recuperação)—precisa ser validada fora da banda.

xml
<SignatureValue>base64encodedSignature==</SignatureValue>

<KeyInfo>
  <X509Data>
    <X509SubjectName>CN=Example,O=Example Inc</X509SubjectName>
    <X509Certificate>MIID...base64...==</X509Certificate>
  </X509Data>
</KeyInfo>

<!-- Other KeyInfo options: -->
<!--   <KeyName>key-id</KeyName> -->
<!--   <KeyValue><RSAKeyValue>...</RSAKeyValue></KeyValue> -->
<!--   <RetrievalMethod URI="..."/> -->
<!-- KeyInfo is optional and unverified by itself -->

Canonicalização

A canonicalização converte um conjunto de nós XML em bytes estáveis, para que a assinatura seja reproduzível apesar de diferenças irrelevantes (ordem de atributos, CDATA). Exclusive c14n (xml-exc-c14n) é preferido em assinaturas porque delimita os namespaces à subárvore assinada.

xml
<!-- Two documents that are logically identical may differ in bytes:
     - attribute order
     - namespace declarations
     - CDATA vs escaping
     - whitespace outside elements
     Canonical XML (c14n) produces a canonical byte form. -->

<CanonicalizationMethod
    Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>

<!-- Exclusive c14n (recommended for signatures): -->
<CanonicalizationMethod
    Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>

<!-- Exclusive form avoids leaking inherited namespace declarations
     into the signed digest, preventing wrapping attacks. -->

Assinatura Enveloped

Uma assinatura enveloped fica embutida no documento que assina (o mais comum para XML). A transform enveloped-signature remove o elemento <Signature> antes do hash, para que a assinatura não faça parte do próprio digest. Também existem as variantes detached e enveloping.

xml
<?xml version="1.0"?>
<order Id="order">
  <item>Widget</item>
  <Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
    <SignedInfo>
      <CanonicalizationMethod Algorithm="...exc-c14n#"/>
      <SignatureMethod Algorithm="...rsa-sha256"/>
      <Reference URI="#order">
        <Transforms>
          <Transform Algorithm="...enveloped-signature"/>
        </Transforms>
        <DigestMethod Algorithm="...sha256"/>
        <DigestValue>...</DigestValue>
      </Reference>
    </SignedInfo>
    <SignatureValue>...</SignatureValue>
  </Signature>
</order>
<!-- The signature lives INSIDE the signed element -->
19

Convenções de Nomeação

Nomeação de Elementos

Escolha um estilo e aplique-o consistentemente. Minúsculas com hífens são comuns em vocabulários XML (HTML, SVG). Nomes devem ser descritivos o bastante para não serem ambíguos, mas concisos. Evite abreviações crípticas e nomes verbosos demais.

xml
<!-- Good: lowercase, hyphen-separated, descriptive -->
<customer-address>
  <street>123 Main St</street>
  <postal-code>12345</postal-code>
</customer-address>

<!-- Avoid: abbreviations that are unclear -->
<!-- <cust-addr><pc>...</pc></cust-addr> -->

<!-- Avoid: too long -->
<!-- <customerMailingPostalAddressCode> -->

<!-- Be consistent across the whole vocabulary -->

Nomeação de Atributos

Atributos servem para metadados (id, type, href, status). Siga o estilo de nomeação dos elementos. Booleanos carregam valores explícitos. Não prefixe um atributo com o nome do elemento (user-id em <user> é redundante). Use 'id' para identificadores únicos.

xml
<product sku="A1" unit-price="9.99" in-stock="true">
  <name>Widget</name>
</product>

<!-- Conventions:
     - attributes are metadata: id, type, href, status
     - use lowercase-hyphen style to match elements
     - boolean attributes still carry a value ("true"/"false")
     - avoid repeating the element name: <user user-id="..."/>
       prefer <user id="..."/> -->

<!-- IDs: use 'id' or '<element>-id' for clarity -->

URIs e Prefixos de Namespace

URIs de namespace são identificadores, não URLs para baixar, mas devem ser estáveis e sob sua posse (use HTTPS num domínio que você controla). Prefixos são apelidos locais—mantenha-os curtos e convencionais. Versione a URI quando o schema mudar de forma incompatível.

xml
<!-- Namespace URIs should be stable, owned, and permanent -->
xmlns:bk  = "https://example.com/ns/books/2024"
xmlns:auth= "https://example.com/ns/auth"

<!-- Prefix conventions:
     - short and mnemonic: xs, xsi, xsl, svg, html, dc
     - lowercase, no punctuation beyond letters
     - 'tns' commonly means 'this namespace' in XSD
     - avoid 'xml' (reserved) -->

<!-- Version the URI when the vocabulary changes incompatibly:
     .../ns/books/2024  vs  .../ns/books/2025 -->

Estilos de Caixa

Estilos de caixa comuns em XML: PascalCase (XSD/WSDL, .NET), camelCase (derivado de JSON, Java), minúsculas-com-hífens (HTML/SVG, amigável a REST), snake_case (raro). A regra crucial é a consistência dentro de um vocabulário—misturar estilos confunde.

xml
<!-- PascalCase (UpperCamelCase): common in XSD/WSDL, .NET -->
<OrderRequest>
  <CustomerId>123</CustomerId>
</OrderRequest>

<!-- camelCase: common in JSON-derived XML, Java ecosystems -->
<orderRequest>
  <customerId>123</customerId>
</orderRequest>

<!-- lowercase-with-hyphens: HTML5, SVG, REST-friendly -->
<order-request>
  <customer-id>123</customer-id>
</order-request>

<!-- snake_case: rare in XML, used in some Python/SQL ecosystems -->
<order_request><customer_id>123</customer_id></order_request>

Versionamento

Versione vocabulários XML explicitamente: um atributo version na raiz é o mais simples; uma URI de namespace versionada é o mais rigoroso (mudanças incompatíveis ganham URI nova). Decida o que conta como mudança menor (aditiva) vs maior (quebradora) e documente.

xml
<!-- Versioning strategies -->

<!-- 1. Attribute on the root -->
<catalog version="2.0">...</catalog>

<!-- 2. Versioned namespace URI -->
<catalog xmlns="https://example.com/ns/catalog/v2">...</catalog>

<!-- 3. Versioned root element name -->
<catalog-v2>...</catalog-v2>

<!-- Backward-compatible changes: add optional elements/attributes
     Incompatible changes: bump the version (and/or namespace) -->

<!-- Document the policy: which changes are "minor" vs "major" -->

Convenções de Arquivo e Extensão

Use extensões reconhecidas para que ferramentas e pessoas identifiquem os tipos de arquivo. O atributo encoding da declaração XML deve corresponder à codificação real dos bytes; UTF-8 é o padrão seguro. BOMs são desencorajados para XML UTF-8.

xml
<!-- Common file extensions:
     .xml   generic XML
     .xsd   XML Schema
     .xsl   XSLT stylesheet
     .xslt  XSLT (alternate)
     .dtd   Document Type Definition
     .rss   RSS feed
     .atom  Atom feed
     .svg   SVG graphic
     .wsdl  WSDL service description
     .xhtml XHTML document
     .plist Apple property list -->

<!-- XML files are UTF-8 by default; declare encoding if different:
     <?xml version="1.0" encoding="UTF-8"?> -->
20

Boas Práticas

Boa Formação Primeiro

Um documento precisa estar bem formado antes que qualquer ferramenta o processe. Valide com um parser cedo: xmllint --noout file.xml reporta o primeiro erro. Boa formação é inegociável; validade contra um schema é uma camada adicional e opcional.

xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <child>properly nested &amp; escaped</child>
</root>

<!-- Always ensure well-formedness before worrying about validity:
     - exactly one root element
     - all tags closed and properly nested
     - attributes quoted and unique per element
     - & < escaped (and > in some contexts)
     - valid encoding declaration -->

Validação e Schemas

Valide contra um schema para capturar erros estruturais. XSD é a escolha mais comum para vocabulários tipados e com namespaces; Schematron o complementa com regras de negócio. xsi:noNamespaceSchemaLocation liga um doc ao seu XSD; use xsi:schemaLocation para schemas com namespace.

xml
<!-- Choose a schema language:
     - DTD:      simple, built-in, limited types
     - XSD:      rich types, namespaces, industry standard
     - RelaxNG:  compact syntax, flexible patterns
     - Schematron: rule-based business constraints -->

<?xml version="1.0"?>
<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:noNamespaceSchemaLocation="schema.xsd">
  <item>valid</item>
</root>

<!-- Validate during development; consider it at runtime for
     untrusted input. -->

Codificação (UTF-8)

UTF-8 é a codificação padrão e recomendada para XML—trata o Unicode inteiro sem entidades. Sempre declare a codificação e salve o arquivo nessa codificação. Evite BOMs; para caracteres especiais você também pode usar referências numéricas de caracteres.

xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <msg>Café — résumé — 中文 — emoji 🙂</msg>
</root>

<!-- Always declare UTF-8 and save the file as UTF-8.
     Avoid legacy encodings (ISO-8859-1) unless required.
     Do not add a UTF-8 BOM (some parsers mishandle it).
     For non-UTF-8 encodings, declare them accurately. -->

Legibilidade e Indentação

Indentação consistente (2 espaços é comum) torna o XML legível e os diffs limpos. Evite linhas únicas longas. Ferramentas como 'xmllint --format' ou um formatador XML podem normalizar espaços—mas lembre de que regiões com xml:space='preserve' não devem ser reformatadas.

xml
<?xml version="1.0"?>
<catalog>
  <book id="b1">
    <title>XML Guide</title>
    <author>Jane Doe</author>
  </book>
  <book id="b2">
    <title>Advanced XML</title>
    <author>John Smith</author>
  </book>
</catalog>

<!-- Use 2-space indentation; one element per line for mixed
     or deep structures. Tools: xmllint --format, prettier. -->

Desempenho

Para arquivos grandes, prefira parsers de streaming (SAX/StAX) a DOM para manter a memória baixa. Desative o carregamento de DTDs e entidades externas, a menos que precise. Compile expressões XPath uma vez e reutilize-as. Para sistemas internos, considere formatos binários compactos para cortar tamanho e tempo de análise.

xml
<!-- Parsing large XML efficiently:
     - use SAX/StAX (streaming) instead of DOM for big files
     - disable DTD/external entities if you don't need them
     - validate once, not on every read
     - reuse parser instances (factory creation is costly)
     - consider binary formats (protobuf, CBOR) for internal traffic -->

<!-- Java StAX with XXE disabled:
     factory.setProperty(XMLInputFactory.SUPPORT_DTD, false); -->

<!-- For repeated XPath, compile once and reuse the expression -->

Segurança (XXE)

Ataques XML External Entity (XXE) abusam de entidades externas de DTD para ler arquivos, disparar SSRF ou causar negação de serviço (billion laughs/expansão de entidades). A defesa mais forte é desativar completamente DTDs e resolução de entidades externas, a menos que seu caso de uso exija.

xml
<?xml version="1.0"?>
<!DOCTYPE root [
  <!-- XXE: attacker forces the parser to read a local file -->
  <!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<root>&xxe;</root>

<!-- Defenses (do ALL that apply):
     1. Disable DTDs entirely if you don't need them.
     2. Disable external entity resolution.
     3. Disable XInclude.
     4. Validate input; limit entity expansion (billion laughs). -->

<!-- Python: defusedxml
     Java:  XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES = false
     PHP:   libxml_disable_entity_loader(true) -->

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.