Ein Beispiel für XSD

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

XML-Dokument

Lassen Sie uns das nach "shiporder.xml" benannte XML-Dokument 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", die ein notwendiges Attribut namens "orderid" enthält. Das "shiporder"-Element enthält drei verschiedene Unterelemente: "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" informiert den XML-Parser, den Dokument nach einem bestimmten Schema zu validieren. Diese Zeile: xsi:noNamespaceSchemaLocation="shiporder.xsd" definiert den Ort des Schemas (hier ist es im selben Ordner wie "shiporder.xml").

Erstellen Sie ein XML Schema

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

Wir können mit der Eröffnung eines neuen Datei beginnen und diese Datei "shiporder.xsd" nennen. Um ein Schema zu erstellen, müssen wir einfach der Struktur des XML-Dokuments folgen und jeden entdeckten Element definieren. Zunächst 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, dessen Standardwert http://www.w3.org/2001/XMLSchema ist.

Als nächstes müssen wir das "shiporder"-Element definieren. Dieses Element hat ein Attribut, das andere Elemente enthält, daher betrachten wir es als komplexen Typ. Die Kindelemente des "shiporder"-Elements sind 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 (denn es enthält keine Attribute oder andere Elemente). Der Präfix des Typs (xs:string) wird durch den Namespace-Präfix vorgeschrieben, der mit dem XML Schema verbunden ist, das die vordefinierten Schema-Datentypen angibt:

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

Als nächstes muss ich zwei Elemente als komplexe Typen definieren: "shipto" und "item". 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 Auftretens eines Elements zu definieren. maxOccurs definiert den maximalen Wert der Anzahl der Auftretens eines Elements, während minOccurs den minimalen Wert definiert. Die Standardwerte für maxOccurs und minOccurs sind beide 1!

Nun können wir den "item"-Element definieren. Dieses Element kann mehrmals im "shiporder"-Element vorkommen. Dies wird durch die Festlegung des Wertes der maxOccurs-Attribut des "item"-Elements auf "unbounded" erreicht, so dass das "item"-Element so oft vorkommen kann, wie der Ersteller wünscht. Beachten Sie, dass das "note"-Element ein optionales Element ist. Wir haben das 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 Attribute des Elements "shiporder" erklären. Da es sich um ein obligatorisches Attribut handelt, legen wir fest, dass use="required" ist.

Anmerkung:Die Erklärung dieses Attributes muss am Ende stehen:

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

Dies ist die Dokumentliste der Schema-Datei 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

Diese Designmethode ist sehr einfach, aber schwierig zu lesen und zu warten, wenn das Dokument komplex ist.

Die folgende Designmethode basiert darauf, zunächst alle Elemente und Attribute zu definieren, und dann auf sie mit dem ref-Attribut zu verweisen.

Dies ist eine Schema-Datei, die mit einer neuen Methode entworfen wurde:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<!-- 简易元素的定义 -->
<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 der Attribute -->
<xs:attribute name="orderid" type="xs:string"/>
<!-- Definition des komplexen Elements -->
<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)

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

Dies ist ein Schema-Dokument, das mit dem dritten Verfahren entworfen wurde ("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 Element "restriction" zeigt an, dass der Datentyp aus der W3C XML Schema Namensraum stammt. Daher müssen die Werte der Elemente oder Attribute im folgenden Abschnitt Zeichenkettenwerte sein:

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

Der restriction-Element wird häufig verwendet, um Einschränkungen auf Elemente anzuwenden. Sehen Sie sich diese 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 dass er aus sechs aufeinanderfolgenden Zeichen bestehen muss, die alle 0-9 sein müssen.