Dieser Artikel basiert auf dem Artikel aus der freien Enzyklopädie Wikipedia und steht unter der GNU-Lizenz für freie Dokumentation. In der Wikipedia ist eine Liste der Autoren verfügbar.

XML Schema ist eine Empfehlung des W3C zum Definieren von XML-Dokumentstrukturen. Anders als bei den klassischen XML-DTDs wird die Struktur in Form eines XML-Dokuments beschrieben. Darüber hinaus wird eine große Anzahl von Datentypen unterstützt.

Gebräuchliche Plurale sind XML-Schemas und XML-Schemata.

Einleitung [Bearbeiten]

XML Schema ist eine komplexe Sprache zur Beschreibung eines XML-Typsystems. Dieses XML-Typsystem umfasst die Spezifikation neuer XML-Elemente, deren Attribute, sowie deren Kindelemente. Im Gegensatz zu DTDs kann bei Verwendung von XML Schema zwischen dem Namen des XML-Typs und dem in der Instanz verwendeten XML-Tagnamen unterschieden werden.

Vermutlich werden DTDs irgendwann vollständig von XML-Schemata abgelöst. Allerdings sind XML-Schemata durch ihre erweiterten Möglichkeiten wesentlich komplexer und nicht so einfach ohne Hilfsmittel auszuwerten. Neben XML Schema existieren weitere Ansätze zur Definition von XML-Strukturen. Ein konkretes XML-Schema wird auch als eine XSD (XML-Schema-Definition) bezeichnet und hat üblicherweise die Dateiendung ".xsd".

Datentypen [Bearbeiten]

XML Schema unterscheidet zwischen einfachen und komplexen Datentypen. Der Begriff Typ bezeichnet im nachfolgenden Text jeweils die abstrakte Definition der Struktur eines Abschnitts innerhalb eines XML-Dokumentes.

Einfache Typen [Bearbeiten]

XML Schema stellt einige grundlegende atomare Datentypen bereit. Die atomaren Datentypen enthalten die „klassischen“ Typen, wie sie zum Teil aus anderen Typsystemen (z. B. C, Java oder SQL) bekannt sind:

• xsd:string
• xsd:decimal
• xsd:integer
• xsd:float
• xsd:boolean
• xsd:date
• xsd:time

Hinzu kommen weitere XML-spezifische atomare Typen, unter anderem:

• QName: Qualified Name, global eindeutiger Bezeichner. Aufgebaut aus sog. NCNames (Non-Colonized Names), wobei jeder NCName bis auf den letzten einen Namensraum ("Namespace") bezeichnet. Der letzte NCName entspricht dem lokalen Namen innerhalb des Namensraumes. Die einzelnen NCNames werden mittels Punkt (.) zu einem QName konkateniert.
• anyURI: Uniform Resource Identifier (URI)
• language: Sprachbezeichnung, z. B. de-DE, en-US, fr
• ID: Identifikationsattribut innerhalb von XML Elementen
• IDREF: Referenz auf einen ID-Wert

Einfache XML-Datentypen dürfen weder XML-Kindelemente enthalten noch XML-Attribute besitzen.

Außer den atomaren Datentypen gehören Listen und Unions, (bestehend aus atomaren Elementen) zu den einfachen Typen:

• Das folgende Beispiel definiert einen neuen XML-Datentypen mit dem Namen monatInt sowie eine Liste dieses neuen Typs:

 <xsd:simpleType name="monatInt">
   <xsd:restriction base="xsd:integer">
     <xsd:minInclusive value="1"/>
     <xsd:maxInclusive value="12"/>
   </xsd:restriction>
 </xsd:simpleType>

<xsd:simpleType name="monate">
   <xsd:list itemType="monatInt"/>
</xsd:simpleType>

Eine Instanz des neuen Typs könnte wie folgt aussehen:

 <monate>
    1 2 3 4 5 6 7 8 9 
 </monate>

Die einzelnen Elemente einer Liste werden durch Leerzeichen getrennt.

• Zu den einfachen Typen gehören zusätzlich noch sogenannte "Unions" (engl. für Vereinigung).

Ein neuer Typ wird als Vereinigung bereits bestehender Typen definiert. Das nachfolgende Beispiel definiert einen weiteren Typ monatsname sowie einen Union Typ monat:

<xsd:simpleType name="monatsname">
  <xsd:restriction base="xsd:string">
   <xsd:enumeration value="Jan"/>
   <xsd:enumeration value="Feb"/>
   <xsd:enumeration value="Mär"/>
   <!-- und so weiter ... -->
  </xsd:restriction>
</xsd:simpleType> 

<xsd:simpleType name="monat">
  <xsd:union memberTypes="monatsname monatInt"/>
</xsd:simpleType>

XML-Elemente vom Typ monat dürfen sowohl Integer Werte im Bereich 1–12 enthalten als auch eine der entsp. Monatsbezeichnungen als Zeichenkette.

Komplexe Typen [Bearbeiten]

Im Gegensatz zu den einfachen Typen bieten komplexe XML-Datentypdefinitionen die Möglichkeit, Kindelemente sowie Attribute zu definieren.

Das folgende Beispiel definiert einen neuen Typ pc-Typ mit entsprechenden Kindelementen name, hersteller, etc., sowie einem Attribut id:

 <xsd:complexType name="pc-Typ">
   <xsd:sequence>
     <xsd:element name="name"       type="xsd:string"/>
     <xsd:element name="hersteller" type="xsd:string"/>
     <xsd:element name="prozessor"  type="xsd:string"/>
     <xsd:element name="mhz"        type="xsd:integer" minOccurs="0"/>
     <xsd:element name="kommentar"  type="xsd:string"  minOccurs="0" maxOccurs="unbounded"/>
   </xsd:sequence>
   <xsd:attribute name="id" type="xsd:integer"/>
 </xsd:complexType>

Die Möglichkeiten zur Definition komplexer Typen sollen hier nur exemplarisch erläutert werden. Der interessierte Leser sei auf die unten angegebenen Links zu den Seiten des W3C verwiesen.

Die Kindelemente eines komplexen Typs können auf drei unterschiedliche Arten kombiniert werden:

• xsd:sequence: Eine Liste von Kindelementen wird spezifiziert. Jedes dieser Elemente kann 0 oder mehrfach auftreten (Attribute minOccurs und maxOccurs). Falls kein occurs-Attribut vorhanden ist, wird in beiden Fällen der Default-Wert 1 verwendet. Die Elemente innerhalb einer sequence müssen in der angegebenen Reihenfolge auftreten. In dem oben gezeigten Beispiel müssen die Elemente name, hersteller und prozessor genau einmal auftreten, das mhz-Element kann null oder einmal auftreten, kommentar-Elemente können beliebig oft oder auch gar nicht auftreten.
• xsd:choice: Aus einer Liste von Alternativen kann ein Element ausgewählt werden. Das nachfolgende Beispiel definiert einen neuen Typ computer der als Kindelement entweder ein desktop-Element besitzt (vom Typ pc-Type) oder ein laptop-Element:

 <xsd:complexType name="computer">
   <xsd:choice>
     <xsd:element name="desktop" type="pc-Typ"/>
     <xsd:element name="laptop" type="laptop-Typ"/>
   </xsd:choice>
 </xsd:complexType>

• xsd:all: Mittels des xsd:all-Tags lässt sich eine Gruppe von Kindelementen definieren, von denen jedes maximal einmal auftreten darf (min- und maxOccurs dürfen nur die Werte 0 oder 1 annehmen). Die Reihenfolge der Elemente ist beliebig.

Beliebiger Inhalt [Bearbeiten]

XML-Elemente mit beliebigem Inhalt lassen sich mittels des Basistype anyType definieren. Der nachfolgende Code spezifiziert ein kommentar-Element beliebigen Inhalts, d. h. sowohl komplexe XML-Elemente als auch Text kann vorkommen.

<xsd:element name="kommentar" type="xsd:anyType"/>

Leere Elemente [Bearbeiten]

Von leeren XML-Elementen spricht man, wenn das jeweilige Element aus nur einem einzelnen XML-Tag besteht und keine weiteren XML-Elemente oder Text umschließt (z. B. der XHTML-Zeilenumbruch: <br />). XML Schema bedient sich an dieser Stelle eines kleinen Tricks: Es wird mittels xsd:complexType ein neuer Typ definiert ohne ein Kindelement anzugeben. Da xsd:complexType per default nur komplexe XML-Kindelemente als Inhalt zulässt, bleibt das jeweilige Element in diesem Fall leer.

Ableitung neuer Typen [Bearbeiten]

Neue Datentypen lassen sich zum einen durch die Definition eines neuen Typs erstellen (siehe vorheriger Abschnitt) oder durch die Ableitung eines neuen Typs aus bereits bestehenden. Die Ableitung eines neuen Typs kann auf zweierlei Arten erfolgen: Erweiterung oder Einschränkung.

Erweiterung eines Typs [Bearbeiten]

Die Erweiterung eines bisherigen Typs (engl. extension) um weitere Eigenschaften, d. h. neue Elemente oder Attribute werden hinzugefügt. Im folgenden Beispiel wird der oben definierte Typ pc-Typ um ein Element ram erweitert:

 <xsd:complexType name="myPC-Typ">
   <xsd:complexContent>
     <xsd:extension base="pc-Typ">
       <xsd:sequence>
         <xsd:element name="ram" type="xsd:integer"/>
       </xsd:sequence>
     </xsd:extension>
  </xsd:complexContent>
</xsd:complexType>

Der neu definierte XML-Typ myPC-Typ besteht aus allen Kindelementen des Typs pc-Typ sowie dem Element ram. Letzteres wird, wie in einer xsd:sequence-Definition, an die bisherigen Kindelemente angehängt.
Die Erweiterung einer bestehenden Typdefinition impliziert jedoch keine Substituierbarkeit, d. h. an einer Stelle an der ein Element vom Typ pc-Typ erwartet wird, darf nicht ohne weiteres ein Element vom Typ myPC-Typ verwendet werden (Casts sind jedoch möglich).

Einschränkung eines Typs [Bearbeiten]

Durch Einschränkung bereits bestehender Typen (engl. restriction) lassen sich ebenfalls neue Definitionen ableiten. Zu diesem Zweck müssen alle Elementdefinitionen des Basistyps wiederholt werden, verändert um die jeweiligen restriktiveren Einschränkungen. Im folgenden Beispiel wird ein neuer Typ myPC2-Typ von pc-Typ abgeleitet. In diesem Fall darf maximal ein kommentar-Element auftreten (im Gegensatz zu einer beliebigen Anzahl beim Typ pc-Typ)

 <xsd:complexType name="myPC2-Typ">
   <xsd:complexContent>
     <xsd:restriction base="pc-Typ">
       <xsd:sequence>
        <xsd:element name="name"       type="xsd:string"/>
        <xsd:element name="hersteller" type="xsd:string"/>
        <xsd:element name="prozessor"  type="xsd:string"/>
        <xsd:element name="mhz"        type="xsd:integer" minOccurs="0"/>
        <xsd:element name="kommentar"  type="xsd:string" minOccurs="0" maxOccurs="1"/>
       </xsd:sequence>
     </xsd:restriction>
  </xsd:complexContent>
</xsd:complexType>

Zusätzlich zu der Einschränkung komplexer Typen ist es auch möglich, neue Typen als Einschränkung einfacher Typen zu definieren. Ein Beispiel für eine solche Definition befindet sich bereits im Abschnitt zu den einfachen Typen. Ein neuer Typ monatInt wird als Einschränkung des Typs Integer auf den Wertebereich 1–12 definiert. Grundsätzlich stehen die folgenden Primitive zur Verfügung, um Einschränkungen auf einfachen Typen zu beschreiben:

• length, maxLength, minLength – Beschränkt die Länge eines Strings oder einer Liste.
• enumeration – Beschränkung durch Angabe alternativer Werte
• pattern – Beschränkung durch Angabe eines regulären Ausdrucks
• minExclusive, minInclusive, maxExclusive, maxInclusive – Einschränkung des Wertebereichs.
• totalDigits, fractionDigits – Einschränkung der Dezimalstellen (Gesamtzahl und Nachkommastellen)
• whiteSpace – Behandlung von Leerzeichen und Tabs

Die folgenden Beispiele veranschaulichen die Verwendung dieser Komponenten:

• Körpertemperatur, 3 Dezimalstellen, 1 Nachkommastelle, Minimal- und Maximalwert

<xsd:simpleType name="celsiusKörperTemp">
  <xsd:restriction base="xsd:decimal">
    <xsd:totalDigits value="3"/>
    <xsd:fractionDigits value="1"/>
    <xsd:minInclusive value="35.0"/>
    <xsd:maxInclusive value="42.5"/>
  </xsd:restriction>
</xsd:simpleType>

• Deutsche Postleitzahlen, optionales „D “ gefolgt von fünf Ziffern

<xsd:simpleType name="plz">
   <xsd:restriction base="xsd:string">
     <xsd:pattern value="(D )?[0-9]{5}"/>
   </xsd:restriction>
</xsd:simpleType>

• Größenangabe

<xsd:simpleType name="size">
  <xsd:restriction base="xsd:string">
    <xsd:enumeration value="XS"/>
    <xsd:enumeration value="S"/>
    <xsd:enumeration value="M"/>
    <xsd:enumeration value="L"/>
    <xsd:enumeration value="XL"/>
  </xsd:restriction>
</xsd:simpleType>

Bei der Definition eines Typs ist es möglich festzulegen, ob und auf welche Art von diesem Typ weitere XML-Elementtypen abgeleitet werden dürfen. So kann man zum Beispiel festlegen, dass von einem Typ pc-Typ weitere Typen nur durch das Setzen weiterer Einschränkungen abgeleitet werden dürfen – und nicht durch das Hinzufügen neuer Kindelemente.

Elementdefinition [Bearbeiten]

Wie im vorangegangenen Abschnitt erläutert, erlaubt es XML Schema neue XML-Datentypen zu definieren und diese bei der Definition eigener XML-Elemente zu verwenden. Das folgende Beispiel veranschaulicht die Verwendung des bereits definierten Types pc-Typ innerhalb einer Liste von pc-Elementen:

<xsd:element name="pc-liste">
  <xsd:complexType>
   <xsd:sequence>
    <xsd:element name="pc" type="pc-Typ" maxOccurs="unbounded"/>
   </xsd:sequence>
  </xsd:complexType>
</xsd:element>

Ein entsprechendes XML-Element könnte wie folgt aussehen:

<pc-liste>
  <pc>
    <name>Dimension 3100 </name>
    <hersteller>Dell</hersteller>
    <mhz>3060</mhz>
    <kommentar>Arbeitsplatzrechner</kommentar>
  </pc>
  <pc>
    <name>T 42</name>
    <hersteller>IBM</hersteller>
    <mhz>1600</mhz>
    <kommentar>guter Laptop</kommentar>
  </pc>
</pc-liste>

Innerhalb dieses Beispiels erfolgt die Spezifikation des anonymen Listentyps direkt innerhalb der Elementdefinition, während die Spezifikation des pc-Typs extern erfolgt.

Bei dem Entwurf eines komplexen XML-Schemas sollte sowohl die Wiederverwendbarkeit und Erweiterbarkeit der einzelnen XML-Elementtypen als auch die Lesbarkeit des Schemas selbst berücksichtigt werden. Die Verwendung anonymer XML-Elementtypen als Teil größerer Elemente gewährleistet im Allgemeinen eine bessere Lesbarkeit kleinerer XML-Schemata. Die Definition und Benennung einzelner, kleinerer und wiederverwendbarer XML-Elementtypen hingegen ermöglicht eine stärkere Modularisierung der XML-Schema-Struktur. Aufgrund der Vielzahl möglicher Anwendungsszenarien haben sich bisher noch keine allgemeingültigen Entwurfprinzipien für XML-Schemata herausgebildet (vergleichbar den Normalformen für relationale Datenbanken).

Weiterführende Konzepte und Eigenschaften [Bearbeiten]

Eindeutige Schlüssel [Bearbeiten]

Vergleichbar den Primärschlüsseln in relationalen Datenbanken lassen sich mittels XML Schema eindeutige Schlüssel definieren. XML Schema unterscheidet zwischen der Eindeutigkeit (engl. unique) und der Schlüsseleigenschaft.

Das nachfolgende Beispiel definiert ein neues Element pc-list mit einer Liste von pc-Kindelementen:

 <xsd:element name="pc-list">
   <xsd:complexType>
     <xsd:sequence>
       <xsd:element name="computer" type="pc-Typ" maxOccurs="unbounded"/>
     </xsd:sequence>
   </xsd:complexType>
   <xsd:unique name="her-name">
     <xsd:selector xpath="computer"/>
     <xsd:field xpath="name"/>
     <xsd:field xpath="hersteller"/>
   </xsd:unique> 
   <xsd:key name="idKey">
     <xsd:selector xpath="computer"/>
     <xsd:field xpath="@id"/>
   </xsd:key>
 </xsd:element>

Die beiden Elemente unique und key selektieren mit einem XPath Pfadausdruck (im Beispiel: computer) eine Menge von pc-Elementen. Für diese Menge muss die jeweilige Eindeutigkeits- bzw. Schlüsselbedingung erfüllt werden. Im obigen Beispiel wird festgelegt, dass die Kombination der Elemente name und hersteller für jedes pc-Element innerhalb dieser Liste eindeutig sein muss.
Durch das key-Element wird festgelegt, dass das Attribut id innerhalb dieser Liste eindeutig sein muss und von außerhalb referenziert werden kann.

Das folgende Beispiel zeigt die Referenzierung dieses Schlüssels mit dem Attribut refer und dem Schlüsselwort @references.

 <xsd:keyref name="idFremdKey" refer="idKey">
   <xsd:selector xpath="computerFremd"/>
   <xsd:field xpath="@references"/>
 </xsd:keyref>

Beachte

Mit refer bezieht man sich auf das name-Attribut einer Schlüsselbedingung, nicht auf das Schlüsselfeld. Die Werte in references müssen also immer unter den Schlüsseln zu den computern zu finden sein. (Hintergrund dieses Konstrukts ist die Sicherstellung der Referentiellen_Integrität, wie man sie von relationalen Datenbanksystemen her kennt.)

Import, Include und Redefine [Bearbeiten]

XML Schema erlaubt es, fremde Schemata wiederzuverwenden.
Hierzu stehen sowohl der include- als auch der import-Tag zur Verfügung sowie die Möglichkeit einer neuen Definition bzw. Anpassung fremder Schemata beim Einbinden.

include

Typdefinitionen innerhalb eines Namensraumes, die auf mehrere Dateien verteilt sind, lassen sich mittels include zusammenfügen.

 <schema xmlns="http://www.w3.org/2001/XMLSchema"
         xmlns:pcTeile="http://www.example.com/pcTeile"
         targetNamespace="http://www.example.com/pcTeile">
   ...
   <include schemaLocation="http://www.example.com/schemata/harddisk.xsd"/>
   <include schemaLocation="http://www.example.com/schemata/ram.xsd"/>
   ...
 </schema>

• mehrere Schemata können inkludiert werden.
• targetNamespace des harddisk.xsd muss mit dem des inkludierenden Schemas übereinstimmen.

redefine

Gleiches Beispiel wie gerade. Annahme es gäbe einen complexType Hersteller im Schema harddisk.xsd.

 <schema xmlns="http://www.w3.org/2001/XMLSchema"
         xmlns:pcTeile="http://www.example.com/pcTeile"
         targetNamespace="http://www.example.com/pcTeile">
   ...
   <redefine schemaLocation="http://www.example.com/schemata/harddisk.xsd">
     <complexType name="Hersteller">
       <complexContent>
         <restriction base="pcTeile:Hersteller">
           <sequence>
             <element name="hersteller" type="string" minOccurs="10" maxOccurs="10"/>
           </sequence>
         </restriction>
       </complexContent>
     </complexType>
   <redefine/>
   ...
   <include schemaLocation="http://www.example.com/schemata/ram.xsd">
   ...
 </schema>

• redefine kann an Stelle von include verwendet werden.
• Der Name des Typs ändert sich dabei nicht.

import

Der import-Tag erlaubt es, Elemente aus anderen Namensräumen zu importieren, mit einem Präfix zu versehen und damit Schema-Bestandteile aus unterschiedlichen Namespaces wiederzuverwenden.
Annahme ist, dass es einen definierten Typ superTyp in pcTeile gibt.

 <schema xmlns="http://www.w3.org/2001/XMLSchema"
         xmlns:pcTeile="http://www.example.com/pcTeile"
         targetNamespace="http://www.example.com/firma">
   ...
   <import namespace="http://www.example.com/pcTeile"/>
   ...
     <...
       <xsd:attribute name="xyz" type="pcTeile:superTyp"/>
     .../>
   ...
 </schema>

Verwendung von XML-Schemata [Bearbeiten]

Zur Verwendung eines XML-Schemas in einer XML-Datei müssen die Attribute xmlns:xsi und xsi:schemaLocation verwendet werden, um ein gewünschtes Schema einem Namensraum zuzuweisen. In folgendem Beispiel wird ausgedrückt, dass der Standard-Namensraum http://www.w3.org/1999/xhtml ist und dann angegeben, dass das XML-Schema für diesen Namensraum unter http://www.w3.org/1999/xhtml.xsd aufzufinden ist.

 <html xmlns="http://www.w3.org/1999/xhtml"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.w3.org/1999/xhtml
                           http://www.w3.org/1999/xhtml.xsd">

Die Definition gilt für das XML-Element, bei dem die Attribute angegeben sind, und alle Kinderelemente.

Beispiel [Bearbeiten]

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <xsd:element name="html">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="head"/>
        <xsd:element name="body" type="xsd:string"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>
  <xsd:element name="head">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="title" type="xsd:string"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>
</xsd:schema>

Dies entspricht abgesehen vom Namensraum folgender DTD

 <!ELEMENT html (head, body)>
 <!ELEMENT head (title)>
 <!ELEMENT title (#PCDATA)>
 <!ELEMENT body (#PCDATA)>

Die Extensible Markup Language (engl. für „erweiterbare Auszeichnungs-Sprache“), abgekürzt XML, ist ein Standard zur Modellierung von halb-strukturierten Daten in Form einer Baumstruktur, der vom World Wide Web Consortium (W3C) definiert wird. XML definiert also Regeln für den Aufbau von Dokumenten, die Daten enthalten, die zum Teil einer fest vorgegebenen Struktur entsprechen, teilweise aber auch Elemente beinhalten, die nicht diesem statischen Schema entsprechen. XML als Rahmenkonzept lässt somit offen, ob und wie ein konkretes XML-Dokument automatisiert verarbeitet werden kann.

Für ein XML-verarbeitendes Programm („XML-Anwendung“) müssen die Elemente der jeweiligen Dokumente genau beschrieben werden. Dies betrifft insbesondere die Festlegung der Strukturelemente und ihre Anordnung innerhalb des Dokumentenbaums. Auch für diese Beschreibung selbst stellt XML Standards zur Verfügung, so die DTD.

XML ist damit ein Standard zur Definition von beliebigen, in ihrer Grundstruktur jedoch stark verwandten Auszeichnungssprachen, die Programme ebenso wie Daten beschreiben können. Eine Sprache wie XML zur Definition anderer Sprachen nennt man Metasprache. XML ist eine vereinfachte Teilmenge von SGML.

Namen der Strukturelemente [Bearbeiten]

Die Namen der Strukturelemente (XML-Elemente) für eine XML-Anwendung lassen sich frei wählen. Ein XML-Element kann ganz unterschiedliche Daten enthalten und beschreiben: meistens Text, aber auch Grafiken oder abstraktes Wissen. Ein Grundgedanke hinter XML ist es, Daten und ihre Repräsentation zu trennen, um Daten beispielsweise einmal als Tabelle und einmal als Grafik auszugeben, aber für beide Arten der Auswertung die gleiche Datenbasis im XML-Format zu nutzen.

Fachbegriffe [Bearbeiten]

Wohlgeformtheit

Ein XML-Dokument ist wohlgeformt, wenn es sämtliche Regeln für XML einhält. Beispielhaft seien hier folgende genannt:

• Das Dokument besitzt genau ein Wurzelelement.
• Alle Tags mit Inhalt besitzen ein Beginn- und ein End-Tag. Tags ohne Inhalt können auch mit /> abschließen.
• Die Beginn- und End-Tags sind korrekt verschachtelt.

Gültigkeit

Soll XML für den Datenaustausch verwendet werden, ist es von Vorteil, wenn das Format mittels einer Grammatik (z. B. einer Dokumenttypdefinition (DTD) oder eines XML-Schemas) definiert ist. Der Standard definiert ein XML-Dokument als gültig, wenn es wohlgeformt ist, den Verweis auf eine Grammatik enthält und das durch die Grammatik beschriebene Format einhält.

Parser

Programme oder Programmteile, die XML-Daten auslesen, interpretieren und ggf. auf Gültigkeit prüfen, nennt man XML-Parser. Prüft der Parser die Gültigkeit, so ist er ein validierender Parser.

Aufbau eines XML-Dokuments [Bearbeiten]

Beispiel einer XML-Datei

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<enzyklopaedie>
     <titel>Wikipedia Städteverzeichnis</titel>
     <eintrag>
          <stichwort>Genf</stichwort>
          <eintragstext>Genf ist der Sitz von …</eintragstext>
     </eintrag>
     <eintrag>
          <stichwort>Köln</stichwort>
          <eintragstext>Köln ist eine Stadt, die …</eintragstext>
     </eintrag>
</enzyklopaedie>

XML-Dokumente besitzen einen physischen und einen logischen Aufbau.

Der physische Aufbau eines XML-Dokumentes besteht aus

• Entitäten. Die erste Entität ist die Hauptdatei des XML-Dokuments. Weitere mögliche Entitäten sind über
  • Entitätenreferenzen (&name; für das Dokument bzw. %name; für die Dokumenttypdefinition) eingebundene Zeichenketten, eventuell auch ganze Dateien, sowie
  • Referenzen auf Zeichenentitäten zur Einbindung einzelner Zeichen, die über ihre Nummer referenziert wurden (&#Dezimalzahl;, oder &#xHexadezimalzahl;).
• Eine XML-Deklaration wird optional verwendet, um XML-Version, Zeichenkodierung und Verarbeitbarkeit ohne Dokumenttypdefinition zu spezifizieren.
• Eine Dokumenttypdefinition wird optional verwendet, um Entitäten sowie den erlaubten logischen Aufbau zu spezifizieren.

Der logische Aufbau eines XML-Dokumentes ist eine Baumstruktur und damit hierarchisch strukturiert. Als Baumknoten gibt es:

• Elemente, deren physische Auszeichnung mittels
  • einem passenden Paar aus Start-Tag (<Tag-Name>) und End-Tag (</Tag-Name>) oder
  • einem Empty-Element-Tag (<Tag-Name />) erfolgen kann,
• Attribute als bei einem Start-Tag oder Empty-Element-Tag geschriebene Schlüsselwort-Werte-Paare (Attribut-Name="Attribut-Wert") für Zusatz-Informationen über Elemente (eine Art Meta-Information),
• Verarbeitungsanweisungen (<?Ziel-Name Parameter ?>, engl. Processing Instruction)
• Kommentare (<!-- Kommentar-Text -->)
• Text, welcher als normaler Text oder in Form eines CDATA-Abschnittes (<![CDATA[ beliebiger Text]]>) auftreten kann.

Ein XML-Dokument muss genau ein Element auf der obersten Ebene enthalten. Unterhalb von diesem Dokumentelement können weitere Elemente verschachtelt werden.

Zur Spezifikation des logischen Aufbaus werden die Dokumenttypdefinitionen durch das umfangreichere XML-Schema abgelöst, welches keine Möglichkeit zur Definition von Entitäten, jedoch einen adäquaten Ersatz für Entitäten besitzt. Verarbeitungsanweisungen werden in der Praxis meist eingesetzt, um in XML-Dokumenten Verarbeitungsanweisungen in anderen Sprachen einzubauen. Ein Beispiel dafür ist PHP, dessen Verarbeitungsanweisungen in XML-Dokumenten mit einer PHP-Verarbeitungsanweisung, z. B. <?php echo'Hello, World'; ?> eingebaut werden können.

Einige Web-Browser können XML-Dokumente mit Hilfe eines eingebauten XML-Parsers direkt darstellen. Dies geschieht in Verbindung mit einem Stylesheet. Diese Transformation kann die Daten in ein komplett anderes Format umwandeln, das Zielformat muss nicht einmal XML sein.

Vorgänger von XML [Bearbeiten]

Obwohl der Vorgänger SGML bereits weitaus umfangreicher war, kam es nie zu einer breiten Akzeptanz in der Öffentlichkeit. Der Grund dafür lag u. a. in der Komplexität SGMLs, die die Softwareentwicklung stark erschwert. Die Komplexität von SGML und XML kann mit der Pareto-Verteilung beschrieben werden: Obwohl XML nur ca. 20 % der Komplexität von SGML hat, können damit ca. 80 % der Anwendungsfälle abgedeckt werden. Der Bedarf nach einem unbeschränkten weltweiten Informationsaustausch und die Popularität von HTML brachten das deutlich einfachere XML hervor.

Kerntechnologien [Bearbeiten]

Die Kerntechnologien im XML-Umfeld kann man grob aufteilen in APIs zur Verarbeitung von XML und Sprachen zur Beschreibung von XML-Dateien.

APIs zur Verarbeitung von XML [Bearbeiten]

SAX [Bearbeiten]

SAX (Simple API for XML) ist eine standardisierte Möglichkeit, wie eine XML-Datei durch einen Parser bearbeitet wird. Hierbei wird ein Datei-Strom in einen Strom von Ereignissen umgewandelt. Programme können sich für einzelne Ereignisse registrieren, um bei Bedarf ihre Arbeit zu verrichten. Die Eingabedaten werden rein sequentiell verarbeitet. Ein Vorteil von SAX ist, dass nicht die gesamte XML-Datei im Speicher vorgehalten werden muss. Das ist aber dann ein Nachteil, wenn man viele Informationen, die über die ganze Datei verstreut sind, zur Verarbeitung benötigt.

DOM [Bearbeiten]

DOM (Document Object Model) ist der zweite Weg, um XML-Dateien auszuwerten und wurde vom W3C standardisiert. Er stellt ein standardisiertes Objektmodell zur Verfügung, mit dessen Hilfe der Inhalt der XML-Datei ausgewertet oder manipuliert werden kann. Zum Aufbauen des Objektbaumes muss jedoch zunächst die gesamte Datei eingelesen werden, wofür möglicherweise viel Speicher benötigt wird. Vorteilhaft ist hingegen, dass dann alle Elemente in einer hierarchischen Struktur vorliegen und auf alle gleichermaßen zugegriffen werden kann. Die Elemente stehen zueinander in Beziehung (Eltern, Geschwister, Kinder). Als Nachteil von DOM kann sich ein hoher Speicherbedarf erweisen; er verhält sich proportional zur Größe der Eingabedatei.

Als Beispiel sei eine Webseite erwähnt, die in XML spezifiziert ist. 100 kB sind für eine solche Webseite schon eine beachtliche Größe, sind in einem DOM jedoch noch problemlos möglich. Auf der anderen Seite kann ein Wörterbuch (3 MB Grunddaten) gegebenenfalls Probleme verursachen, wobei es weniger der Speicherplatz an sich sein dürfte sondern die Zugriffsgeschwindigkeit. Beide Modelle haben deshalb ihre Berechtigung in der Anwendung.

Schemasprachen [Bearbeiten]

Um die Struktur von XML-Dokumenten zu beschreiben, bedient man sich so genannter Schemasprachen. Die zwei bekanntesten sind DTD und XML Schema.

DTD [Bearbeiten]

Eine DTD (Dokumenttypdefinition) ist eine Beschreibung eines XML-Dokuments. Sie wurde zusammen mit XML standardisiert, zu einem Zeitpunkt, an dem XML noch hauptsächlich für „narrative documents“ („erzählende Dokumente“, also Zeitungsartikel, Bücher, …) gedacht war, weniger als Datenaustauschformat. Daher ist es z. B. in DTD nicht möglich, zwischen Texten und Zahlen zu unterscheiden. Ein weiterer Nachteil ist die Tatsache, dass die DTD in einer eigenen Sprache abgefasst werden muss. Außerdem kennt die DTD keine Namensräume.

XML-Schema / XSD [Bearbeiten]

XML-Schema (bzw. XSD = XML-Schema-Definition) ist die moderne Möglichkeit, die Struktur von XML-Dokumenten zu beschreiben. XML-Schema bietet auch die Möglichkeit, den Inhalt von Elementen und Attributen zu beschränken, z. B. auf Zahlen, Datumsangaben oder Texte, z. B. mittels regulärer Ausdrücke. Ein Schema ist selbst ein XML-Dokument, welches erlaubt, komplexere (auch inhaltliche) Zusammenhänge zu beschreiben, als dies mit einer formalen DTD möglich ist.

Weitere Schemasprachen [Bearbeiten]

Weitere Schemasprachen sind RELAX NG, Schematron und Examplotron.

XML-Familie [Bearbeiten]

Infrastruktur [Bearbeiten]

Im Zusammenhang mit XML wurden vom W3-Konsortium auf Basis von XML viele Sprachen definiert, welche XML-Ausdrücke für häufig benötigte allgemeine Funktionen anbieten wie etwa die Verknüpfung von XML-Dokumenten. Zahlreiche XML-Sprachen nutzen diese Grundbausteine.

• Transformation von XML-Dokumenten: XSLT
• Adressierung von Teilen eines XML-Baumes: XPath
• standardisierte Attribute: XML Base und xml:id
• Verknüpfung von XML-Ressourcen: XPointer, XLink und XInclude
• Selektion von Daten aus einem XML-Datensatz: XQuery
• Definition von XML-Datenstrukturen: XML Schema (= XSD, XML Schema Definition Language)
• Signatur und Verschlüsselung von XML-Knoten: XML Signature und XML-Encryption
• PDF-Generierung aus XML-Daten: XSL-FO

Sprachen [Bearbeiten]

Während XML selbst aus SGML hervorgegangen ist, bedienen sich heute sehr viele formale Sprachen der Syntax von XML. So ist XML ein wesentliches Instrument, um – wie es das W3C vorsieht – eine offene, für Mensch und Maschine verständliche Informationslandschaft (semantisches Web) zu schaffen.

Auch die bekannte Dokumentsprache HTML wurde als „Extensible HyperText Markup Language“ (XHTML) im Anschluss an die Version 4.01 in dieses Konzept integriert, so dass ihr nun XML als Definitionsbasis zu Grunde liegt. Vielfacher Grund für den Einsatz von XML ist das zahlreiche Vorhandensein von Parsern und die einfache Syntax: die Definition von SGML umfasst 500 Seiten, jene von XML nur 26.

Die folgenden Listen stellen einige dieser XML-Sprachen dar.

Text [Bearbeiten]

• XSL-FO (Textformatierung)
• DocBook
• DITA
• XHTML (XML-konformes HTML)
• TEI (Text Encoding Initiative)
• NITF (News Industry Text Format)

Grafik [Bearbeiten]

• SVG (Vektorgrafiken)
• X3D (3D-Modellierungssprache)
• Collada (Austauschformat für Daten zwischen verschiedenen 3D-Programmen)

Geodaten [Bearbeiten]

• Geography Markup Language (GML)
• GPS Exchange Format (GPX): XML für GPS-Daten
• Keyhole Markup Language (KML): Koordinaten-Spezifikation für Google Earth
• OpenImmo : XML für Immobilien mit Geo-Daten

Multimedia [Bearbeiten]

• SMIL (zeitsynchronisierte, multimediale Inhalte)
• MPEG-7 (MPEG-7 Metadaten)
• Laszlo (LZX)

Sicherheit [Bearbeiten]

• SAML (sicherheitsbezogene Informationen beschreiben und übertragen)
• XML Signature (XML-Schreibweise für digitale Signaturen)
• XML Encryption

Weitere [Bearbeiten]

Darüber hinaus existieren XML-Sprachen für Webservices (z. B. SOAP und WSDL), für mathematische Formeln (MathML), für Verfahren im Bereich des Semantic Web (RDF, OWL, Topic Maps, UOML), für Service Provisioning (SPML), für den Austausch von Finanzberichten wie bspw. Jahresabschlüsse (XBRL), in Bereichen der Automobilindustrie (ODX, QDX, JADM) über Landwirtschaft (AgroXML) bis zum Verlagswesen (ONIX) und viele weitere mehr.

Eine Zusammenfassung von XML-Sprachen für Office-Anwendungen findet sich im OpenDocument-Austauschformat (OASIS Open Document Format for Office Applications).

Siehe auch [Bearbeiten]

• Namensraum, Liste der XML-Namensräume
• Cω (lies: C - Omega)
• XML-Datenbank

Programme [Bearbeiten]

• XML-Editoren
  • Open Source
    • Eclipse
    • JEdit mit XML-Plugin
    • KXML Editor
    • NetBeans
    • Open XML Editor
  • Freeware
    • Crimson Editor mit XML-Syntaxfile
    • Peter's XML Editor
    • Microsoft XML Notepad 2007
  • Kommerziell
    • Altova XMLSpy 2006, auch als kostenlose „Home Edition“ verfügbar
    • XML EditX
    • oXygen
    • Epic
    • XML Editor
    • Stylus Studio
    • XMetaL
    • XMLmind
    • NGed, ein WYSIWYG-XML-Editor
• Office
  • AbiWord
  • Adobe FrameMaker (seit V7.2 Unterstützung von DTD, Schema, XSL; komfortables Editieren auch per Drag&Drop in Baumansicht)
  • KOffice
  • Microsoft Word (Seit der Version „Word 2003“ kann Word eigene Dokumente in WordML, einer proprietären XML-Anwendung, speichern. Darüber hinaus ist in der Professionell-Variante das Editieren von beliebigen XML-Dateien möglich.) ^[1]
  • OpenOffice.org

• Anzeigeprogramme
  • Internet Explorer
  • Firefox
  • Mozilla
  • Netscape (ab Version 6)
  • Opera

• XML-Schema Dokumentation
  • Open Source
    • xsddoc
    • xs3p
  • Nicht Open Source
    • xnsdoc
    • XSDDoc

XML-Parser [Bearbeiten]

XML-Parser (oft auch als XML-Prozessoren bezeichnet) lesen ein XML-Dokument nach bestimmten Kriterien aus. Beim DOM wird das gesamte Dokument in eine Struktur eingelesen, die dann weiterverarbeitet werden kann. XML-Parser sind in verschiedensten Sprachen vorhanden, z. B. Java, C, C++, C# oder PHP.

Quellen [Bearbeiten]

XML/DTDs

XSLT-Elemente

xsl:apply-imports
xsl:apply-templates
xsl:attribute
xsl:attribute-set
xsl:call-template
xsl:choose
xsl:comment
xsl:copy
xsl:copy-of
xsl:decimal-format
xsl:element
xsl:fallback
xsl:for-each
xsl:if
xsl:import
xsl:include
xsl:key
xsl:message
xsl:namespace-alias
xsl:number
xsl:otherwise
xsl:output
xsl:param
xsl:preserve-space
xsl:processing-instruction
xsl:sort
xsl:strip-space
xsl:stylesheet
xsl:template
xsl:text
xsl:transform
xsl:value-of
xsl:variable
xsl:when
xsl:with-param

XPath-Funktionen

boolean()
ceiling()
concat()
contains()
count()
current()
document()
element-available()
false()
floor()
format-number()
function-available()
generate-id()
id()
key()
lang()
last()
local-name()
name()
namespace-uri()
normalize-space()
not()
number()
position()
round()
starts-with()
string()
string-length()
substring()
substring-after()
substring-before()
sum()
system-property()
translate()
true()
unparsed-entity-uri()

Allgemeines

<?xml ?>
ATTLIST
CDATA
DOCTYPE
ELEMENT
version (<?xml?>)
ENTITY
IGNORE
INCLUDE
NOTATION
standalone (<?xml?>)
version (<?xml?>)
xmlns