Questo capitolo dimostrerà come scrivere uno schema XML. Imparerai anche che uno schema può essere scritto in modi diversi.
Un documento XML
Diamo uno sguardo a questo documento XML denominato "shiporder.xml" :
<?xml version="1.0" encoding="UTF-8"?>
<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>Norway</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>
Il documento XML sopra è costituito da un elemento radice, "shiporder" , che contiene un attributo obbligatorio denominato "orderid" . Il "shiporder" elemento contiene tre diversi elementi figlio: "orderperson" , "shipto" e "item" . La "item" elemento appare due volte, e contiene un "title" , un optional "note" elemento, una "quantity" , e un "price" elemento.
La linea di cui sopra: xmlns: xsi = "http://www.w3.org/2001/XMLSchema-instance" dice al parser XML che questo documento deve essere convalidato contro uno schema. La linea: xsi: noNamespaceSchemaLocation = "shiporder.xsd" specifica in cui risiede schema (here it is in the same folder as "shiporder.xml") .
Creare uno schema XML
Ora vogliamo creare uno schema per il documento XML sopra.
Si comincia con l'apertura di un nuovo file che chiameremo "shiporder.xsd" . Per creare lo schema potremmo semplicemente seguire la struttura del documento XML e definire ogni elemento come la troviamo. Inizieremo con la dichiarazione standard XML seguita dalla xs: elemento dello schema che definisce uno schema:
<?xml version="1.0" encoding="UTF-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
...
</xs:schema>
Nello schema di cui sopra utilizza lo spazio normale (xs) , e l'URI associato a questo spazio dei nomi è la definizione del linguaggio dello schema, che ha il valore standard di http://www.w3.org/2001/XMLSchema.
Quindi, dobbiamo definire il "shiporder" elemento. Questo elemento ha un attributo e contiene altri elementi, pertanto consideriamo come un tipo complesso. Gli elementi figlio del "shiporder" elemento è circondato da un xs: elemento sequenza che definisce una sequenza ordinata di elementi secondari:
<xs:element name="shiporder">
<xs:complexType>
<xs:sequence>
...
</xs:sequence>
</xs:complexType>
</xs:element>
Poi dobbiamo definire la "orderperson" elemento come un tipo semplice (perché non contiene attributi o altri elementi). Il tipo (xs:string) è preceduto con il prefisso dello spazio dei nomi associato con XML Schema che indica un tipo di dati di schema predefinito:
<xs:element name="orderperson" type="xs:string"/>
Quindi, dobbiamo definire due elementi che sono di tipo complesso: "shipto" e "item" . Iniziamo definendo la "shipto" elemento:
<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>
Con schemi possiamo definire il numero di possibili occorrenze di un elemento con le maxOccurs e attributi minOccurs. maxOccurs specifica il numero massimo di occorrenze di un elemento e minOccurs specifica il numero minimo di occorrenze di un elemento. Il valore predefinito per entrambi i maxOccurs e minOccurs è 1!
Ora possiamo definire la "item" elemento. Questo elemento può apparire più volte all'interno di un "shiporder" elemento. Questo è specificato impostando l' maxOccurs attributo della "item" elemento "unbounded" il che significa che ci possono essere tante occorrenze della "item" elemento come la volontà dell'autore. Si noti che la "note" elemento è opzionale. Abbiamo specificato impostando le minOccurs attribuiscono a zero:
<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>
Ora possiamo dichiarare l'attributo della "shiporder" elemento. Poiché si tratta di un attributo obbligatorio specifichiamo uso = "necessaria".
Note: Le dichiarazioni di attributo devono sempre venire scorso:
<xs:attribute name="orderid" type="xs:string" use="required"/>
Ecco la lista completa dei file di schema chiamato "shiporder.xsd" :
<?xml version="1.0" encoding="UTF-8" ?>
<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>
Dividere il Schema
Il metodo di progettazione precedente è molto semplice, ma può essere difficile da leggere e gestire quando i documenti sono complesse.
Il metodo di progettazione successiva si basa sulla definizione di tutti gli elementi e gli attributi, e poi riferendosi a loro utilizzando il ref attributo.
Ecco il nuovo design del file di schema ("shiporder.xsd") :
<?xml version="1.0" encoding="UTF-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<!-- definition of simple elements -->
<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 of attributes -->
<xs:attribute name="orderid" type="xs:string"/>
<!-- definition of complex 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>
Utilizzo di tipi Named
Il metodo terzo disegno definisce le classi o tipi, che ci permette di riutilizzare definizioni degli elementi. Questo viene fatto nominando gli elementi simpleTypes e complexTypes, e poi puntare a loro attraverso il type attributo dell'elemento.
Ecco il terzo progetto del file di schema ("shiporder.xsd") :
<?xml version="1.0" encoding="UTF-8" ?>
<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>
L'elemento di restrizione indica che il tipo di dati è derivato da un tipo di dati namespace W3C XML Schema. Così, il seguente frammento significa che il valore dell'elemento o dell'attributo deve essere un valore di stringa:
<xs:restriction base="xs:string">
L'elemento di restrizione è più spesso utilizzato per applicare restrizioni agli elementi. Guardate le seguenti righe dallo schema di cui sopra:
<xs:simpleType name="orderidtype">
<xs:restriction base="xs:string">
<xs:pattern value="[0-9]{6}"/>
</xs:restriction>
</xs:simpleType>
Ciò indica che il valore dell'elemento o attributo deve essere una stringa, deve essere esattamente sei caratteri in una riga, e quei caratteri deve essere un numero da 0 a 9.