Ein XSD Beispiel

Dieser Abschnitt zeigt Ihnen, wie Sie einen XML Schema schreiben. Sie werden auch verschiedene Methoden zur Erstellung von Schemas lernen.

XML-Dokument

Lassen Sie uns das XML-Dokument mit dem Namen "shiporder.xml" betrachten:

<?xml version="1.0" encoding="ISO-8859-1"?>
<shiporder orderid="889923">
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="shiporder.xsd">
 <orderperson>George Bush</orderperson>
 <shipto>
  <name>John Adams</name>
  <address>Oxford Street</address>
  <city>London</city>
  <country>UK</country>
 </shipto>
 <item>
  <title>Empire Burlesque</title>
  <note>Special Edition</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 die Wurzelelemente "shiporder", das das Attribut "orderid" enthält. Das "shiporder"-Element enthält drei verschiedene Unterlemente: "orderperson", "shipto" und "item". Das "item"-Element tritt zweimal auf und enthält ein "title", ein optionales "note"-Element, eine "quantity" und ein "price"-Element.

Diese Zeile xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" gibt dem XML-Parser an, die Dokumentdatei gemäß einem Schema zu validieren. Diese Zeile: xsi:noNamespaceSchemaLocation="shiporder.xsd" legt den Ort des Schemas fest (hier ist es im selben Verzeichnis wie "shiporder.xml").

Erstellen Sie ein XML Schema

Jetzt müssen wir ein Schema für das obige XML-Dokument erstellen.

Wir können mit der Eröffnung eines neuen Datei beginne und diese Datei "shiporder.xsd" nennen. Um ein Schema zu erstellen, müssen wir nur einfach der Struktur des XML-Dokuments folgen und jeden gefundenen Element definieren. Zuerst beginnen wir mit der Definition einer Standard-XML-Deklaration:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
...
...
</xs:schema>

Im obigen Schema haben wir den Standardnamespace (xs) verwendet, der mit dem Schema Language Definition (Schema language definition) verbunden ist, deren Standardwert http://www.w3.org/2001/XMLSchema ist.

Nun müssen wir das "shiporder"-Element definieren. Dieses Element hat ein Attribut, das andere Elemente enthält, daher definieren wir es als komplexen Typ. Die Kindelemente des "shiporder"-Elements werden von dem xs:sequence-Element umgeben, das die Reihenfolge der Kindelemente definiert:

<xs:element name="shiporder">
 <xs:complexType>
  <xs:sequence>
  ...
  ...
  </xs:sequence>
  ...
 </xs:complexType>
</xs:element>

Dann müssen wir das "orderperson"-Element als einfachen Typ definieren (da es keine Attribute oder anderen Elemente enthält). Der Präfix des Typs (xs:string) wird durch den Namespace-Prefix vorgeschrieben, der mit dem XML Schema verbunden ist, das die vordefinierten Schema-Datentypen angibt:

<xs:element name="orderperson" type="xs:string"/>

Nun muss ich die beiden Elemente "shipto" und "item" als komplexe Typen definieren. Wir beginnen mit der Definition des "shipto"-Elements:

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

Durch das Schema können wir die Attribute maxOccurs und minOccurs verwenden, um die mögliche Anzahl der Auftretensmöglichkeiten eines Elements zu definieren. maxOccurs definiert den maximalen Wert der Anzahl der Auftretensmöglichkeiten eines Elements, während minOccurs den minimalen Wert definiert. Die Standardwerte für maxOccurs und minOccurs sind beide 1!

Jetzt können wir den "item"-Element definieren. Dieses Element kann mehrmals im "shiporder"-Element auftreten. Dies wird durch die Festlegung des maxOccurs-Attributs des "item"-Elements auf "unbounded" erreicht, so dass das "item"-Element so oft wie vom Ersteller gewünscht auftreten kann. Bitte beachten Sie, dass das "note"-Element ein optionales Element ist. Wir haben den minOccurs-Attribut dieses Elements auf 0 gesetzt:

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

Jetzt können wir die Eigenschaften des "shiporder"-Elements deklarieren. Da es sich um eine obligatorische Eigenschaft handelt, haben wir use="required" festgelegt.

Anmerkung:Die Deklaration dieser Eigenschaft muss am Ende platziert werden:

<xs:attribute name="orderid" type="xs:string" use="required"/>

Dies ist die Dokumentliste des Schema-Dokuments mit dem Namen "shiporder.xsd":

<?xml version="1.0" encoding="ISO-8859-1" ?>
<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>

Schema teilen

Die vorherige Designmethode ist sehr einfach, aber schwer lesbar und zu warten, wenn das Dokument komplex ist.

Der nächste vorgestellte Designansatz basiert darauf, alle Elemente und Eigenschaften zunächst zu definieren, bevor sie mit dem ref-Attribut referenziert werden.

Dieses Schema-Dokument wurde mit einer neuen Methode entworfen:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<!-- Einfacher Element-Beschreibung -->
<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"/>
<!-- Eigenschaftsdefinition -->
<xs:attribute name="orderid" type="xs:string"/>
<!-- Kombinierter Element-Beschreibung -->
<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>

Verwendung der angegebenen Typen (benannte Typen)

Die dritte Designmethode definiert Klassen oder Typen, sodass wir in der Lage sind, die Definitionen von Elementen zu wiederverwenden. Der spezifische Weg ist: Zunächst werden einfache und komplexe Elemente benannt, und dann wird durch das type-Attribut auf sie verwiesen.

Dieses Schema wurde mit der dritten Methode entworfen ("shiporder.xsd"):

<?xml version="1.0" encoding="ISO-8859-1" ?>
<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 zeigt an, dass der Datentyp aus dem Namensraum des W3C XML Schema stammt. Daher bedeutet der folgende Fragment, dass der Wert des Elements oder der Eigenschaft ein Wert des Typs "string" sein muss:

<xs:restriction base="xs:string">

Die "restriction"-Element wird häufig verwendet, um Einschränkungen auf Elemente anzuwenden. Schauen Sie sich folgende Fragmente aus dem obigen Schema an:

<xs:simpleType name="orderidtype">
 <xs:restriction base="xs:string">
  <xs:pattern value="[0-9]{6}"/>
 </xs:restriction>
</xs:simpleType>

Dieser Code zeigt an, dass der Wert des Elements oder der Eigenschaft ein String sein muss und aus sechs aufeinanderfolgenden Zeichen bestehen muss, die alle 0-9 Ziffern sind.