Validació de Documents XML amb XSD

Llenguatge de marques i
sistemes de gestió d'informació
UF 1: Programació amb XML
Part 3c

Validació amb
XML Schema Definition
Language
Xavier Sala Pujolar
IES Cendrassos

XML Schemas
Les limitacions dels DTD van fer sorgir un
nou sistema per definir llenguatges XML

XML Schemas Definition
Language (XSD)

Administració de Sistemes Informàtics i Xarxes

XSD
●
●

És un estàndard del W3C
La versió actual és la 1.1 però es pot veure si hi
ha versions noves en la pàgina:
http://www.w3c.org/XML/Schema


XSD
Els DTD són un llenguatge nou, amb
noves regles, etc...

Els XSD són documents XML!


XSD
En DTD no es pot control·lar el
contingut de les etiquetes

Els XSD inclouen tipus de
dades per control·lar el
contingut
Pemeten definir restriccions


XSD
En DTD no es poden validar
documents que estiguin formats per
dos llenguatges diferents

Els XSD inclouen suport per
fer servir espais de noms


Validació
●

●

La majoria dels validadors poden validar els
XML Schemas
Per exemple amb xmllint ho podem fer:
$ xmllint --noout --schema ./exercici.xsd exercici.xml
exercici.xml validates

S'hi afegeix la opció
“schema” i el fitxer
d'esquema

XMS Schema

Associar l'esquema
a un fitxer XML


Associar un XSD
●

Tots els XML validats per XSD tindran definit
l'espai de noms de XSD en l'arrel:
<?xml version=”1.0” encoding=”UTF-8” ?>

<lliga xmlns:xsi="
http://www.w3.org/2001/XMLSchema-instance" ... >

...
</lliga>

Associar un XSD a un XML
●

I el lloc on es troba el fitxer de definició

<lliga xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation=”fitxer.xsd”>
<equip>FC Barcelona</equip>
<equip>Real Madrid</equip>
</lliga>

●

El lloc on està el fitxer pot ser una URL:
xsi:SchemaLocation=”http://www.lloc.com/fitxer.xsd”

XMS Schema

Definir un fitxer d'esquema


Definir un fitxer d'esquema
●

L'arrel del XSD és l'etiqueta <schema> on
sempre s'hi definirà l'espai de noms 'xmlns'
<xs:schema xmlns:xs=
"http://www.w3.org/2001/XMLSchema">
...
</xs:schema>

El valor xs pot ser qualsevol
cosa: xsi, patata, ...

Notes
●

Es poden fer servir els comentaris XML però
també defineix etiquetes per posar comentaris
<xs:annotation>
<xs:documentation>
Aquest esquema XML està pensat per fer
Proves. Però aquí hi podria posar qualsevol
Cosa
</xs:documentation>
</xs:annotation>

Poden anar a qualsevol lloc del
document

XML Schemas
●

En XSD definim dos tipus d'etiquetes:

Etiquetes de
tipus simple

Només contenen
dades

Etiquetes de
tipus complexe

No contenen res,
altres etiquetes, o
tenen atributs


XML Schema

Tipus simples


Tipus simple
●

Una etiqueta de tipus simple és la que només
conté dades.
<nom>Xavier</nom>
<any>2010</any>

Complexes

Aquesta és
simple!!

Simples

<cotxe marca=”Opel”>
Corsa
</cotxe>
<data>
<any>2010</any>
</data>

Tipus simples
●

L'etiqueta que serveix per definir etiquetes és
<element>

<xs:element name=”nom” type=”xs:string”/>

Definició
Element

Nom de l'etiqueta
En aquest exemple
és nom

Tipus de dades
que contindrà
l'etiqueta

Tipus simples
●

Amb els tipus de dades podem controlar quin
és el contingut de les etiquetes.
<xs:element name=”nom”
type=”xs:string” />
<xs:element name=”any”
type=”xs:integer”/>

<nom>Xavier</nom>
<any>2010</any>

Tipus de dades
●

Els tipus bàsics els podem trobar a
http://www.w3.org/TR/xmlschema-0/#CreatDt :
Tipus

Explicació

xs:string

Contindrà una cadena de caràcters

xs:decimal

Contindrà un número

xs:boolean

Contindrà 'true' o 'false' o (1 o 0)

xs:date

Contindrà una data (AAAA-MM-DD)

xs:anyURI

Contindrà una referència a un lloc (URL, disc...)

xs:base64binary

Es fa servir per representar dades binàries


Tipus de dades
●

Hi solen haver variants de cada tipus per
adaptar-se millor al que cal:
–

Text: string, normalizedString, token, Name,
NMTOKEN, ...

–

Números: integer, positiveInteger,
negativeInteger, nonNegativeInteger,
nonPositiveInteger, long, unsignedLong, int,
unsignedInt, byte, unsignedByte, decimal, float,
double

–

Dates: duration, dateTime, date, time, gYear,
gMonth, gYearMonth, gDay, gMonthDay,


Tipus de dades: exemples
<xs:element name=”dia”
type=”xs:date” />
<xs:element name=”mes”
type=”xs:gMonth” />
<xs:element name=”altura”
type=”xs:integer” />
type=”xs:string” />
<xs:element name=”altura”
type=”xs:float” />
<xs:element name=”lloc”
type=”xs:anyURI” />

<dia>2010-09-15</dia>
<mes>--3</mes>
<altura>220</altura>
<nom>Xavier</nom>
<altura>1.7E2</altura>
<lloc>
http://www.iescendrassos.net
</lloc>

Altres atributs
●

Els elements simples poden ser alterats perquè
funcionin de determinades formes
Atribut

Valors fixes
Valors per defecte
Vegades que pot sortir
l'etiqueta
Restringir valors

fixed
default
MaxOccurs, MinOccurs
restriction

Llistes de valors
Unions

Valors fixes
●

Podem definir que un element té un valor fixe
definint-lo amb l'etiqueta 'fixed'

<xs:element name=”cap” type=”xs:string”
fixed=”Manel” />
●

Això ens permet definir:
<cap>Manel</cap>
<cap></cap>

●

Però no:
<cap>Xavier</cap>

Valors predefinits
●

Podem definir que un element té un valor
predefinit definint-lo amb l'etiqueta 'default'
default=”Manel” />

●

Això ens permet definir:
<cap>Manel</cap>
<cap></cap>
<cap>Xavier</cap>

Ocurrències
●

Es poden definir les vegades que ha de sortir
un element com a mínim
minOccurs=”1” />
–

●

Si té un valor de 0 és que no té mínim

O com a màxim:
maxOccurs=”3” />
–

'unbounded' implica un número indeterminat de
vegades


Restriccions
●

●

Podem fer modificacions als tipus simples
posant-hi restriccions
Es defineixen els nous tipus restringits amb
SimpleType
<xs:element name=”naixement”>
<xs:simpleType>
...
</xs:simpleType>
</xs:element>

Restringir els tipus simples
●

Després amb l'etiqueta xs:restriction s'hi
defineix el tipus del que es vol fer la restricció
<xs:simpleType>
<xs:restriction base=”xs:integer” >

...
</xs:restriction>
</xs:simpleType>
</xs:element>

De quin tipus fem la
restricció

Restringir els tipus simples
●

Dins es defineix quina restricció hi volem
aplicar:
<xs:simpleType>
<xs:restriction base=”xs:integer” >

...
</xs:restriction>
</xs:simpleType>
</xs:element>
Quina restricció es vol
fer

Restriccions
●

Les restriccions es defineixen amb etiquetes:
<xs:maxInclusive value=”5” />
<xs:minInclusive value=”2” />
<xs:length value=”4” />
<xs:minLength value=”3” />
<xs:maxLength value=”6” />
<xs:enumeration value=”A” />
<xs:enumeration value=”B” />
<xs:enumeration value=”C” />

Definim un rang de valors.
Serveix tant per números com
per dates
Definim la llargada del valor d'un
camp
Permeten definir un conjunt de
valors acceptables

Permet definir el número de
<xs:totalDigits value=”5” />
dígits d'un valor numèric o dels
<xs:fractionDigits value=”3” />
seus decimals
Defineix valors basats en una
<xs:pattern value=”w_d{3}” /> expressió regular

Restriccions de valors
●

En aquest exemple es restringeix el valor de
l'etiqueta naixement a un valor entre 1900 i
2012:
<xs:simpleType>
<xs:restriction base=”xs:integer”>


</xs:restriction>
</xs:simpleType>
</xs:element>

Crear tipus nous
●

Els tipus simples es poden reaprofitar en altres
llocs del document posant-hi nom:
<xs:simpleType

name=”data_vida”>

<xs:restriction base=”xs:integer”>
</xs:restriction>
</xs:simpleType>

Crear tipus nous
●

Un cop definit un tipus amb nom es pot fer
servir com un tipus normal
<xs:element name=”vida”
type=”data_vida” />
<xs:element name=”mort”
type=”data_vida” />

No hi haurà cap diferència
amb els altres

Restriccions amb patrons
●

Els patrons són un avenç força important amb
respecte als DTD
–

●

Permeten ajustar el contingut d'una etiqueta de
manera que s'ajusti a valors arbitraris

Es defineixen amb l'etiqueta <xs:pattern>
<xs:pattern value=”d{5}” />

●

La clau de tot està en els valors que es posen
en l'atribut value

Patrons
.
d
D
s
S
x*
x?
x+
[abc]
[0-9]
x{5}
x{5,}
x{5,8}
(xyz){2}

Qualsevol caràcter
Qualsevol dígit
Qualsevol no dígit
Espais en blanc, tabuladors, salts de línia
Qualsevol caràcter que no sigui algun dels anteriors
Hi han d'haver zero o més x
Hi ha d'haver o una o cap x
Hi ha d'haver una o més x
Hi ha d'haver algun dels caràcters de dins dels corxets
Un valor entre 0 i 9
Hi han d'haver 5 x seguides
Hi han d'haver almenys 5 x seguides
Hi han d'haver entre 5 i 8 x seguides
Hi ha d'haver dues vegades el de dins del parèntesi

Patrons
●

Això permet definir una etiqueta que obligui a
que el contingut sigui com un DNI:
–

8 números: [0-9]{8}, Un guió: - i una lletra en majúscules: [A-Z]

<xs:element name=”dni”>
<xs:simpleType>
<xs:restriction base=”xs:string”>
<xs:pattern value=”[0-9]{8}-[A-Z]” />
</xs:restriction>
</xs:simpleType>
</xs:element>

<dni>77980433K</dni>

Llistes
●

Les llistes de valors es defineixen amb <list>
<xs:element name=”partits”>
<xs:simpleType>
<xs:list itemType=”xs:dateTime” />
</xs:simpleType>
</xs:element>

<partits>
2010-09-12T17:30
2010-09-19T19:00
</partits>

Unions
●

O definir continguts de diferents grups
<xs:element name=”valor”>
<xs:simpleType>
<xs:union
memberTypes=”euros pessetes” />
</xs:simpleType>
</xs:element>

●

En l'exemple el valor haurà de ser un valor dels
tipus “euros” o de “pessetes”
–

S'han de posar tipus obligatòriament

XML Schema

Tipus complexes


Tipus complexes
●

●

Un tipus complexe és un que conté elements
fills, atributs o una combinació d'ambdós
Normalment sempre hi haurà com a mínim un
tipus complexe en els documents: l'arrel
<cos>
<cap>
<ulls />
<nas />
<boca />
</cap>
</cos>

Tipus complexes
●

Els tipus complexes es divideixen en altres
tipus complexes o en tipus simples
<cos>
<cap>
<ulls />
<nas />
<boca />
</cap>
<cos>
<cames />
</cos>

Complexe format
per complexes

Complexe format
per simples

Tipus complexes
●

No hi ha tipus complexes predefinits i per tant
cal definir-los
<xs:element name=”fabricacio”>
<xs:complexType>
...
</xs:complexType>
</xs:element>

El definim igual
que abans però el
derivem de
complexType

Atributs
●

Una diferència amb els tipus simples és que els
complexes poden contenir atributs
<cos animal=”cuc”>
<cap>
<ulls color=”blau” numero=”2”/>
<nas />
<boca />
</cap>
</cos>

Atributs
●

L'etiqueta que serveix per definir atributs és
<attribute>

<xs:attribute name=”nom” type=”xs:string”/>

Definició d'un
atribut

Nom de l'atribut
En aquest exemple
és nom

Tipus de dades
que hi haurà en
l'atribut

Els atributs sempre
són per defecte
opcionals

Atributs
●

S'hi pot treballar igual que amb els elements

<xs:attribute name=”Id”>
<xs:simpleType>
<xs:restriction base=”xs:integer” />
<xs:pattern value=”d{4}” />
</xs:restriction>
</xs:simpleType>
</xs:attribute>
Però el seu contingut no pot
ser complexe

Atributs: use
●

Per fer un atribut obligatori es fa servir
use=”required”
<xs:attribute name=”src”
type=”xs:anyURI” use=”required” />

●

●

Perquè no es faci servir posem
use=”prohibited”
També existeix la opció use=”optional” però
rarament es fa servir

Atributs
●

Com amb les etiquetes podem definir valors per
defecte, valors fixes i grups d'atributs
<xs:attribute name=”numero” type=”xs:integer”
Default=”1” />
<xs:attribute name=”especial” type=”xs:integer”
fixed=”Disabled” />
<xs:attributeGroup name=”Persones”>
...
</xs:attributeGroup>
<xs:attributeGroup ref=”Persones” />

Atributs
●

Els atributs es defineixen al final de la definició
del ComplexType
<element name=”animal”>
<xs:complexType>
...
...
<xs:attribute name="nom" type="xs:string"
use="required"/>
</xs:complexType>
</element>

complexType
●

Resumint, els tipus complexes poden tenir dos
tipus de continguts

Etiquetes

Dades


complexType
●

Els continguts de tipus de text es defineixen
amb dues etiquetes:
<xs:simpleContent>
Contingut complex

Contingut simple

<xs:complexContent>

simpleContent
●

El cas més simple de tipus complexe és tenir
una etiqueta amb contingut i atributs
<persona tipus=”home”>Manel Puig </persona>

Té un atribut o sigui que és
complexType

Però el contingut és simple

simpleContent
simpleContent per indicar
que el valor és simple

<xs:element name="persona">
<xs:complexType>
<xs:simpleContent>

Tipus integer

<xs:extension base="xs:string">
<xs:attribute name="tipus" type="xs:string"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</element>

L'atribut

complexType
●

Quan el contingut són etiquetes es defineix a
partir de tres etiquetes
<xs:all>
<xs:sequence>
Tria d'etiquetes

Seqüències d'etiquetes

<xs:choice>

Seqüències ordenades
●

Seqüències ordenades d'elements
<xs:sequence>
<xs:complexType nom=”persona”>
<xs:sequence>
type=”xs:string”/>
<xs:element name=”cognom”
type=”xs:string” maxOccurs=”2”/>
</xs:sequence>
</xs:complexType>
–

Es defineixen en l'ordre en el que els volem

–

Pot contenir altres seqüències ...

Seqüències desordenades
●

Quan ens interessi que els elements apareguin
en qualsevol ordre fem servir <xs:all>
<xs:all>
<xs:element name=”cognom”
</xs:all>
</xs:complexType>
–

Les etiquetes han d'aparèixer només un cop i
només pot contenir elements

Seqüències desordenades
●

Però s'ha de tenir en compte que les etiquetes
dins de all només poden sortir UN COP
<A>
<a>A1</a>
B1
B2
</A>

●

<xs:all>
<xs:element name=”a” type=”xs:string”/>
<xs:element name=”b” type=”xs:string”
maxOccurs=”2” />
</xs:all>

Una solució alternativa pot ser crear un tipus
complexe amb la repetició
<A>
<a>A1</a>
B1
B2
</A>

<xs:all>
<xs:element name=”a” type=”xs:string”/>
<xs:element name=”b” type=”tipus-B” />
</xs:all>

Tria d'elements
●

Podem definir o uns elements o uns altres
<xs:choice>
<xs:choice>
<xs:element name=”nomCognom”
<xs:element name=”dni”
</xs:choice>
</xs:complexType>
–

A dins hi poden haver seqüències i es pot niuar

Tria d'elements: Determinisme
●

●

S'ha de tenir en compte que davant de cada
decisió el processador ha de saber per quin
camí ha de tirar
No es poden fer coses com:
<xs:choice>
<xs:sequence>
<xs:element name=”nom”/>
<xs:element name=”alies”/>
<xs:element name=”cognom”/>
</xs:sequence>
<xs:sequence>
<xs:element name=”nom”/>
<xs:element name=”cognom”/>
</xs:sequence>
</xs:choice>

El processador
no sabrà quina
alternativa triar

Tipus complexes buits
<xs:element name=”Persona”>
<xs:complexType name="Mida">
<xs:attribute name="metres" type="xs:token"/>
</xs:complexType>
</xs:element>
●

Es defineixen els
atributs sense res més

Si no té atributs podem definir

<xs:complexContent>
<xs:restriction base="xs:anyType"/>
</xs:complexContent>

Elements buits
●

Si no té atributs també podria haver definit la
etiqueta amb el tipus simple
–

Definint-ne la llargada a zero

<xs:element name="delegat">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:length value="0"/>
</xs:restriction>
</xs:simpleType>
</xs:element>

Tipus complexes mixtes
●

Un element pot contenir etiquetes i text.
<xs:complexType name="Mida"

mixed=”true” >

<xs:sequence>
<xs:element name=”metres” />
<xs:element name=”centimetres” />
</xs:sequence>
</xs:complexType>
Si volem fer les mescles hem de
declarar que l'element serà de
tipus mixed

Contingut barrejat
●

Amb això podrem validar coses com:

<carta>Estimat senyor <nom>Pere<nom>:
Li envio aquesta carta per recordar-li que hem quedat per
trobar-nos el dia <cita>12</cita>
Joan
</carta>
<xs:element name=”carta”>
<xs:complexType mixed=”true”>
<xs:sequence>
<xs:element name=”nom” type=”xs:string” />
<xs:element name=”cita” type=”xs:integer” />
</xs:sequence>
</xs:complexType>
</xs:element>

Altres
●

Per determinar quants n'hi ha d'haver podem
fer servir minOccurs i maxOccurs en l'element

<xs:complexType name="moneder">
<xs:choice minoccurs=”1” maxoccurs=”4”>
●

Si un grup d'elements surten varies vegades
podem definir un grup

<xs:group name="moneder">
...
</xs:group>
<xs:group ref=”moneder” />
–

S'han de definir al principi del fitxer

Referències a elements
●

Podem definir els elements de forma global i
després usar-los en les definicions de tipus

<xs:element name=”cognom” type=”xs:string” />
<xs:element name=”persona”>
<xs:complexType>
<xs:element ref=”nom” />
<xs:element ref=”cognom” />
</xs:complexType>
</xs:element>
–

Això ens permetrà reusar-los quan ens facin falta

XML Schema

Exemple


XML
●

Volem fer un Schema per validar aquest
document:
<?xml version="1.0" encoding="UTF-8"?>
<classe>
<curs>1r ASIX</curs>
<professor>
<nom>Xavier Sala</nom>
</professor>
<alumnes>
<nom>Federicu Garcia</nom>
<nom>Mariano Pi</nom>
<nom>Filomenu Bonany</nom>
</alumnes>
</classe>

Modificar l'XML
●

El primer és afegir en la definició de l'etiqueta
arrel, “classe”, quin serà el document.

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

●

Com que no definirem cap espai de noms fem
servir noNamespaceSchemaLocation

En el document XML no hi hem de fer res més

Crear el XSD
●

Hem de crear el document XSD:
<xs:schema
xmlns:xs="http://www.w3.org/2001/XMLSchema">
...
</xs:schema>

●

Hi ha diverses formes d'atacar-lo:
–

Anar definint les etiquetes tal com estan en el
document

–

Definir els tipus simples i anar muntant els
complexes a partir d'aquests

–

Amb tipus amb nom

Crear el XSD: possibilitat 1
●

Partim de la etiqueta arrel i hi definim el
contingut: curs, professor i alumnes
<xs:element name="classe">
<xs:complexType>
<xs:sequence>
<xs:element name="curs" type="xs:string" />
<xs:element name="professor"> </xs:element>
<xs:element name="alumnes"> </xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
–

L'etiqueta “curs” és simple : ja està

–

Les altres els haurem de definir més
detalladament

●

O sigui:
<xs:element name="classe">
<xs:complexType>
<xs:sequence>
<xs:element name="professor" maxOccurs="1">
<xs:complexType>
<xs:sequence>
<xs:element name="nom" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="alumnes" >
<xs:complexType>
<xs:sequence>
<xs:element name="nom" type="xs:string"
maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>

●

Normalment un millor sistema és definir-ho amb
referències perquè és més mantenible
–

Comencem pels tipus simples

–

I després els complexes a partir de les
referències

<xs:element name="professor">
<xs:complexType>
<xs:sequence>
<xs:element ref=”nom” maxOccurs=”1” />
</xs:sequence>
</xs:complexType>
</xs:element>

<xs:element name="alumnes">
<xs:complexType>
<xs:sequence>
<xs:element ref=”nom” maxOccurs=”unbounded” />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name=”classe”>
<xs:complexType>
<xs:sequence>
<xs:element ref=”curs” />
<xs:element ref=”professor” />
<xs:element ref=”alumnes” />
</xs:sequence>
</xs:complexType>
</xs:element>

●

I sempre podem recórrer a fer tipus amb nom
per crear l'esquema:
–

Hem de definir els tipus simples per poder-los
combinar en compostos

<xs:simpleType name="tipusnom" >
<xs:restriction base="xs:string"/>
</xs:simpleType>
<xs:simpleType name="tipuscurs">
<xs:restriction base="xs:string" />
</xs:simpleType>

●

I després la resta
<xs:complexType name="tipusprofessor">
<xs:sequence>
<xs:element name="nom" type="tipusnom"
maxOccurs="1" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="tipusalumne">
<xs:sequence>
<xs:element name="nom" type="tipusnom"
maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>

●

I acabem amb l'element arrel
<xs:complexType name="tipusalumne">
<xs:sequence>
<xs:element name="curs" type="tipuscurs" />
<xs:element name="professor" type="tipusprofessor" />
<xs:element name="alumnes" type="tipusalumne" />
</xs:sequence>
</xs:complexType>
<xs:element name=”classe” type=”tipusalumne” />

Validació de Documents XML amb XSD

Recomendados

Mais conteúdo relacionado

Semelhante a Validació de Documents XML amb XSD

Semelhante a Validació de Documents XML amb XSD (6)

Mais de Xavier Sala Pujolar

Mais de Xavier Sala Pujolar (19)

Último

Último (6)

Validació de Documents XML amb XSD