Illustriamo ora la struttura di un file XSD e i suoi principali componenti, conlo scopo è quello di fornire una conoscenza base dell’XSD; per una trattazione completa di XSD potete fare riferimento a [1]. Tutti i componenti del XML schema sono contenuti all’interno della seguente struttura:

<?xml version="1.0" encoding="UTF-8"?>

come possiamo vedere è stato definito il namespace xs e quindi tutti i componenti dell’XML schema saranno preceduti da “xs:”

-Dichiarazione di un elemento

Il componente principale di un XML schema è ELEMENT che definisce i tag che saranno contenuti nel nostro formato xml:

In questo caso “mioTag” sarà un tag valido all’interno del mio file XML e dovrà contenere una stringa. Posso anche definire altre caratteristiche del mio elemento oltre al nome e al tipo, come il valore di default del mio tag, oppure il numero massimo e minimo di occorrenze che posso avere per questo determinato tag. XML schema ha un certo insieme di tipi di dato predefiniti; i più comuni sono i seguenti:

E’ pero possibile definire dei nuovi tipi di dato, semplici o complessi con cui possiamo definire i nostri element.

-Definizione di un tipo

XML schema ci permette di definire nuovi tipi di dato oltre quelli predefiniti;

Tipi semplici:

Posso definire tipi di dato semplici, i quali non possono contenere altri elementi e non prevedono attributi. Vengono spesso utilizzati per derivare i tipi di dato predefiniti vincolando i valori ad uno specifico sottoinsieme. Ad esempio
<xs:simpleType name="intervallo">
   <xs:restriction base="xs:integer">
      <xs:minInclusive value="0"/>
      <xs:maxInclusive value="100"/>
   </xs:restriction>
</xs:simpleType>
<xs:element name="valore" type="xs:intervallo">

Abbiamo definito un nuovo tipo di dato “intervallo” che deriva da xs:integer ma limita i valori possibili tra 0 e 100. In seguito è stato dichiarato un elemento “valore” di tipo intervallo. Vedremo nel dettaglio le restrictions più avanti.

Tipi complessi:

Un tipo di dato complesso, al contrario dei tipo semplice, può contenere altri elementi e degli attributi:

<xs:complexType name="personainfo">

   <xs:sequence>

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

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

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

      <xs:element name="nazionalità" type="xs:string"/>

   </xs:sequence>

   <xs:attribute name="lingua" type="xs:string" default="IT"/>

</xs:complexType>

<xs:element name="impiegato" type="personainfo"/>

Il tipo complesso “personainfo” è formato da 4 elementi di tipo stringa (nome,cognome,professione ,nazionalità) e un attributo che descrive la lingua in cui sono espressi gli elementi. Il tag “xs:sequence” è un indicatore di ordine; gli indicatori di ordine specificano come gli elementi figli devono occorrere:

Gli elementi che formano un tipo complesso possono essere a loro volta di tipo complesso.

-Dichiarazione di un attributo

Come abbiamo visto nell’esempio precedente, è possibile definire uno o più attributi per un certo tipo di elemento che abbiamo definito. Tutti gli attributi sono dichiarati come tipi semplici. La sintassi per dichiarare un attributo è :

<xs:attribute name="xxx" type="yyy" default="zzz" use="required"/>

dove “default” definisce il valore dell’attributo se non viene specificato, e “use” definisce le l’attributo è richiesto o opzionale.

-Facets

I Facets sono delle restrizioni che usate per controllare i valori accettabili di un tag o di un attributo. Il costrutto che viene utilizzato per implementare i Facets è “xs:restictions” che abbiamo incontrato nella definizione dei tipi semplici. La sintassi è la seguente:

<xs:simpleType name="nomeTipo">

   <xs:restriction base="[tipo base]">

         …

            <xs:[tipo restriction] value="[valore]"/>

         …

   </xs:restriction>

</xs:simpleType>

dove [tipo base] è il tipo di partenza a cui sono applicate le restrizioni, [tipo restriction] è il tipo di restrizione applicata (vedi tabella 1), [valore] è il valore con cui viene applicata la restrizione.

Sono possibili diversi tipi di restrizioni, riportiamo di seguito una tabellacon tutte le restrizioni possibili:

L’utilizzo dei Facets permette di automatizzare molti controlli usati comunemente in varie applicazioni; per una trattazione completa dei Facets fate riferimento a [1].

<?xml version="1.0" encoding="UTF-8"?>
<xs:schemaxmlns:xs="http://www.w3.org/2001/XMLSchema"  targetNamespace="http://www.k-tech.it/Assicurazione"xmlns:as="http://www.k-tech.it/Assicurazione"elementFormDefault="qualified" attributeFormDefault="unqualified">
<xs:element name="Assicurazione">
   <xs:complexType>
      <xs:sequence>
         <xs:element name="Autisti" type="as:AnagraficaType" maxOccurs="unbounded"/>
         <xs:element name="Veicolo" type="as:VeicoloType"/>
         <xs:element name="Opzioni" type="as:OpzioniType"/>
      </xs:sequence>
      <xs:attribute name="Lingua" type="xs:string" use="required"/>
   </xs:complexType>
</xs:element>
<xs:simpleType name="AutoType">
   <xs:restriction base="xs:string">
      <xs:enumeration value="Audi"/>
      <xs:enumeration value="Bmw"/>
      <xs:enumeration value="Mercedes"/>
   </xs:restriction>
</xs:simpleType>
<xs:complexType name="OptionalType">
   <xs:sequence>
      <xs:element name="ABS" type="xs:boolean"/>
      <xs:element name="Antifurto" type="xs:boolean"/>
   </xs:sequence>
</xs:complexType>
<xs:complexType name="AnagraficaType">
   <xs:sequence>
      <xs:element name="Nome" type="xs:string"/>
      <xs:element name="Cognome" type="xs:string"/>
      <xs:element name="Età" type="xs:int"/>
      <xs:element name="Provincia" type="xs:string"/>
   </xs:sequence>
</xs:complexType>
<xs:complexType name="VeicoloType">
   <xs:sequence>
      <xs:element name="Marca" type="as:AutoType"/>
      <xs:element name="Modello" type="xs:string"/>
      <xs:element name="Optional" type="as:OptionalType" minOccurs="0"/>
   </xs:sequence>
</xs:complexType>
<xs:complexType name="OpzioniType">
   <xs:sequence>
      <xs:element name="BonusMalus" type="xs:int"/>
      <xs:element name="FurtoIncendio" type="xs:boolean"/>
      <xs:element name="AttiVandalici" type="xs:boolean"/>
   </xs:sequence>
</xs:complexType>
</xs:schema>

 Listato assicurazione.xsd

Per la costruzione dell’XML schema consigliamo di utilizzare un tool per la gestione di file XML; per esempio XMLSpy [2] permette la costruzione in modo grafico dell’XSD:

Per utilizzare gli XMLBeans dobbiamo innanzitutto scaricare il software necessario dal sito della Apache Foundation [3]. Quindi è necessario settare l’ambiente in questo modo:

A questo punto possiamo creare la nostra libreria java per gestire un file XML che rispetti il formato che abbiamo definito con “assicurazione.xsd”. Ci posizioniamo nella directory contenente il nostro file XSD e digitiamo:

Al termine della compilazione nella nostra directory avremo il file “assicurazione.jar” che contiene la nostra libreria pronta per l’uso, e la directory “assicurazione” che contiene i file sorgenti della libreria appena creata. Normalmente la direttiva “-src” viene omessa, ma nel nostro caso la utilizziamo per analizzare il codice creato dagli XMLBeans.

Innanzi tutto notiamo che il codice generato è contenuto in un package nominato come il namespace URI dell’ XSD. Quindi, nel nostro caso, nella directory “it\kTech\assicurazione“ troviamo le classi più importanti per la gestione dell’XML; possiamo notare che è stata creata un’interfaccia “AssicurazioneDocument” la quale incapsula l’intero documento XML, inoltre per ogni tipo complesso definito nell’XSD è stata generata un’interfaccia che lo gestisce. In generale la compilazione genera un’interfaccia per ogni elemento “globale” definito nell’XSD. Questa soluzione permette di utilizzare gli elementi globali come parti intere con tutti i metodi accessori (get & set) necessari. Da notare che tali metodi accessori possono utilizzare diversi tipi di valore; ogni tipo predefinito dell’ XML schemaviene mappato su un tipo naturale java e su un tipo di dato XMLBeans Type, ovvero un tipo di dato definito all’interno delle librerie di XMLBeans che può essere utilizzato al posto del tipo naturale java, e che fornisce delle funzioni aggiuntive. Ovviamente la nostra libreria comprende i metodi accessori per gestire entrambi i casi. Per la lista completa delle corrispondenze tra i vari tipi di dato potete consultare [4].

Vediamo ora come il codice generato sia perfetto per gestire un file xml che rispetti le regole dettate dall’XML schema. Innanzi tutto notiamo che per ogni tipo definito nell’XSD è stata creata un’interfacciae una classe che la implementa (contenuta nella directory “it\kTech\assicurazione\impl“) .

Apriamo l’interfaccia “AssicurazioneDocument.java” con un qualsiasi editor di testo. Notiamo che ,oltre i metodi accessori “get” e “set” di cui abbiamo parlato in precedenza, abbiamo un altro metodo accessorio “addNew” che restituisce un elemento vuoto che sarà poi riempito in seguito.

Notiamo inoltre gli elementi per cui è stata definito l’attributo maxOccurs come "unbounded" vengono gestiti tramite degli array.

E’ il caso dell’elemento “Autisti”, dove oltre i metodi accessori normali:

vengono creati dei metodi accessori indicizzati:

Allo stesso modo per gli elementi opzionali, ovvero quegli elementi in cui l’attributo “minOccour” è uguale a 0, vengono inseriti dei metodi per verificare se l’elemento è presente o settarlo come assente. Come nel caso dell’elemento “Optional” interno all’elemento “Veicolo”, nell’interfaccia “VeicoloType.java” possiamo trovare i seguenti metodi:

Esplorando ancora il codice generato da XMLBeans vediamo che il codice generato per gestire gli elementi che contengono dei Facets ci obbligano a rispettare le regole dell’XML schema. E’ impossibile quindi, ad esempio, creare un elemento di tipo “VeicoloType” con una “Marca” diversa da quelle predefinite.

Infine notiamo che ogni interfaccia che rappresenta un elemento dell’XML schema, contiene un’inner class “Factory” ,creata secondo il pattren abstract Factory ,che permette di creare un oggetto java che incapsula l’elemento.

<?xml version="1.0" encoding="UTF-8"?>

<Assicurazione xmlns="http://www.k-tech.it/Assicurazione"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.k-tech.it/Assicurazione
C:\LAVORO~1\ARTICO~1\xmlbeans-1.0.3\prove\assicurazione.xsd" Lingua="">

    <Autisti>

      <Nome>Alfonso</Nome>

      <Cognome>Iannotta</Cognome>

      <Età>31</Età>

      <Provincia>Roma</Provincia>

   </Autisti>

   <Veicolo>

      <Marca>Mercedes</Marca>

      <Modello>SLK</Modello>

   </Veicolo>

   <Opzioni>

      <BonusMalus>2</BonusMalus>

      <FurtoIncendio>true</FurtoIncendio>

      <AttiVandalici>true</AttiVandalici>

   </Opzioni>

</Assicurazione>

Questo è l’XML che rappresenta l’assicurazione della mia auto (Mercedes SLK magari ;-) )

Scriviamo il codice che legge il i dati del mio XML tramite la libreria generata da XMLBeans:

Compiliamo la classe avendo cura di inserire nel classpath le librerie XMLBeans e la libreria creata da noi assicurazione.jar. Mandiamo in esecuzione passando in input il path del file XML “miaAssicurazione.xml” precedentemente creato. Il risultato sarà:

Autisti
Numero Autisti 1
Autista 0
       Nome Alfonso
       Cognome Iannotta
       Eta 31
       Provncia Roma
Veicolo
        Marca Mercedes
        Modello SLK
Opzioni
        Bonus Malus 2
       Furto Incendio true
       Atti Vandalici true
fine elaborazione

Da notare che nella classe Assicura l’XML risulta trasparente, la gestione viene fatta completamente su oggetti Java. Inoltre non sono necessari controlli sulla presenza o meno di campi o sulla loro validità.

Riferimenti:

[1] http://www.w3schools.com/schema/schema_elements_ref.asp

[2] http://www.altova.com/

[3] http://xmlbeans.apache.org/

[4] http://xmlbeans.apache.org/docs/1.0.4/guide/conXMLBeansSupportBuiltInSchemaTypes.html