XSD Beispiel
In diesem Abschnitt wird gezeigt, wie man ein XML-Schema schreibt. Sie lernen außerdem verschiedene Methoden zum Schreiben eines Schemas kennen.
XML-Dokument
Betrachten wir dieses XML-Dokument mit dem Namen "shiporder.xml":
<shiporder orderid="889923"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="shiporder.xsd">
<orderperson>John Smith</orderperson>
<shipto>
<name>Ola Nordmann</name>
<address>Langgt 23</address>
<city>4000 Stavanger</city>
<country>Norwegen</country>
</shipto>
<item>
<title>Empire Burlesque</title>
<note>Sonderausgabe</note>
<quantity>1</quantity>
<price>10.90</price>
</item>
<item>
<title>Hide your heart</title>
<quantity>1</quantity>
<price>9.90</price>
</item>
</shiporder>
Das obige XML-Dokument enthält das Wurzelelement "shiporder", das ein erforderliches Attribut namens "orderid" enthält. Das Element "shiporder" enthält drei verschiedene untergeordnete Elemente: "orderperson", "shipto" und "item". Das Element "item" kommt zweimal vor, und es enthält einen "title", ein optionales "note"-Element, eine "quantity" und ein "price"-Element.
Die obige Zeile, xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance", weist den XML-Parser an, dieses Dokument anhand eines Schemas zu validieren. Diese Zeile: xsi:noNamespaceSchemaLocation="shiporder.xsd" gibt den Speicherort des Schemas an (hier befindet es sich im selben Ordner wie "shiporder.xml").
Ein XML-Schema erstellen
Nun müssen wir ein Schema für das obige XML-Dokument erstellen.
Wir können zunächst eine neue Datei öffnen und sie "shiporder.xsd" nennen. Um das Schema zu erstellen, müssen wir einfach der Struktur im XML-Dokument folgen und jedes Element definieren, das wir finden. Zuerst definieren wir eine standardmäßige XML-Deklaration:
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
...
</xs:schema>
Im obigen Schema haben wir den Standardnamensraum (xs) verwendet. Die diesem Namensraum zugeordnete URI ist die Definition der Schema-Sprache, und ihr Standardwert ist http://www.w3.org/2001/XMLSchema.
Als Nächstes müssen wir das Element "shiporder" definieren. Dieses Element hat ein Attribut und enthält andere Elemente, daher identifizieren wir es als komplexen Typ. Die untergeordneten Elemente des Elements "shiporder" sind vom xs:sequence-Element umgeben, das die Reihenfolge der untergeordneten Elemente definiert:
<xs:complexType>
<xs:sequence>
...
</xs:sequence>
</xs:complexType>
</xs:element>
Dann müssen wir das Element "orderperson" als einfachen Typ definieren (weil es keine Attribute oder anderen Elemente enthält). Das Präfix des Typs (xs:string) wird durch das Namespace-Präfix angegeben, das mit dem XML-Schema verknüpft ist, das vordefinierte Schema-Datentypen angibt:
Als Nächstes muss ich zwei Elemente als komplexe Typen definieren: "shipto" und "item". Wir beginnen mit der Definition des Elements "shipto":
<xs:complexType>
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Durch ein Schema können wir die Attribute maxOccurs und minOccurs verwenden, um zu definieren, wie oft ein bestimmtes Element vorkommen darf. maxOccurs definiert die maximale Anzahl, wie oft ein Element vorkommen darf, während minOccurs die minimale Anzahl definiert, wie oft ein Element vorkommen darf. Der Standardwert für sowohl maxOccurs als auch minOccurs ist 1!
Jetzt können wir das Element "item" definieren. Dieses Element kann mehrmals innerhalb des Elements "shiporder" vorkommen. Dies wird erreicht, indem der Wert des Attributs maxOccurs des Elements "item" auf "unbounded" gesetzt wird, sodass das Element "item" so oft vorkommen kann, wie der Autor möchte. Beachten Sie, dass das Element "note" ein optionales Element ist. Wir haben sein Attribut minOccurs auf 0 gesetzt:
<xs:complexType>
<xs:sequence>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string" minOccurs="0"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Jetzt können wir das Attribut des Elements "shiporder" deklarieren. Da dies ein erforderliches Attribut ist, geben wir use="required" an.
Hinweis:Die Deklaration dieses Attributs muss am Ende stehen:
Dies ist die Dokumentauflistung der Schemadatei namens "shiporder.xsd":
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="shiporder">
<xs:complexType>
<xs:sequence>
<xs:element name="orderperson" type="xs:string"/>
<xs:element name="shipto">
<xs:complexType>
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="item" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string" minOccurs="0"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
<xs:attribute name="orderid" type="xs:string" use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>
Das Schema unterteilen
Die vorherige Entwurfsmethode ist sehr einfach, aber wenn das Dokument komplex ist, ist es schwierig zu lesen und zu warten.
Die als Nächstes vorgestellte Entwurfsmethode basiert darauf, zuerst alle Elemente und Attribute zu definieren und dann das ref-Attribut zu verwenden, um auf sie zu verweisen.
Hier ist die Schemadatei ("shiporder.xsd"), die mit der neuen Methode entworfen wurde:
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<!-- Definition einfacher Elemente -->
<xs:element name="orderperson" type="xs:string"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>
<!-- Definition von Attributen -->
<xs:attribute name="orderid" type="xs:string"/>
<!-- Definition komplexer Elemente -->
<xs:element name="shipto">
<xs:complexType>
<xs:sequence>
<xs:element ref="name"/>
<xs:element ref="address"/>
<xs:element ref="city"/>
<xs:element ref="country"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="item">
<xs:complexType>
<xs:sequence>
<xs:element ref="title"/>
<xs:element ref="note" minOccurs="0"/>
<xs:element ref="quantity"/>
<xs:element ref="price"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="shiporder">
<xs:complexType>
<xs:sequence>
<xs:element ref="orderperson"/>
<xs:element ref="shipto"/>
<xs:element ref="item" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute ref="orderid" use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>
Benannte Typen verwenden
Die dritte Entwurfsmethode definiert Klassen oder Typen und gibt uns die Möglichkeit, Elementdefinitionen wiederzuverwenden. Die konkrete Vorgehensweise ist: Zuerst werden die einfachen Elemente und komplexen Elemente benannt, und dann wird über das type-Attribut des Elements auf sie verwiesen.
Hier ist die Schemadatei ("shiporder.xsd"), die mit der dritten Methode entworfen wurde:
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:simpleType name="stringtype">
<xs:restriction base="xs:string"/>
</xs:simpleType>
<xs:simpleType name="inttype">
<xs:restriction base="xs:positiveInteger"/>
</xs:simpleType>
<xs:simpleType name="dectype">
<xs:restriction base="xs:decimal"/>
</xs:simpleType>
<xs:simpleType name="orderidtype">
<xs:restriction base="xs:string">
<xs:pattern value="[0-9]{6}"/>
</xs:restriction>
</xs:simpleType>
<xs:complexType name="shiptotype">
<xs:sequence>
<xs:element name="name" type="stringtype"/>
<xs:element name="address" type="stringtype"/>
<xs:element name="city" type="stringtype"/>
<xs:element name="country" type="stringtype"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="itemtype">
<xs:sequence>
<xs:element name="title" type="stringtype"/>
<xs:element name="note" type="stringtype" minOccurs="0"/>
<xs:element name="quantity" type="inttype"/>
<xs:element name="price" type="dectype"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="shipordertype">
<xs:sequence>
<xs:element name="orderperson" type="stringtype"/>
<xs:element name="shipto" type="shiptotype"/>
<xs:element name="item" maxOccurs="unbounded" type="itemtype"/>
</xs:sequence>
<xs:attribute name="orderid" type="orderidtype" use="required"/>
</xs:complexType>
<xs:element name="shiporder" type="shipordertype"/>
</xs:schema>
Das restriction-Element gibt an, dass der Datentyp von einem Datentyp im W3C-XML-Schema-Namespace abgeleitet ist. Daher bedeutet das folgende Fragment, dass der Wert des Elements oder Attributs ein Wert vom Typ string sein muss:
Das restriction-Element wird häufig verwendet, um Einschränkungen für Elemente festzulegen. Betrachten Sie die folgenden Fragmente aus dem obigen Schema:
<xs:restriction base="xs:string">
<xs:pattern value="[0-9]{6}"/>
</xs:restriction>
</xs:simpleType>
Dieser Code gibt an, dass der Wert des Elements oder Attributs eine Zeichenkette sein muss, aus sechs aufeinanderfolgenden Zeichen bestehen muss und dass diese Zeichen Ziffern von 0-9 sein müssen.
Andere Erweiterungen