XML-Schema di Babbo Natale

L’interesse che gira intorno al mondo XML è grande. In tutte le applicazioni web si percepisce la necessità di separare definitivamente i contenuti dalla loro rappresentazione e le esigenze di multicanalità sono sempre più pressanti.
Qualsiasi soluzione tecnologica che voglia avere un respiro sufficientemente ampio deve essere compatibile con XML, se non addirittura essere basata su XML stesso. Lo stesso SOAP, protocollo applicativo di cui abbiamo parlato e sul quale torneremo, ha la presunzione di essere un protocollo futuribile oltre che presente per il solo fatto di essere XML-based.
XML pertanto è la materia prima con la quale costruire le architetture del futuro e poiché il futuro nel nostro mondo è oggi, esso rappresenta la base per le architetture odierne.
Come sappiamo, però, non esiste materia prima nobile senza un alto grado di malleabilità e di duttilità e, soprattutto, senza gli strumenti che ci permettano di lavorarla.
Uno degli strumenti che ci permette di utilizzare al meglio XML è senza dubbio XML-Schema, una specifica del W3C che definisce un linguaggio con il quale sia possibile scrivere regole chiare che un documento XML deve rispettare per poter essere “valido”.
Come sappiamo un documento associato ad una grammatica è valido se soddisfa completamente i requisiti imposti dalla grammatica stessa.

XML-Schema, pertanto, è uno strumento per scrivere grammatiche XML, un po’ quello che accade con i Document Type Definition. Ma allora a cosa serve un nuovo linguaggio? Semplice, XML-Schema è un’applicazione di XML stesso, DTD no.
Associate ad XML-Schema ci sono tali e tante caratteristiche interessanti che la specifica, se tentate di stamparla, occupa un migliaio di pagine.
Potete trovare questo mare di informazioni a partire dal seguente URL:

http://www.w3.org/XML/Schema

Quello che cercheremo di fare oggi è un piccolo esempio della potenza con la quale XML-Schema ci permette di generare grammatiche XML anche di una discreta complessità, ma veniamo al succo della questione.

Un Babbo Natale tecnologico

Dovete sapere che il vostro vecchio amico Babbo Natale, quello cui spedivate le letterine da bambini, non è affatto immune dal fascino della tecnologia, ha pertanto commissionato ad un’azienda di informatica un portale web per la ricezione delle letterine che i bambini sono soliti mandargli.
L’URL per il momento non posso svelarvelo, ma posso dirvi che l’anno prossimo le letterine a Babbo Natale dovranno essere spedite in formato XML! Certo, cosa c’è di strano? Sul portale di Babbo Natale c’è un web-service che riceve le letterine nel formato corretto, le decodifica e le inserisce all’interno di un database in modo che possano essere elaborate. Tutto questo con il preciso obiettivo di alleggerire il lavoro ai folletti ed ottimizzare il processo di produzione dei giocattoli.

Naturalmente in un’architettura del genere il file che viene ricevuto non può essere un file XML qualsiasi, bensì dovrà rispettare una serie di regole molto precise in modo da essere elaborato in maniera automatica senza necessità dell’intervento di nessuno.

Le regole

Babbo Natale ha fissato alcune semplici regole per la produzione della letterina in XML, vediamole:

• Il root tag del file XML dovrà essere <Letterina>
• I figli di primo livello dovranno essere:
  • <Mittente> – il mittente della letterina e destinatario dei regali
  • <TestoLetterina> – il testo della letterina
  • <ListaRegali> – la lista dei regali desiderati (al massimo tre!)
  • <Complimenti> – Babbo Natale ci tiene …
• Il <Mittente> dovrà essere una struttura complessa composta da <Nome>, <Cognome> ed <Indirizzo>
• L'<Indirizzo> stesso dovrà essere una struttura complessa composta da <Via>, <Citta>, <Cap_Zip>, <Paese>
• Il <TestoLetterina> sarà una semplice stringa opzionale
• La <ListaRegali> dovrà essere un elenco con un massimo di tre occorrenze della struttura complessa <Regalo>, la quale conterrà informazioni relative al <Produttore> (identificato attraverso <RagioneSociale> e <Indirizzo>) <Descrizione> e <Prezzo_Euro>.
• La sezione <Complimenti> è necessaria in quanto Babbo Natale pare sia un tipo che apprezza questo genere di cose.

La nostra letterina in XML è linkata ad un documento XML-Schema che ne stabilisce le regole che abbiamo indicato in precedenza, tale link è espresso attraverso un attributo del root-tag:

<Letterina
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:noNamespaceSchemaLocation="letterina.xsd">
...
</Letterina>

Le regole quindi sono contenute nel file Schema letterina.xsd, ma come può essere fatta una grammatica di questo genere?

Tanto per cominciare un file di Schema ha il seguente root-tag:

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
...
</xs:schema>

che identifica il namespace di riferimento e contiene tutti gli elementi della grammatica.

Ogni singolo elemento che sarà possibile trovare all’interno dal documento XML da validare è composto, nella grammatica, da un elemento di questo genere:

<xs:element name="NomeElemento" type="TipologiaElemento"/>

Nel caso in cui si tratti di un elemento complesso, ovvero formato da più elementi figli, la sintassi è la seguente:

<xs:element name="NomeElementoComplesso">
   <xs:complexType>
      <xs:sequence>
         <xs:element name="FiglioComplesso" type="FiglioComplessoType"/>
         <xs:element ref="FiglioSemplice"/>
      </xs:sequence>
   </xs:complexType>
</xs:element>

Naturalmente da qualche parte all’interno della nostra grammatica dovremo avere le definizioni per l’oggetto FiglioComplesso e FiglioSemplice.

Nel caso dello Schema per la letterina in XML avremo sicuramente questo frammento di codice che identifica la struttura generale della letterina.

<xs:element name="Letterina">
   <xs:complexType>
      <xs:sequence>
         <xs:element name="Mittente" type="MittenteType"/>
         <xs:element ref="TestoLetterina" minOccurs="0"/>
         <xs:element name="ListaRegali" type="ListaRegaliType"/>
         <xs:element ref="Complimenti"/>
      </xs:sequence>
   </xs:complexType>
</xs:element>

Come si vede il root-tag del documento XML dovrà essere <Letterina>, composto esattamente dagli elementi indicati, i quali sono tutti obbligatori tranne <TestoLetterina> che, secondo specifica, è opzionale.

Gli oggetti <TestoLetterina> e <Complimenti> sono semplici stringhe di testo descritte dal codice seguente:

<xs:element name="TestoLetterina" type="xs:string"/>
<xs:element name="Complimenti" type="xs:string"/>

L’elemento <Mittente> è anch’esso un oggetto complesso descritto dalla sezione:

<xs:complexType name="MittenteType">
   <xs:sequence>
      <xs:element ref="Nome"/>
      <xs:element ref="Cognome"/>
      <xs:element name="Indirizzo" type="IndirizzoType"/>
   </xs:sequence>
</xs:complexType>

Dove gli oggetti <Nome> e <Cognome> sono stringhe di testo descritte dal codice seguente:

<xs:element name="Nome" type="xs:string"/>
<xs:element name="Cognome" type="xs:string"/>

Mentre l’oggetto <Indirizzo>, anch’esso complesso come si può vedere, è descritto dal codice seguente:

<xs:complexType name="IndirizzoType">
   <xs:sequence>
      <xs:element ref="Via"/>
      <xs:element ref="Citta"/>
      <xs:element ref="Cap_Zip"/>
      <xs:element ref="Paese"/>
   </xs:sequence>
</xs:complexType>

<xs:element name="Via" type="xs:string"/>
<xs:element name="Citta" type="xs:string"/>
<xs:element name="Cap_Zip" type="xs:string"/>
<xs:element name="Paese" type="xs:string"/>

La lista dei regali vera e propria è descritta nell’oggetto complesso <ListaRegali>, vediamone la descrizione:

<xs:complexType name="ListaRegaliType">
   <xs:sequence>
      <xs:element name="Regalo" type="RegaloType" maxOccurs="3"/>
   </xs:sequence>
</xs:complexType>

Come si può vedere è possibile richiedere al massimo 3 regali, dove ogni regalo è un oggetto complesso descritto dal codice seguente:

<xs:complexType name="RegaloType">
   <xs:sequence>
      <xs:element name="Produttore" type="ProduttoreType"/>
      <xs:element ref="Descrizione"/>
      <xs:element ref="Prezzo_Euro" />
   </xs:sequence>
</xs:complexType>

<xs:element name="Descrizione" type="xs:string"/>
<xs:element name="Prezzo_Euro" type="xs:byte"/>

La <Descrizione> è una stringa ed il <Prezzo_Euro> è un numerico.
Leggermente più complesso è l’oggetto <Produttore> che rappresenta il produttore del giocattolo in questione. Il codice che lo descrive è il seguente:

<xs:complexType name="ProduttoreType">
   <xs:sequence>
      <xs:element ref="Ragione_Sociale"/>
      <xs:element name="Indirizzo" type="IndirizzoType"/>
   </xs:sequence>
</xs:complexType>

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

Dove la <Ragione_Sociale> è una semplice stringa e l’oggetto <Indirizzo> è lo stesso oggetto che avevamo descritto in precedenza.

A questo punto i pezzi del mosaico ci sono tutti, vediamo una panoramica della struttura dell’oggetto <Letterina> prodotta utilizzando il magnifico strumento XML Spy di Altova:

E vediamo anche una panoramica dell’oggetto <ListaRegali>:

A questo punto siamo possiamo mettere insieme i pezzi del mosaico e generare il file di Schema letterina.xsd con il quale Babbo Natale sarà in grado di verificare la correttezza semantica delle letterine che gli giungeranno in formato XML.