Skip to content

XML Spickzettel

Extensible Markup Language für strukturierten Datenaustausch.

01

Erste Schritte

XML-Dokumentstruktur

XML-Dokumente beginnen mit einer XML-Deklaration. Elemente müssen korrekt verschachtelt und geschlossen sein. Attribute liefern zusätzliche Metadaten. xmlns deklariert XML-Namensräume, um Namenskonflikte zu vermeiden.

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>

XML-Deklaration

Die XML-Deklaration ist die erste Zeile des Prologs. 'version' ist Pflicht (1.0 oder 1.1). 'encoding' ist standardmäßig UTF-8. 'standalone' sagt Parsern, ob externe DTD-Deklarationen nötig sind.

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>

Kommentare & Verarbeitungshinweise

Kommentare nutzen <!-- --> und dürfen nicht verschachteln oder '--' innen enthalten. Verarbeitungshinweise (PIs) wie xml-stylesheet reichen App-spezifische Infos an den Parser weiter. PIs nutzen <?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>

Wohlgeformtes XML

Wohlgeformt heißt: ein Root-Element, korrekte Verschachtelung, alle Tags geschlossen, Attribute quotiert, keine doppelten Attribute. Ein Dokument MUSS wohlgeformt sein, um parsebar zu sein; Validität (gegen ein DTD/Schema) ist optional.

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"/>

XML-Prolog & Whitespace

Der Prolog schließt die XML-Deklaration und ein optionales DOCTYPE ein. xml:space='preserve' sagt Parsern, Whitespace zu erhalten; 'default' erlaubt normale Behandlung. Whitespace zwischen Elementen ist generell unbedeutend.

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>

CDATA-Überblick

CDATA-Abschnitte markieren Text, den der Parser nicht als Markup interpretieren soll. Innerhalb von CDATA brauchen Zeichen wie <, > und & kein Escaping. CDATA darf nicht verschachteln und nicht das literale ']]>' enthalten.

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

Elemente & Attribute

Elemente vs. Attribute

Attribute passen zu Metadaten (ids, Typen, Flags); Elemente zu Daten mit Struktur oder wiederholten Werten. Ein Attribut erscheint einmal pro Element und kann keine verschachtelte Struktur halten. Es gibt keine strenge Regel — Konsistenz zählt am meisten.

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

Leere Elemente

Ein leeres Element hat keinen Inhalt. Die selbstschließende Form <tag/> ist die Kurzform von <tag></tag>. Das Leerzeichen vor '/>' ist eine Stil-Konvention für Lesbarkeit und XHTML-Kompatibilität.

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"/>

Verschachtelte Elemente

Elemente verschachteln hierarchisch und müssen in umgekehrter Reihenfolge schließen — sie dürfen sich nicht überlappen. Verschachtelung drückt Struktur aus. Tief verschachtelte Bäume sind gültig, können aber Lesbarkeit und Parsing-Performance schädigen.

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

Attributwerte & Anführungszeichen

Attributwerte müssen mit einfachen oder doppelten Anführungszeichen quotiert sein. Doppelte Anführungszeichen innerhalb doppelt quotierter Werte müssen als &quot; escapet werden. Ein Attribut darf nur einmal pro Element erscheinen — Kind-Elemente für wiederholte Werte nutzen.

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"/>

Default- & Fixed-Attribute

DTD-Attributdeklarationen unterstützen #REQUIRED (muss erscheinen), #IMPLIED (optional), #FIXED (Konstantwert) und einen literalen Default. Ein #FIXED-Attribut muss immer seinem deklarierten Wert entsprechen, sonst ist das Dokument ungültig.

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

Elementnamensregeln

Elementnamen müssen mit einem Buchstaben oder Unterstrich beginnen und dürfen Buchstaben, Ziffern, Bindestriche, Unterstriche und Punkte enthalten. Namen dürfen nicht mit 'xml' beginnen (unabhängig von der Schreibweise). XML ist schreibabhängig, <Tag> und <tag> unterscheiden sich also.

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

Namensräume

Standard-Namensraum

Ein Standard-Namensraum (xmlns=URI) gilt für das Element, auf dem er deklariert ist, und alle unpräfixierten Nachkommen. Kindelemente erben ihn, außer er wird überschrieben. Attribute nutzen nie den Standard-Namensraum.

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

Namensraum-Präfix

Ein Namensraum-Präfix wird mit xmlns:prefix=URI deklariert und als prefix:element genutzt. Das Präfix ist nur ein Alias — für die Identität zählt nur der URI. Präfixe sind schreibabhängig.

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>

Mehrere Namensräume

Ein einzelnes Dokument kann viele Namensräume mischen. Jedes Präfix einmal deklarieren (meist am Root) und wiederverwenden. Einen Namensraum auf einem Element zu deklarieren gilt für dieses Element und seine Nachkommen.

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>

Namensraum-Scope

Namensraum-Deklarationen sind auf das Element begrenzt, auf dem sie erscheinen, und dessen Nachkommen. Eine Neudeklaration in einem Kind überschreibt die Präfix-Zuordnung des Parents für diesen Teilbaum. Die ursprüngliche Zuordnung kehrt zurück, nachdem das Kind schließt.

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>

Häufige Namensräume

Diese URIs sind bekannte Bezeichner, keine URLs, die abgerufen werden müssten. Der xsi-Namensraum liefert schema-instance-Attribute (type, nil, schemaLocation). XSD, XSL, SVG, SOAP, Atom und Dublin Core (dc) haben jeweils Standard-URIs.

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/"

Ziel-Namensraum in XSD

Das targetNamespace eines Schemas ist der Namensraum der Elemente, die es definiert. elementFormDefault='qualified' heißt, lokal deklarierte Elemente liegen im Ziel-Namensraum. Der tns-Präfix ist eine Konvention für 'dieser Namensraum'.

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 & Entities

Vordefinierte Entities

XML definiert fünf Entities vor: &lt; (<), &gt; (>), &amp; (&), &apos; ('), &quot; ("). & muss IMMER escapet werden (auch in CDATA-freiem Text); < muss escapet werden, außer als Taganfang; Anführungszeichen zählen vor allem in Attributen.

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>

Zeichenreferenzen

Zeichenreferenzen nutzen einen Unicode-Codepoint: &#169; (dezimal) oder &#xA9; (hex) für ©. Sie funktionieren in Elementtexten und Attributwerten und sind von der Kodierung unberührt. Sie können jedes Unicode-Zeichen repräsentieren.

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

CDATA-Abschnitte

CDATA-Abschnitte erlauben <, > und & ohne Escaping — nützlich für Code und Markup. CDATA darf ']]>' nicht literal enthalten; zum Einbetten den Abschnitt wie gezeigt splitten. CDATA ist Zeichendaten, nicht als Elemente geparst.

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>

Eigene Entities (DTD)

Interne Entities werden in einer DTD deklariert und überall dort expandiert, wo sie referenziert werden. Sie wirken wie Textmakros und dürfen andere Entities referenzieren. Nützlich für wiederholten Boilerplate. Vorsicht: externe/allgemeine Entities können ein XXE-Sicherheitsrisiko sein.

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

Escaping in Attributen

Innerhalb von Attributwerten musst du & als &amp; escapen und das Anführungszeichen escapen, das den Wert begrenzt (&quot; oder &apos;). < sollte ebenfalls escapet werden. Zeilenumbrüche und Tabs in Attributen werden vom Parser zu Leerzeichen normalisiert.

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>

Parameter-Entities

Parameter-Entities (deklariert mit %) werden nur innerhalb von DTDs genutzt, um wiederverwendbare Inhaltsmodelle zu bauen. Sie werden als %name; (mit Semikolon) referenziert. Allgemeine Entities (&name;) werden im Dokumentinhalt genutzt.

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)

Internes DTD

Ein internes DTD wird inline im DOCTYPE in eckigen Klammern deklariert. Es definiert die Struktur: welche Elemente existieren, ihre Inhaltsmodelle und Attribute. Interne DTDs sind in sich geschlossen, gelten aber nur für dieses eine Dokument.

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>

Externes DTD

Ein externes DTD liegt in einer separaten .dtd-Datei, referenziert per SYSTEM (privat) oder PUBLIC (öffentlicher Bezeichner + URI). Externe DTDs lassen viele Dokumente eine Definition teilen. SYSTEM 'file.dtd' ist die häufigste Form.

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>

Elementdeklarationen

Inhaltsmodelle nutzen , (Sequenz), | (Auswahl), ? (0-1), * (0+), + (1+). #PCDATA ist Text; gemischter Inhalt erlaubt Text, verschränkt mit Elementen. EMPTY heißt kein Inhalt; ANY deaktiviert die Prüfung (in Produktion vermeiden).

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

Attributdeklarationen

ATTLIST deklariert Typ und Default eines Attributs. ID ist ein eindeutiger Bezeichner; IDREF/IDREFS referenzieren IDs (für Querverweise). NMTOKEN ist ein Namens-Token. Aufzählende Typen listen erlaubte Werte. Defaults: #REQUIRED, #IMPLIED, #FIXED oder ein 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>

Entity-Deklarationen

Allgemeine Entities (&name;) expandieren im Inhalt; Parameter-Entities (%name;) in der DTD. Externe geparste Entities schließen anderes XML ein; ungeparste Entities (mit NDATA) zeigen auf Nicht-XML-Daten, referenziert via NOTATION. Externe Entities können XXE-Injection verursachen.

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>

DTD-Validierung

Validierung prüft, dass ein Dokument seinem DTD entspricht (Elementreihenfolge, erlaubte Attribute, ID-Eindeutigkeit). Standard-DOM-Parser wie minidom validieren NICHT standardmäßig — lxml (Python), xmllint (Befehlszeile) oder einen validierenden Parser nutzen.

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)

Schema-Struktur

Ein XSD ist selbst ein XML-Dokument. Das Root-<schema> deklariert den XSD-Namensraum und einen Ziel-Namensraum für die Elemente, die es definiert. elementFormDefault='qualified' legt lokale Elemente in den Ziel-Namensraum.

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>

Einfache Typen

Ein simpleType beschränkt einen Basistyp mit Facetten (pattern, minInclusive, enumeration, length usw.). Einfache Typen haben nur Textinhalt und Attribute — keine Kindelemente. Sie sind schemaübergreifend wiederverwendbar.

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"/>

Komplexe Typen

Ein complexType kann Kindelemente und Attribute halten. sequence erzwingt die Reihenfolge; choice erlaubt eines von mehreren; all erlaubt jede Reihenfolge (jeweils höchstens einmal). Compositors verschachteln sich, um reichhaltige Strukturen auszudrücken.

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>

Eingebaute Typen

XSD liefert eine reichhaltige Typhierarchie: Strings, Zahlen (integer, decimal, float), Daten/Zeiten, boolean, anyURI, ID/IDREF und QName. Jeder unterstützt Facetten wie length, pattern und enumeration zur weiteren Beschränkung.

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"/>

Einschränkungen (Facetten)

Facetten beschränken einfache Typen: enumeration (erlaubte Werte), pattern (regex), length/minLength/maxLength, min/maxInclusive/Exclusive, totalDigits, fractionDigits und 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>

Elemente & Attribute in XSD

minOccurs/maxOccurs steuern die Kardinalität (Standard 1); maxOccurs='unbounded' erlaubt eine beliebige Zahl. Attribut-'use' ist required/optional/prohibited, mit optionalem default oder fixed-Wert. Anonyme komplexe Typen inlinen die Definition.

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

Pfadausdrücke

XPath nutzt pfadartige Ausdrücke. '/' wählt von der Wurzel; '//' wählt Nachfahren in beliebiger Tiefe. '*' ist eine Wildcard für jedes Element; '@' wählt Attribute. Ein mit '/' beginnender Ausdruck ist absolut.

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

Prädikate

Prädikate in [ ] filtern eine Knotenmenge. Die Indexierung ist 1-basiert. last() und position() verweisen auf die Position des Knotens in seinem Kontext. Prädikate können Elementtext, Attribute (@name) oder berechnete Werte prüfen.

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

Achsen

Achsen definieren Navigationsrichtungen: child (Standard), descendant, parent (..), ancestor, following-sibling, preceding-sibling, attribute (@), self (.), descendant-or-self (//). Die meisten haben in der Praxis genutzte Kurzformen.

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: .) -->

Funktionen

XPath 1.0 hat eingebaute Funktionen: count, sum, string-length, contains, starts-with, normalize-space, name, concat, substring, round und mehr. XPath 2.0+ erweitert die Funktionsbibliothek enorm und ergänzt Typisierung.

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

Operatoren

XPath nutzt = für Gleichheit (einzelnes =, nicht ==) und die Operatoren 'and'/'or' für Logik (nicht && / ||). 'div' ist Division und 'mod' Modulo, da '/' für Pfade reserviert ist. '|' berechnet die Vereinigung von Knotenmengen.

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

XPath-Beispiele

Diese Muster kombinieren Pfade, Prädikate und Funktionen für echte Abfragen. text() wählt den Textknoten; min() verlangt XPath 2.0+. Die //*Wildcard mit einem Prädikat ist ein üblicher Weg, Elemente nach Attribut im ganzen Baum zu finden.

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

XSLT-Transformationen

Einfache Transformation

Ein XSLT-Stylesheet ist XML. Templates matchen Knoten mit XPath; apply-templates verarbeitet gewählte Knoten rekursiv. value-of extrahiert Text. Das match='/'-Template läuft zuerst, am Dokumentroot.

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 & apply-templates

match-Templates feuern, wenn der Prozessor passende Knoten besucht; benannte Templates werden explizit mit call-template aufgerufen. apply-templates ohne select verarbeitet alle Kinder und ermöglicht so rekursive, regelgetriebene Transformationen.

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 & xsl:for-each

xsl:for-each iteriert eine Knotenmenge und ändert den Kontextknoten. Für flache Ausgaben ist er oft einfacher als Templates, aber Übergebrauch macht Stylesheets prozedural. Für rekursive Strukturen Templates und apply-templates bevorzugen.

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 & xsl:choose

xsl:if hat kein else — für Mehrweg-Verzweigungen xsl:choose nutzen. Der 'test'-Ausdruck folgt XPaths booleschen Regeln: eine nicht-leere Knotenmenge ist wahr, eine leere falsch, Zahlen ungleich Null sind wahr.

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 & xsl:variable

xsl:sort ordnet die aktuelle Knotenmenge nach einem oder mehreren Schlüsseln neu; data-type ist 'text' oder 'number'. Variablen (xsl:variable) sind unveränderlich und begrenzt. Denken, < innerhalb von Attributwerten im Stylesheet-XML als &lt; zu escapen.

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 & modes

Modes lassen dieselbe Menge Quellknoten auf verschiedene Weise verarbeiten (z. B. ein Inhaltsverzeichnis vs. vollständige Einträge). Das mode-Attribut an Template und apply-templates muss übereinstimmen. Ohne mode greifen nur no-mode-Templates.

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

FLWOR-Ausdrücke

FLWOR ist XQuery's Kernkonstrukt: for bindet Variablen an Sequenzelemente, let bindet berechnete Werte, where filtert, order by sortiert und return formt die Ausgabe. Er ähnelt SQL's SELECT-FROM-WHERE.

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

Pfadausdrücke

XQuery bettet XPath direkt ein. doc('file.xml') lädt ein Dokument; collection('uri') fragt mehrere Dokumente ab. Pfadausdrücke liefern Knotensequenzen, über die FLWOR-Ausdrücke iterieren können.

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

Prädikate & Joins

Mehrere 'for'-Klauseln bilden einen Join (wie SQL JOIN). XQuery führt Joins aus, indem er Kombinationen iteriert und mit where filtert. Bei großen Datensätzen sind explizite Joins über Prädikate oder Schlüssel effizienter als verschachtelte Schleifen.

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>

Bedingungen & Quantifikatoren

XQuery hat if-then-else (das else ist Pflicht), quantifizierte Ausdrücke (some/every ... satisfies) und typeswitch zum Verzweigen nach Knotentyp. Bedingungen nutzen XPath-artige boolesche Semantik.

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"

Funktionen

XQuery wiederverwendet XPath-Funktionen und ergänzt viele (string-join, distinct-values, avg, min, max). Eigene Funktionen werden im Modul mit Parameter- und Rückgabetypen deklariert, konventionsgemäß im local:-Namensraum.

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)

XML konstruieren

XQuery baut XML mit direkten Konstruktoren (literale Tags mit { } für eingebettete Ausdrücke) oder berechneten Konstruktoren (element name { ... }). Geschweifte Klammern werten umschließende Ausdrücke aus; Attribute können Werte inline einbetten.

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

DOM-Parsing

XML laden (JavaScript)

DOMParser verwandelt im Browser einen XML-String in einen DOM-Baum; Parsefehler erscheinen als <parsererror>-Element statt einer Ausnahme. Node.js hat kein eingebautes XML-DOM — xmldom, @xmldom/xmldom oder einen Streaming-Parser nutzen.

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

DOM-Traversierung

Die DOM-API legt documentElement, children, childNodes und nextSibling für die Traversierung offen. nodeType 1 ist ein Element, 3 Text, 8 ein Kommentar. document.evaluate führt XPath in Browsern aus (Node braucht xpath-Bibliotheken).

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();

DOM ändern

createElement/setAttribute/appendChild bauen Knoten und hängen sie an; textContent setzt Text. XMLSerializer verwandelt ein DOM zurück in einen String. Das DOM ist live — Mutationen spiegeln sich sofort in allen Referenzen.

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);

Elemente erzeugen

minidom erlaubt es, ein Dokument von Grund auf zu bauen: createDocument für den Root, createElement/setAttribute/createTextNode für Inhalte, appendChild zum Verknüpfen. toprettyxml serialisiert mit Einrückung. minidom ist einfach, aber bei großen Bäumen langsam.

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())

Java-DOM-Parsing

Javas JAXP-DOM lädt das ganze Dokument via DocumentBuilder in den Speicher. setNamespaceAware(true) erhält Namensraum-Präfixe. Das DOM ist bequem für wahlfreien Zugriff, aber bei großen Dateien speicherhungrig — dann lieber StAX/SAX.

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 ist ein schnelles, funktionsreiches Python-Binding für libxml2. Er unterstützt volles XPath, XSLT, Validierung (DTD/XSD/RelaxNG) und inkrementelles Parsen. Sein ElementPath (find/findall) ist eine XPath-Teilmenge; für volles XPath xpath() nutzen.

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

SAX-Parsing

SAX-Handler (Python)

SAX ist ereignisgetrieben und streamend: Der Parser ruft startElement, characters und endElement auf, während er liest, und baut nie einen vollen Baum. Er ist speichereffizient bei riesigen Dateien. Den Zustand (etwa das aktuelle Element) musst du selbst tracken.

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())

SAX-Event-Methoden

ContentHandler-Callbacks markieren Dokument- und Elementgrenzen. characters() kann einen einzelnen Textknoten in mehrere Aufrufe splitten — in einen Buffer akkumulieren. startPrefixMapping/endPrefixMapping melden Namensraum-Deklarationen.

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

Einen Elementpfad zu tracken (ein Stack) ist der Standardweg, um beim Streaming den Ort zu kennen. characters()-Ausgabe puffern und in endElement spülen, denn characters kann mehr als einmal pro Textknoten feuern.

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)

Java-SAX-Parser

Java-SAX erweitert DefaultHandler. startElement erhält Namensraum-URI, lokalen Namen, qualifizierten Namen und ein Attributes-Objekt. characters(ch, start, len) liefert einen char-Ausschnitt — puffern, denn ein Textknoten kann sich über mehrere Aufrufe erstrecken.

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 streamt Events mit konstantem Speicher, ideal für riesige Dateien und Ein-Durchlauf-Extraktion. DOM lädt den ganzen Baum, erlaubt XPath und wahlfreie Mutation, nutzt aber Speicher proportional zur Dateigröße. Nach Zugriffsmuster und Dateigröße wählen.

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

Fehlerbehandlung (SAX)

Ein ErrorHandler empfängt Warnungen, behebbare Fehler und fatale Fehler. Standardmäßig wirft ein fataler Fehler eine Ausnahme und stoppt das Parsen. error() zu implementieren erlaubt es, nicht-fatale Validierungsprobleme zu loggen, ohne das ganze Parsen abzubrechen.

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 (Pull-Parsing)

StAX-Cursor-API

StAX ist ein Pull-Parser: Dein Code zieht das nächste Event mit next(), du steuerst also die Schleife. Die Cursor-API (XMLStreamReader) bewegt sich Event für Event. Schneller und speicherärmer als DOM und flexibler als SAXs Push-Modell.

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();

XMLStreamReader-Events

Event-Typen umfassen START_ELEMENT, END_ELEMENT, CHARACTERS, COMMENT, PROCESSING_INSTRUCTION und START/END_DOCUMENT. getText() liefert den aktuellen Text; isWhiteSpace() filtert Einrückung. Der Cursor rückt ein Event pro next()-Aufruf.

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;
    }
}

Elemente & Attribute lesen

getAttributeValue(namespaceURI, localName) liest Attribute nach Name (null für keinen Namensraum übergeben). getElementText() ist ein Komfort, der den Text eines nur-Text-Elements liest und über sein END_ELEMENT hinausrückt — sauberer, als characters selbst zu puffern.

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);
    }
}

StAX-Writer

XMLStreamWriter baut XML sequenziell. writeStartDocument, writeStartElement/writeEndElement, writeAttribute, writeCharacters und writeNamespace müssen ausgeglichen sein. Am Ende flush/close, um sicherzustellen, dass die Ausgabe vollständig ist.

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 pusht Events an deinen Handler; StAX lässt dich Events bei Bedarf ziehen. StAXs Pull-Modell erleichtert das Überspringen von Teilbäumen und die Zustandsverwaltung und ergänzt eine Writer-API. Beide vermeiden den Bau eines vollen DOM-Baums und passen also zu großen Dokumenten.

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 (Iterator-API)

Die Iterator-API (XMLEventReader) liefert XMLEvent-Objekte, die du ansehen und konsumieren kannst. Sie ist objektorientierter als die Cursor-API und leichter zum Filtern oder Splitten, aber etwas schwerer wegen der Event-Objekt-Allokation.

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

XML- & JSON-Konvertierung

XML zu JSON (JavaScript)

fast-xml-parser konvertiert in Node.js XML zu JSON. Attribute werden präfixiert (Standard @_), wiederholte Elemente werden zu Arrays. Die Bibliothek ist pure JavaScript und schnell, mit Optionen für Arrays, Zahlen und Booleans.

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 zu XML (JavaScript)

XMLBuilder kehrt die Konvertierung um. Das @_Präfix markiert Attribute, verschachtelte Objekte werden zu Kindelementen. Arrays erzeugen wiederholte Elemente. XMLs Einzelroot-Regel heißt, das JSON-Top-Level-Objekt muss auf ein Root-Element mappen.

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>

Python xmltodict

xmltodict behandelt XML wie dict/list-Strukturen: Attribute nutzen '@name', Text '#text'. parse() liest XML, unparse() schreibt es. Super für schnelle Rundtrips, verliert aber Ordnung und manche Randfälle bei komplexen Schemata.

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)

Attribut- & Textbehandlung

XML zu JSON zu konvertieren erzwingt Entscheidungen über Attribute (@_Präfix), Text (#text) und gemischten Inhalt. Gemischter Inhalt — Text, verschränkt mit Kindelementen — mappt nicht sauber auf JSON und verliert oft Treue. Konventionen wählen und konsistent bleiben.

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

Konvertierungs-Herausforderungen

Häufige Konvertierungs-Fallstricke: einzelnes vs. mehrfaches Kind (Array vs. String), Elementreihenfolge, Namensraum-Präfixe (die Aliasse sind), die Einzelroot-Beschränkung und primitive Typisierung (XML hat keine nativen Zahlen oder Booleans). Deine Konventionen dokumentieren.

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

Rundtrip-Beispiel

Rundtrips (XML -> JSON -> XML) funktionieren für gut strukturierte Daten, können aber Kommentare, Verarbeitungshinweise, CDATA-Grenzen und exakten Whitespace verlieren. Für verlustfreies Bearbeiten lieber eine DOM-/Baum-API statt JSON-Konvertierung.

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

RSS- & Atom-Feeds

RSS-2.0-Struktur

RSS 2.0 hat einen <rss>-Root mit einem <channel>. Pflichtfelder des Kanals: title, link, description. Jedes <item> hat title, link, description, guid, pubDate. Daten folgen RFC 822 (z. B. '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>

RSS-Kanal & Item

Kanalebene-Felder beschreiben den Feed (title, link, description, language, ttl, image). Item-Felder beschreiben jeden Eintrag; enclosure unterstützt Podcasts/Medien mit URL, Bytelänge und MIME-Typ. category kann ein domain-Attribut tragen.

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>

Atom-Feed

Atom (RFC 4287) nutzt einen <feed>-Root im Atom-Namensraum. Pflicht: id, title, updated. Einträge brauchen id, title, updated. IDs sollten global eindeutig sein (URNs oder tag:-URIs). Daten nutzen RFC 3339 (ISO 8601) mit Zeitzone.

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>

Atom-Eintragsdetails

Atom-Einträge unterstützen reichhaltige Inhalte: text, html oder xhtml via dem type-Attribut. link nutzt rel-Attribute (alternate, self, enclosure, related). category hat term/scheme/label. published ist das Originaldatum; updated die letzte Änderung.

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>

Häufige Feed-Namensräume

RSS wird oft mit Modulen erweitert: Dublin Core (dc:creator, dc:date), content (content:encoded für volles HTML), Media RSS (media:content) und der atom:link rel='self', der Lesern hilft, die Feed-URL zu finden. Namensräume lassen Feeds Vokabulare mischen.

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>

Feed-Validierung

Den W3C-Feed-Validator nutzen, um RSS/Atom zu prüfen. Häufige Fehler: fehlende Pflichtfelder, schlechte Datenformate, nicht eindeutige IDs, ungültiges XML (nicht escapetes &) und fehlender self-Link. Gültige Feeds stellen sicher, dass Aggregatoren sie zuverlässig parsen.

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 & XML

SVG-Dokumentstruktur

SVG ist ein XML-Vokabular für Vektorgrafiken. Das Root-<svg> deklariert den SVG-Namensraum und einen viewBox für das Koordinatensystem. Alle Grafikelemente (rect, circle, text) sind XML-Elemente mit Präsentationsattributen.

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

SVG-Namensraum & Imports

SVG-Elemente leben im Namensraum http://www.w3.org/2000/svg. xlink wird für href-Referenzen genutzt (in SVG 1.1); SVG 2 bevorzugt plain href. defs halten wiederverwendbare Verläufe, Muster und Symbole, referenziert per 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>

SVG-Formen

SVG-Formelemente: rect (mit rx/ry für abgerundete Ecken), circle, ellipse, line, polyline (offen) und polygon (geschlossen). Koordinaten liegen in den vom viewBox definierten Nutzereinheiten. stroke und fill sind übliche Präsentationsattribute.

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>

SVG-Text & Pfade

SVG-Text nutzt font-family, font-size, font-weight, font-style. tspan erlaubt gemischtes Styling innerhalb eines Textelements. Das d-Attribut des path-Elements nutzt Befehle: M (move), L (line), C (kubische Bezier), Q (quadratisch), A (Bogen), Z (Pfad schließen).

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

SVG-Gruppierung & Wiederverwendung

Das <g>-Element gruppiert Formen für geteiltes Styling und Transforms. <use> referenziert ein Element per id (href='#id' in SVG 2, xlink:href in 1.1) und klont es an neuer Position. <symbol> definiert wiederverwendbare Grafiken, die nur via <use> rendern.

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>

SVG-Validierung

SVG-Dokumente lassen sich gegen W3C-DTD oder XSD validieren. Häufige Probleme: den SVG-Namensraum vergessen, undeklarierte Präfixe, Attribute im falschen Namensraum und fehlerhafte Pfaddaten. xmllint ist der Standard-Befehlszeilen-Validator.

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 & WSDL

SOAP-Envelope

Eine SOAP-Nachricht ist ein XML-Dokument mit einem <Envelope>-Root im SOAP-Namensraum. Der optionale <Header> trägt Metadaten (Auth, Routing); der pflichtige <Body> hält die eigentliche Nachricht-Payload. SOAP 1.1 und 1.2 nutzen unterschiedliche Namensräume.

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

SOAP-Header

Header tragen Out-of-Band-Infos wie Authentifizierung, Adressierung (WS-Addressing) und Transaktionen. soap:mustUnderstand='1' sagt dem Empfänger, dass er diesen Header VERARBEITEN MUSS oder einen SOAP-Fault zurückgibt — das erzwingt Vertragskonformität.

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

SOAP-Body & Fault

Der Body trägt die Anfrage- oder Antwort-Payload. Bei Fehlern enthält der Body ein <Fault> mit faultcode (Client/Server), einer menschenlesbaren faultstring und optionalem detail. SOAP 1.2 benennt diese Elemente um und ergänzt eine Code/Reason-Struktur.

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>

WSDL-Struktur

WSDL beschreibt einen Webdienst: <types> (XSD-Schemata), <message> (Ein-/Ausgabe-Payloads), <portType> (die Schnittstelle — Operationen und ihre Nachrichten), <binding> (Protokoll/Kodierung) und <service> (Endpunkt-URL). WSDL 2.0 vereinfacht das zu interfaces und 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>

WSDL-Binding & Service

Das Binding mappt einen portType auf ein konkretes Protokoll (SOAP über HTTP) und einen Stil (document/literal ist der moderne Standard). Das service-Element listet Endpunkte (soap:address). Document/literal umhüllt die Payload in einem schema-definierten Element.

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 ist ein Protokoll mit strengem XML-Envelope, WSDL-Vertrag und WS-*-Standards (Sicherheit, Transaktionen); am besten für Unternehmensintegrationen, die Zuverlässigkeit und formale Verträge brauchen. REST ist ein leichtgewichtiger HTTP-basierter Stil, meist mit JSON, der öffentliche APIs dominiert.

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

XML-Digitale Signatur

Signaturstruktur

Das Root-<Signature> einer XML-Signatur enthält <SignedInfo> (was signiert wird und wie), <SignatureValue> (die kryptografische Signatur über das kanonisierte SignedInfo), optional <KeyInfo> und <Object>s mit referenzierten Daten.

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 spezifiziert die Kanonisierung (damit byteidentisches Signieren XML-Neuserialisierung übersteht), den Signaturalgorithmus und eine oder mehrere References. Jede Reference zeigt per URI auf Daten, listet Transforms und liefert einen DigestValue dieser Daten.

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 & Transforms

Jede Reference identifiziert, was signiert wird (URI), wendet Transforms an (Kanonisierung, XPath-Filterung, Entfernung der umhüllten Signatur) und hasht dann mit DigestMethod. Die enveloped-signature-Transform schließt das Signature-Element selbst aus seinem eigenen Hash aus.

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 & KeyInfo

SignatureValue ist das Base64-Ergebnis des Signierens des kanonisierten SignedInfo mit dem privaten Schlüssel des Signierers. KeyInfo ist OPTIONAL und deutet nur an, wie der Verifikationsschlüssel zu finden ist (X.509-Zertifikat, RSA-öffentlicher Schlüssel, Schlüsselname oder Abruf-URL) — out of band validieren.

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

Kanonisierung

Kanonisierung konvertiert eine XML-Knotenmenge in stabile Bytes, sodass eine Signatur trotz irrelevanter Unterschiede (Attributreihenfolge, CDATA) reproduzierbar ist. Exclusive c14n (xml-exc-c14n) wird für Signaturen bevorzugt, weil er Namensräume auf den signierten Teilbaum begrenzt.

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

Umhüllte Signatur

Eine umhüllte Signatur ist in das Dokument eingebettet, das sie signiert (am häufigsten bei XML). Die enveloped-signature-Transform entfernt das <Signature>-Element vor dem Hashen, die Signatur ist also nicht Teil ihres eigenen Digests. Detached- und enveloping-Varianten existieren ebenfalls.

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

Benennungskonventionen

Elementbenennung

Einen Stil wählen und konsistent anwenden. Kleinbuchstaben-mit-Bindestrichen ist bei XML-Vokabularen üblich (HTML, SVG). Namen sollten beschreibend genug sein, um eindeutig zu sein, aber knapp. Kryptische Abkürzungen und übermäßig lange Namen vermeiden.

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

Attributbenennung

Attribute passen zu Metadaten (id, type, href, status). Zum Elementbenennungsstil passen. Booleans tragen explizite Werte. Ein Attribut nicht mit seinem Elementnamen präfixieren (user-id auf <user> ist redundant). 'id' für eindeutige Bezeichner nutzen.

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

Namensraum-URIs & Präfixe

Namensraum-URIs sind Bezeichner, keine abrufbaren URLs, sollten aber stabil und in Besitz sein (HTTPS an einer Domain, die du kontrollierst). Präfixe sind lokale Aliasse — kurz und konventionell halten. Den URI versionieren, wenn sich das Schema inkompatibel ändert.

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

Schreibweisen

Übliche XML-Schreibweisen: PascalCase (XSD/WSDL, .NET), camelCase (JSON-abgeleitet, Java), Kleinbuchstaben-Bindestriche (HTML/SVG, REST-freundlich), snake_case (selten). Die entscheidende Regel ist Konsistenz innerhalb eines Vokabulars — Stile zu mischen verwirrt.

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>

Versionierung

XML-Vokabulare explizit versionieren: ein version-Attribut am Root ist am einfachsten; ein versionierter Namensraum-URI am strengsten (inkompatible Änderungen bekommen einen neuen URI). Festlegen, was eine Minor-(additive-)vs. Major-(breaking-)Änderung ist, und dokumentieren.

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

Datei- & Endungskonventionen

Anerkannte Endungen nutzen, damit Tools und Menschen Dateitypen erkennen. Das encoding-Attribut der XML-Deklaration sollte der tatsächlichen Byte-Kodierung entsprechen; UTF-8 ist der sichere Standard. BOMs sind bei UTF-8-XML unüblich.

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

Best Practices

Wohlgeformtheit zuerst

Ein Dokument muss wohlgeformt sein, bevor irgendein Tool es verarbeitet. Früh mit einem Parser validieren: xmllint --noout file.xml meldet den ersten Fehler. Wohlgeformtheit ist nicht verhandelbar; Validität gegen ein Schema ist eine zusätzliche, optionale Schicht.

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

Validierung & Schemata

Gegen ein Schema validieren, um strukturelle Fehler zu erwischen. XSD ist die häufigste Wahl für typisierte, namensräumliche Vokabulare; Schematron ergänzt es um Geschäftsregeln. xsi:noNamespaceSchemaLocation verlinkt ein Dokument mit seinem XSD; für namensräumliche Schemata xsi:schemaLocation nutzen.

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

Kodierung (UTF-8)

UTF-8 ist die Standard- und empfohlene Kodierung für XML — er handhabt alles Unicode ohne Entities. Die Kodierung immer deklarieren und die Datei in dieser Kodierung speichern. BOMs vermeiden; für Sonderzeichen lassen sich auch numerische Zeichenreferenzen nutzen.

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

Lesbarkeit & Einrückung

Konsistente Einrückung (2 Leerzeichen sind üblich) macht XML lesbar und Diffs sauber. Lange Einzelzeilen vermeiden. Tools wie 'xmllint --format' oder ein XML-Formatierer können Whitespace normalisieren — aber bedenken, dass xml:space='preserve'-Regionen nicht umformatiert werden dürfen.

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

Performance

Bei großen Dateien Streaming-Parser (SAX/StAX) statt DOM bevorzugen, um den Speicher niedrig zu halten. DTD-Laden und externe Entities deaktivieren, außer benötigt. XPath-Ausdrücke einmal kompilieren und wiederverwenden. Für interne Systeme kompakte Binärformate erwägen, um Größe und Parsezeit zu senken.

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

Sicherheit (XXE)

XXE-(XML External Entity-)Angriffe missbrauchen DTD-externe Entities, um Dateien zu lesen, SSRF auszulösen oder Denial of Service zu verursachen (billion laughs/entity expansion). Die stärkste Verteidigung ist, DTDs und externe Entity-Auflösung vollständig zu deaktivieren, außer dein Anwendungsfall verlangt sie.

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.