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 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 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 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.
<!-- 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 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 version="1.0"?>
<root>
<code><![CDATA[
if (a < b && c > d) {
console.log("no escaping needed: < > & ");
}
]]></code>
</root>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.
<!-- 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.
<!-- 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.
<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 " escapet werden. Ein Attribut darf nur einmal pro Element erscheinen — Kind-Elemente für wiederholte Werte nutzen.
<!-- Both single and double quotes are allowed -->
<item id="q1" name='quick'/>
<msg text="He said "hi""/>
<msg text='She said 'hi''/>
<!-- 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.
<!-- 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.
<!-- 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) -->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 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 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 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 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.
<!-- 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 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>CDATA & Entities
Vordefinierte Entities
XML definiert fünf Entities vor: < (<), > (>), & (&), ' ('), " ("). & 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 version="1.0"?>
<root>
<lt>less than: <</lt>
<gt>greater than: ></gt>
<amp>ampersand: &</amp>
<apos>apostrophe: '</apos>
<quot>quote: "</quot>
<!-- < > & ' " are the 5 built-in entities -->
</root>Zeichenreferenzen
Zeichenreferenzen nutzen einen Unicode-Codepoint: © (dezimal) oder © (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 version="1.0" encoding="UTF-8"?>
<root>
<decimal>© 2024 Company</decimal>
<hex>© 2024 Company</hex>
<euro>Price: €10</euro>
<emoji>Smile: 😀</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 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 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>©right;</footer>
</root>
<!-- Entities are expanded during parsing -->Escaping in Attributen
Innerhalb von Attributwerten musst du & als & escapen und das Anführungszeichen escapen, das den Wert begrenzt (" oder '). < sollte ebenfalls escapet werden. Zeilenumbrüche und Tabs in Attributen werden vom Parser zu Leerzeichen normalisiert.
<?xml version="1.0"?>
<root>
<link url="https://example.com?a=1&b=2"/>
<msg text="Say "hello" & smile"/>
<path value='C:\Users\name'/>
<data value="<tagged>"/>
</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 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>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 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.
<!-- 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).
<!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.
<!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.
<!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 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)) -->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 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.
<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.
<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.
<!-- 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).
<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.
<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>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.
<!-- 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.
//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.
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.
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.
<!-- 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 | //magazineXPath-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.
<!-- 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']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 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.
<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.
<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.
<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 < zu escapen.
<xsl:variable name="max-price" select="50"/>
<xsl:for-each select="bookstore/book[price < $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 < 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.
<!-- 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"/>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.
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.
(: 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')//titlePrä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.
(: 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.
(: 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.
(: 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.
(: 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 -->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.
// 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 insteadDOM-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).
// 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.
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.
// 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.
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.
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"))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.
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.
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.
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.
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.
<!-- 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.
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")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.
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.
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.
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.
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.
<!-- 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.
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();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.
// 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.99JSON 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.
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.
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 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.
<!-- 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.
// 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);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 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.
<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 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"><p>Full post body</p></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.
<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 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.
<!-- 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 -->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 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 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.
<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).
<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.
<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 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 -->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 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.
<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.
<!-- 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 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.
<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.
<!-- 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 -->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 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.
<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.
<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.
<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.
<!-- 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 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 -->XLink & XPointer
XLink einfacher Link
XLink-einfache Links imitieren HTML-Anker in beliebigem XML. xlink:type='simple' macht einen grundlegenden einseitigen Link; xlink:href ist das Ziel. show steuert die Anzeige (new/replace/embed); actuate das Timing (onRequest/onLoad).
<?xml version="1.0"?>
<root xmlns:xlink="http://www.w3.org/1999/xlink">
<web xlink:type="simple"
xlink:href="https://example.com"
xlink:role="https://example.com/roles/home"
xlink:title="Example Site"
xlink:show="new"
xlink:actuate="onRequest">
Visit Example
</web>
</root>
<!-- A simple link is a one-way hyperlink, similar to HTML <a> -->XLink erweiterter Link
Erweiterte Links verbinden mehrere Ressourcen (Locators) über arcs. Jeder Locator hat ein label; arcs definieren die Durchquerung zwischen Labels (from/to). Out-of-line-Links können in einem separaten Dokument leben und ermöglichen mehrseitiges Verknüpfen zwischen Drittanbieter-Ressourcen.
<?xml version="1.0"?>
<root xmlns:xlink="http://www.w3.org/1999/xlink">
<link xlink:type="extended" xlink:role="https://example.com/mapping">
<loc xlink:type="locator" xlink:label="src"
xlink:href="https://a.example/doc1" xlink:title="Doc A"/>
<loc xlink:type="locator" xlink:label="dst"
xlink:href="https://b.example/doc2" xlink:title="Doc B"/>
<go xlink:type="arc" xlink:from="src" xlink:to="dst"
xlink:show="new" xlink:actuate="onRequest"/>
</link>
</root>
<!-- Extended links can connect multiple resources and be out-of-line -->XLink-Attribute
XLink-Attribute gliedern sich nach Typ. href zielt auf einen Locator/eine Ressource; label benennt einen Teilnehmer für arcs; from/to verdrahten arcs; role/arcrole sind semantische URIs (oft Dublin-Core- oder RELAX-NG-Begriffe). show/actuate treiben Präsentation und Ladeverhalten.
<!-- xlink:type: simple | extended | locator | arc | resource | title | none -->
<!-- Common attributes by type -->
<el xlink:type="simple" xlink:href="..." xlink:role="..." xlink:title="..."
xlink:show="new|replace|embed|other|none"
xlink:actuate="onRequest|onLoad|other|none"/>
<el xlink:type="locator" xlink:href="..." xlink:label="..." xlink:role="..."/>
<el xlink:type="arc" xlink:from="..." xlink:to="..." xlink:show="..."/>
<el xlink:type="resource" xlink:label="..." xlink:role="..."/>
<!-- xlink:role is a URI identifying the resource's meaning -->
<!-- xlink:arcrole describes the arc (relationship) itself -->XPointer-Grundlagen
XPointer adressiert Positionen in einem XML-Dokument via URI-Fragmenten. Kurzform (#id) wählt nach ID. Schemabasierte Formen (#xpointer(...)) nutzen XPath, und element() nutzt positionale Kinderpfade. Das Fragment wird nach dem Holen des Dokuments interpretiert.
<?xml version="1.0"?>
<root xmlns:xlink="http://www.w3.org/1999/xlink">
<!-- XPointer extends a URI fragment to address XML parts -->
<link xlink:type="simple"
xlink:href="doc.xml#xpointer(//book[@id='b1'])"/>
<link xlink:href="doc.xml#xpointer(/root/section[2]/p[1])"/>
<link xlink:href="doc.xml#b1"/>
</root>
<!-- Fragment forms:
- shorthand: #id
- scheme-based: #xpointer(expr)
- element(): #element(/1/2/3) -->XPointer-Framework
Das XPointer-Framework erlaubt es, mehrere Schemata zu ketten, sodass ein späteres versucht wird, wenn ein früheres scheitert. Das xmlns()-Schema bindet Präfixe für nachfolgende xpointer()-Ausdrücke. element() liefert einen robusten positional Pfad unabhängig von IDs.
<!-- The XPointer Framework defines how fragment schemes compose -->
<ref xlink:href="doc.xml#element(/1/2)"/>
<ref xlink:href="doc.xml#xpointer(//section[@id='s1']/p[2])"/>
<ref xlink:href="doc.xml#xmlns(bk=https://example.com/b)xpointer(//bk:book)"/>
<!-- Multiple schemes can be tried in order: -->
<ref xlink:href="doc.xml#element(/1/2)xpointer(//book[@id='b1'])"/>
<!-- If element() fails, the next scheme is attempted -->
<!-- Common schemes: element(), xpointer(), xmlns(), xpath1() -->element()-Schema
Das element()-Schema adressiert einen Knoten über eine Sequenz 1-basierter Kinderpositionen, optional beginnend bei einem mit ID versehenen Element. Er ist robuster als xpointer() gegen Schemaänderungen, weil er nicht von Elementnamen abhängt — nur von Struktur.
<!-- element() addresses by child positions from the root -->
<ref xlink:href="doc.xml#element(/1/2/3)"/>
<!-- selects the 1st child of root, its 2nd child, then 3rd child -->
<!-- or relative to an ID -->
<ref xlink:href="doc.xml#element(b1/2)"/>
<!-- the 2nd child of the element with id="b1" -->
<!-- child positions are 1-based and skip text/attribute nodes;
only element children are counted -->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.
<!-- 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.
<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.
<!-- 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.
<!-- 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.
<!-- 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.
<!-- 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"?> -->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 version="1.0" encoding="UTF-8"?>
<root>
<child>properly nested & 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.
<!-- 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 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 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.
<!-- 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 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) -->Verwandte XML-Snippets
Copy-paste ready code for common tasks.
Namespaces
Declare and use XML namespaces.
XPath
Path expressions for selecting nodes.
DTD and Schema
Document Type Definition for validation.
DOM and SAX Parsing
Two models for reading XML.
Attributes
Name-value pairs on elements.
CDATA Sections
Escape blocks of literal text.
XSLT
Transform XML into other formats.
Well-Formed XML
Rules every parser enforces.
Was this helpful?