Einführung

Der Zweck von XML-Schemata ist, XML-Schnittstellen so genau wie möglich zu beschreiben. XML-Schnittstellen können zum Beispiel Datenschnittstellen zwischen Computersystemen sein. Die Beschreibung der im XML zulässigen Datenstrukturen und Dateninhalten erfolgt über ein oder mehrere XML-Schemata. Ein XML-Schema wird auch als XSD (XML-Schema-Definition) bezeichnet und mit der Endung ".xsd" gespeichert.

Konkret wird per XML-Schema beschrieben:

  • welche Elemente und Attribute vorkommen,
  • in welcher Reihenfolge / Schachtelung Elemente und Attribute vorkommen,
  • welche Inhalte in den Elementen und Attributen erlaubt sind.

Mit Hilfe eines Parsers oder eines anderen XML-Tools kann ein XML-Dokument gegen ein XMNL-Schema geprüft werden. Es wird geprüft, ob der XML-Datenstrom den Regeln des XML-Schemas entspricht.

  • Ein korrektes XML-Dokument nennt man wohlgeformt, wenn es den allgemeinen XML-Regeln entspricht.
  • Ein korrektes XML-Dokument nennt man gültig (valide), wenn es die Regeln eines XML-Schemas einhält.

Ein XML-Schema ist genau wie eine XML-Datei aufgebaut, also mit öffnenden und schließenen Elementtags.

Beispiel für ein XML-Dokument, das Fahrzeugdaten enthält (gespeichert als "fahrzeug.xml"):
<?xml version="1.0" encoding="UTF-8"?>
<Fahrzeug>
  <Farbe>Rot</Farbe>
  <Kw>111</Kw>
  <Verbrauch>9.5</Verbrauch>
</Fahrzeug>
Das XML-Dokument beginnt standardmäßig in der ersten Zeile mit dem Hinweis auf die verwendete XML-Version und die Zeichenkodierung.
Es folgt das Wurzelelement "Fahrzeug" und darunter drei Unterelemente "Farbe", "Kw" und "Verbrauch".

Beispiel für eine XML-Schemadatei, die Regeln für obiges XML-Dokument vorgibt (gespeichert als "fahrzeug.xsd"):
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="Fahrzeug">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="Farbe" type="xs:string"/>
        <xs:element name="Kw" type="xs:integer"/>
        <xs:element name="Verbrauch" type="xs:decimal"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>
Das XML-Schema beginnt standardmäßig mit dem Hinweis auf die verwendete XML-Version und die Zeichenkodierung.
Dann wird ein Namespace definiert und durch das Kürzel "xs" (könnte auch "xsd" oder "abc" sein) ein Bezug zum verwendeten W3C-Namespace hergestellt.
(Durch Namespaces können z.B. mehrere Elemente mit gleichem Namen aus unterschiedlichen Namespaces konfliktfrei in einem XML-Dokument genutzt werden.

Das Element "Fahrzeug" beinhaltet keine eigentlichen Daten, sondern weitere Elemente, deshalb wird es als komplexer Typ einer Sequenz definiert.
Dieser komplexe Typ beinhaltet drei Unterlemente und deren Typdefinitionen (also was im jeweiligen Element als Inhalt erlaubt ist).
Jedes Element und jeder Typ hat das Präfix "xs" und wird dadurch dem W3C-Schema-Vokabular zugeordnet.


Validieren/Testen einer XML-Datei gegen ein XML-Schema:
Bei validome.org können XML und XSD online getestet werden. Alternativ bei tools.decisionsoft.com/schemaValidate.
Oder man nimmt ein kostenloses XML-Freeware- oder Sharewaretool ("XMLSPEAR"), Profis nutzen Sax-/Xerces-Parser oder XML-Spy...

Datentypen (Basistypen und Ableitungen)

XML-Dokumente transportieren Daten innerhalb von Elementen und Attributen. Per XML-Schema legt man fest, welche Inhalte in Elementen und Attributen erlaubt sind. Dies geschieht konkret mit Hilfe sogenannter Schema-Datentypen. Basis aller Schema-Datentypen sind ca. 50 vordefinierten Datentypen des W3C. Man spricht auch von Basis- oder Standardtypen. Hier eine Auswahl von wichtigen Typen:

Typ Beschreibung Beispiel(e)
string Zeichenkette Hello World
decimal Dezimalzahl mit "." als Trennzeichen 1.23, +1,23, -1.23, -.12
integerZahl ohne Nachkommastellen1, +22, -33
positiveIntegerpositive Ganzzahl1, 2, 3
nonNegativeIntegerpositive Ganzzahl oder 00, 1, 2, 3
dateDatum2000-12-31
timeZeitpunkt23:59:00
dateTimeZeitpunkt nach ISO 86012000-12-31T23:59:00
booleanlogischer Werttrue, false, 0, 1

Beispiel für die Anwendung der Standard-Datentypen
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="Fahrzeug">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="Bezeichnung" type="xs:string"/>
        <xs:element name="Kw" type="xs:integer"/>
        <xs:element name="Verbrauch" type="xs:decimal"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

Die Basistypen reichen nicht immer, um Datenelemente genau genug zu beschreiben.
Dann legt man eigene Datentypen an, die von bestehenden Basistypen abgeleitet/eingeschränkt werden (Facetten).

Folgende Ableitungen/Einschränkungen sind u.a. möglich:

  • Länge (length, minLength, maxLength,...)
  • Grenzwerte (minInclusive, minExclusive, maxInclusive,...)
  • Aufzählung (enumeration)
  • Reguläre Ausdrücke (pattern)

Beispiel einer eingeschränkten String-Typdefinition auf eine Länge von 1 bis 20 Zeichen
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="Fahrzeug">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="Bezeichnung">
          <xs:simpleType>
            <xs:restriction base="xs:string">
              <xs:minLength value="1"/>
              <xs:maxLength value="20"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        <xs:element name="Kw" type="xs:integer"/>				
        <xs:element name="Verbrauch" type="xs:decimal"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>
Der Type "xs:string" wird nicht mehr direkt in der Elementdefinition eingetragen.
Zur Einschränkung wird eine Typdefinition geöffnet (xs:simpleType) und darin als Basistyp "xs:string" definiert.
Dieser wird dann weiter eingeschränkt, hier die Länge des Strings auf "1" bis "20" Zeichen.

Beispiel einer eingeschränkten Integer-Typdefinition auf Grenzwerte (Ober- und Untergrenze)
...
<xs:element name="Kw">
  <xs:simpleType>
    <xs:restriction base="xs:integer">
      <xs:minInclusive value="1"/>
      <xs:maxInclusive value="999"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>
...
Der Type "xs:integer" wird auf den Minimalwert "1" und den Maximalwert "999" eingeschränkt.
Somit ist "0" ungültig, "1" ok, 01 als Wert auch ok, "999" ok, 1000 aber nicht mehr.

Beispiel für eine Aufzählung von erlaubten Werten, hier "m" und "w":
...
<xs:element name="Geschlecht">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:enumeration value="m"/>
      <xs:enumeration value="w"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>
...
In einem Geschlecht-Element ist entweder ein "m" oder ein "w" erlaubt, nichts anderes.

Beispiel für einen regulären Ausdruck, um eine Postleitzahl zu beschreiben (5stellige Ziffer)
...
<xs:element name="PLZ">
  <xs:simpleType>
    <xs:restriction base="xs:integer">
      <xs:pattern value="[0-9][0-9][0-9][0-9][0-9]"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>
...
Jedes Klammerpaar [...] beschreibt einen Zeichenvorrat. Je Zeichenvorrat ist ein Zeichen erlaubt.
Somit ist laut Definition in einem PLZ-Element genau 5 mal eine Ziffer von 0 bis 9 gefordert.