Cours gratuits » Cours informatique » Cours développement web » Cours XML » Cours sur les Schémas XML

Cours sur les Schémas XML

Problème à signaler:

Télécharger



★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Cours sur les Schémas XML avec exemples d’application

Un exemple introductif

  • Définition d'un élément <item> par une DTD

<!ELEMENT item (prodName+,USPrice,shipDate?)>

<!ATTLIST item partNum CDATA #implied>

<!ELEMENT prodName (#PCDATA)>

<!ELEMENT USPrice (#PCDATA)>

tyle="font-size: 8pt;"><!ELEMENT shipDate (#PCDATA)>

  • Exemple d'instance

<item partNum="124-PQ">

<prodName>imprimante</prodName>

<prodName>printer</prodName>

<USPrice>150</USPrice>

<shipDate>10/4/04</shipDate>

</item>

item

shipDate

prodName

USPrice

@partNum

prodName

Séquence

Élément racine d’un schéma xmlschema

<?xml version="1.0"?>

<xs:schema

xmlns:xs="…/2001/XMLSchema"

targetNamespace="example "

xmlns=" example ">

...

...

</xs:schema>

XMLSchema un dialecte XML

  • Espace de noms du dialecte XMLSchema

– Préfixe recommandé xs:

Définition par schémaXML

<xs:element name="item">

<xs:complexType>

<xs:sequence>

<xs:element name="prodName"

type="xs:string" maxOccurs="5"/>

<xs:element name="USPrice"

type="xs:decimal"/>

<xs:element name="shipDate"

type="xs:date" minOccurs="0"/>

</xs:sequence>

<xs:attribute name="partNum" type="SKU"/>

</xs:complexType>

</xs:element>

Séquence

Types prédéfinis

Type utilisateur

Définition d'un type utilisateur

<!– Code Produit -->

<xs:simpleType name="SKU">

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

<xs:pattern value="\d{3}-[A-Z]{2}"/>

</xs:restriction>

</xs:simpleType>

  • XMLSchema est un dialecte XML

– C'est plus bavard que les DTDs …

DTD versus XMLSchema

shipDate

prodName

USPrice

@partNum

prodName

item

Composant

prodName

USPrice

ShipDate

@partNum

DTD

#PCDATA

#PCDATA

#PCDATA

CDATA

XMLSchema

xs:string

xs:decimal

xs:date

xs:string + restriction

  • Plus de contraintes exprimées avec XMLSchema
  • Des types de base primitifs prédéfinis
  • xs:string, xs:decimal, xs:string, …
  • Des types définis par l'utilisateur

Déclaration d'un type dérivé

  • Le type SKU (code produit) est défini à l'aide d'une déclaration de type dérivée du type xs:string

<xs:simpleType name="SKU">

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

<xs:pattern value="\d{3}-[A-Z]{2}"/>

</xs:restriction>

</xs:simpleType>

  • Une contrainte sur la chaîne

– 3 chiffres + "-" + 2 lettres majuscules

– Exemple : 344-AB

  • La même restriction pourrait s'appliquer à un contenu

d'élément

shipDate

prodName

USPrice

@partNum

prodName

item

Contraintes d'occurrence dans les modèles de contenu

  • Un modèle de contenu peut contenir des contraintes d'occurrence. Exemple :

– N le nombre d'éléments <prodName>

– Contrainte : 0  N  5

<xs:element name="prodName" type="xs:string" minOccurs="0"

maxOccurs="5"/>

Contrainte : 7  N  12

  • DTD

<!ELEMENT biscuit(#PCDATA)>

<!ELEMENT commande(biscuit,biscuit,biscuit,biscuit, biscuit,biscuit,biscuit, biscuit?,biscuit?,biscuit?,biscuit?,biscuit?)>

  • XMLSchéma

<xs:element name="commande">

<xs:complexType>

<xs:sequence>

<xs:element name="biscuit" type="xs:string"

minOccurs="7" maxOccurs="12" />

</xs:sequence>

</xs:complexType>

</xs:element>

Types énumérés pour les attributs

  • DTD

<!ELEMENT person (description du contenu de person)>

<!ATTLIST person couleur (red | green ) "red">

  • XMLSchéma

<xs:simpleType name="color">

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

<xs:enumeration value="red"/>

<xs:enumeration value="green"/>

</xs:restriction>

</xs:simpleType>

<xs:element name="person" type="person_type">

<xs:complexType>

<xs:attribute name="couleur" type="color"/>

</xs:complexType>

</xs:element>

Schéma XML - Y. Bekkers 14

DTD et modèle de contenu d'élément

  • DTD

– Impossible de spécifier un type énuméré comme contenu d'élément

  • XMLSchéma

– Comme un attribut, un contenu d'élément peut être de type énuméré

– Exemple

<xs:element name="shoes" type="shoe_color">

Valeur par défaut

  • Element

<xs:element name="shoes" type="shoe_color" default="red">

  • Attribut

<xs:attribute

name="shoes" type="shoe_color"

default="red">

DTD versus XMLSchema résumé

  • Plus de sémantique exprimée par le schéma

– L'élément <shipDate> contient une date

– L'élément <USPrice> contient un décimal

– L'attribut @partNum contient une chaîne restreinte à certains modèles

  • Traitement orthogonale des attributs et des contenus d'élément (e.g. les types énumérés)
  • Contraintes d'occurrences plus souples

Vision W3C d'un schéma XML

  • Un schéma XML est construit sur deux ensembles complémentaires de constructions

– Les modèles de contenu

  • Modèle de contenu vide
  • Modèle de contenu simple (que du texte)
  • Modèle de contenu complexe (que des éléments)
  • Modèle de contenu mixte (texte + éléments)

– Les types de données

  • Type simple (attributs + éléments à contenu simple sans attribut)
  • Type complexe (éléments à contenu simple avec attribut + tous les autres)

Déclaration versus définition

  • Les schéma XML contiennent

– Des déclarations pour les composants d'instance de document

  • Éléments
  • Attributs
  • Notations

– Des définitions pour les composants internes au schéma

  • Types
  • Groupe modèles de contenu
  • Groupe d'attributs

Étude des éléments du langage

XMLSchema

Élément <xs:schema>

  • Élément racine d'un schéma XML

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

<xs:schema name="…"

xmlns:xs="…/XMLSchema">

<!–- constructions de niveau 0 -->

</xs:schema>

  • Constructions de niveau 0 (composants globaux)

– Des déclarations d'élément

– Des définitions de type complexes.

– Des définitions de types simples

– D'autres encore …/…

Composants globaux ou locaux

  • Les composants globaux apparaissent au premier niveau au sein de l'élément <xs:schema>

– Ils sont toujours nommés (attribut name="…")

– Leur nom doit être unique au sein de leur type de composant

  • Les composants locaux

– Leur nom a une portée locale au type complexe dans lequel ils sont définis

– Types simples et types complexes définis localement sont anonymes (ils ne peuvent être réutilisés)

Conflit de noms

  • Deux types ne peuvent avoir le même nom
  • Deux éléments de type différents dans la même portée ne peuvent avoir le même nom
  • Un type et un élément peuvent avoir le même nom

Type et élément de même nom

<xs:complexType name="figure" abstract="true">

<xs:attribute name="id" type="xs:string"/>

</xs:complexType>

<xs:element name="root">

<xs:complexType>

<xs:sequence>

<xs:element name="figure" type="a:figure"

maxOccurs="unbounded"/>

</xs:sequence>

</xs:complexType>

</xs:element>

Type simple et type complexe

  • Type simple permettent de donner un type aux :

– Éléments qui ne contiennent que du texte et sans d'attribut

  • Exemple <prénom>Yves</prénom>

– Attributs (leur contenu n'est que textuel !)

  • Type complexe permettent de donner un type aux :

– Éléments qui ne contiennent que du texte mais avec attributs

  • Exemple <ville codePostal="35000">Rennes</ville>

– Éléments qui contiennent d'autres éléments, à contenu mixte ou non

Élément <xs:complexeType>

  • Déclaration de type complexe

<xs:complexeType name="…" mixed="…">

<!-- un modèle de contenu -->

<!-- des déclarations d'attributs -->

</xs:complexeType>

  1. Déclaration d'attribut

<xs:attribute name="…" type="…" use="…">

– L'attribut type fait référence à un type simple

– L'attribut use prend une valeur parmi

  • required, optional, prohibited
  1. Modèle de contenu … à suivre …

Modèle de contenu

  • 4 sortes de modèles de contenu

– Contenu vide (par défaut)

– Contenu simple (seulement pour les contenus caractères)

  • Type simple comme les attributs

<xs:simpleContent>

</xs:simpleContent>

– Contenu composé d'éléments

  • Expression régulière

– Combinaison <xs:sequence>, <xs:choice>, <xs:all>

– Chacun contenant des références à élément de la forme

– <xs:element ref="…" minOccurs="…" maxOccurs="…"/>

– L'attribut ref fait référence à une définition d'élément

– Attribut mixed="true | false" contenu mixte ou non

Contenu vide avec attribut

  • Exemple

<prénom val="yves"/>

  • Définition

<xs:element name="prénom">

<xs:complexType>

<xs:attribute name="val"

type="xs:string"/>

</xs:complexType>

</xs:element>

Contenu simple textuel

  • Exemple

<prénom>Yves</prénom>

  • Définition 1

<xs:element name= "prénom" type="xs:string"/>

  • Définition 2

<xs:element name="prénom">

<xs:complexType mixed="true"/>

</xs:element>

  • Définition 3

<xs:element name="prénom">

<xs:complexType>

<xs:simpleContent>

<xs:extension base="xs:string"/>

</xs:simpleContent>

<xs:complexType>

</xs:element>

Contenu simple textuel avec attribut

  • Exemple

<ville code="35770">vern sur seiche</ville>

  • Définition

<xs:element name="ville">

<xs:complexType mixed="true">

<xs:attribute name="code"

type="xs:string" />

</xs:complexType>

</xs:element>

Autre moyen –l’extension d’un

<simpleContent>

  • Exemple

<ville code="35770">vern sur seiche</ville>

  • Définition

<xs:element name="ville">

<xs:complexType>

<xs:simpleContent>

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

<xs:attribute name="code" type="xs:string" />

</xs:extension>

</xs:simpleContent>

</xs:complexType>

</xs:element>

Contenu simple avec attribut et restriction du type de contenu (bis)

  • Exemple

<price currency="dollard">15.5</price>

  • Définition

<xs:element name="price">

<xs:complexType>

<xs:simpleContent>

<xs:extension base="xs:decimal">

<xs:attribute name="currency" type="xs:string" />

</xs:extension>

</xs:simpleContent>

</xs:complexType>

</xs:element>

Contenu complexe

Expressions régulières

  • Trois opérateurs de composition

– Élément <xs:sequence> séquence d'éléments

– Élément <xs:choice> choix d'éléments

– Élément <xs:all> permutation d'éléments

Séquence d'éléments

  • DTD

<!ELEMENT ROOT (A,B,C) >

<!ELEMENT A (#PCDATA)>

<!ELEMENT B (#PCDATA)>

<!ELEMENT C (#PCDATA)>

  • XMLSchema

<xs:element name="ROOT">

<xs:complexType mixed="false">

<xs:sequence>

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

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

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

</xs:sequence>

</xs:complexType>

</xs:element>

Choix entre éléments

  • DTD

<!ELEMENT ROOT (A|B|C) >

  • XMLSchema

<xs:element name="ROOT">

<xs:complexType mixed="false">

<xs:choice>

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

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

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

</xs:choice>

</xs:complexType>

</xs:element>

Élément à contenu mixte

  • DTD

<!ELEMENT ROOT (#PCDATA|A|B)*>

  • XMLSchema

<xs:element name="ROOT">

<xs:complexType mixed="true">

<xs:choice minOccurs="0" maxOccurs="unbounded">

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

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

</xs:choice>

</xs:complexType>

</xs:element>

Expression régulière (1)

  • DTD

<!ELEMENT ROOT (A|(B,C))>

  • XMLSchema

<xs:element name="ROOT">

<xs:complexType mixed="false">

<xs:choice>

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

<xs:sequence>

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

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

</xs:sequence>

</xs:choice>

</xs:complexType>

</xs:element>

Expression régulière (2)

  • DTD

<!ELEMENT ROOT (A?,B+,C*) >

  • XMLSchema

<xs:element name="ROOT">

<xs:complexType mixed="false">

<xs:sequence>

<xs:element name="A" minOccurs="0"/>

<xs:element name="B" maxOccurs="unbounded"/>

<xs:element name="C" minOccurs="0"

maxOccurs="unbounded"/>

Réutilisation d'un type

  • DTD

– On utilise les entités paramètres

Déclaration <!ENTITY % seqABC "A,B,C">

Utilisation <!ELEMENT root (&seqABC;)>

  • XMLSchema :

– Un type déclaré au niveau 1 de l'élément <xs:schema>

– Il est global, il porte un nom, il peut être réutilisé

<xs:complexType mixed="false" name="root">

<xs:sequence>

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

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

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

</xs:sequence>

</xs:complexType>

Modèle importé dans sa totalité

Types différents pour un même élément

Deux types différents pour le même nom d’élément - 1

<xs:element name="personne1">

<xs:complexType>

<xs:sequence>

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

</xs:sequence>

</xs:complexType>

</xs:element>

Deux types différents pour le même nom d’élément - 2

<xs:element name="personne2">

<xs:complexType>

<xs:sequence>

<xs:element name="nom">

<xs:complexType>

<xs:sequence>

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

<xs:element name="prénom" type="xs:string"/>

</xs:sequence>

</xs:complexType>

</xs:element>

</xs:sequence>

</xs:complexType>

</xs:element>

Deux types différents pour le même nom

d’élément - 3

<xs:element name="test">

<xs:complexType>

<xs:sequence>

<xs:element ref="personne1"/>

<xs:element ref="personne2"/>

</xs:sequence>

</xs:complexType>

</xs:element>

Contraintes pour les attributs

Attribut chaîne obligatoire

  • DTD

<!ELEMENT ROOT EMPTY>

<!ATTLIST ROOT a CDATA #REQUIRED>

  • XMLSchema

<xs:element name="ROOT">

<xs:complexType mixed="false">

<xs:attribute name="a" type="xs:string"

use="required"/>

</xs:complexType>

</xs:element>

obligatoire

Attribut chaîne optionnel

  • DTD

<!ELEMENT ROOT EMPTY>

<!ATTLIST ROOT a CDATA #IMPLIED>

  • XMLSchema

<xs:element name="ROOT">

<xs:complexType mixed="false">

<xs:attribute name="a" type="xs:string"

use="optional"/>

</xs:complexType>

</xs:element>

optionnel

Type énuméré pour un attribut

  • DTD

<!ELEMENT ROOT EMPTY>

<!ATTLIST ROOT a (x|y|z) #REQUIRED>

  • XMLSchema

<xs:element name="ROOT">

<xs:complexType mixed="false">

<xs:attribute name="a" use="required">

<xs:simpleType>

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

<xs:enumeration value="x"/>

<xs:enumeration value="y"/>

<xs:enumeration value="z"/>

</xs:restriction>

</xs:simpleType>

</xs:attribute>

</xs:complexType>

</xs:element>

Définition d'un type énuméré

Par restriction du type xs:string

Attribut à valeur fixe

  • DTD

<!ELEMENT ROOT EMPTY>

<!ATTLIST ROOT a CDATA #FIXED "x">

  • XMLSchema

<xs:element name="ROOT">

<xs:complexType mixed="false">

<xs:attribute name="a" type="xs:string"

fixed="x"/>

</xs:complexType>

</xs:element>

Valeur fixe

Schéma XML - Y. Bekkers 49

Types simples

  • Les types simples peuvent être

– Primitifs (ne dérivant pas d'un autre)

– Dérivés d'un autres type simple

  • Par une liste : séquence de types séparés par des blancs
  • Par une union : union d'autres types simples
  • Par une restriction :

– length, minLength, maxLength (longueur de listes)

– enumeration (liste de valeurs)

– pattern (expression régulière à la Perl)

– whitespace (préserver, remplacer, réduire les espaces)

– minInclusive,maxInclusive (intervales bornés de valeurs)

Types simples prédéfinis

  • Ils peuvent être primitifs ou dérivés
  • Il y en a une cinquantaine

Exemple : restriction

de la longueur d'une chaîne

<xs:simpleType name="chaine32">

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

<xs:maxLength value="32"/>

</xs:restriction>

</xs:simpleType>

Longueur minimum d’un identificateur

<xs:simpleType name="longName">

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

<xs:minLength value="6"/>

</xs:restriction>

</xs:simpleType>

Exemple : restriction du type date

<xs:element name="ROOT">

<xs:simpleType name="maDate">

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

<xs:pattern value="\d{4}-05-\d{2}"/>

</xs:restriction>

</xs:simpleType>

</xs:element>

Entier borné

<xs:element name="age">

<xs:simpleType>

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

<xs:minInclusive value="0"/>

<xs:maxInclusive value="120"/>

</xs:restriction>

</xs:simpleType>

</xs:element>

Type énuméré - 1

<xs:element name="car">

<xs:simpleType>

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

<xs:enumeration value="Audi"/>

<xs:enumeration value="Golf"/>

<xs:enumeration value="BMW"/>

</xs:restriction>

</xs:simpleType>

</xs:element>

Type énuméré - 2

<xs:element name="car" type="carType"/>

<xs:simpleType name="carType">

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

<xs:enumeration value="Audi"/>

<xs:enumeration value="Golf"/>

<xs:enumeration value="BMW"/>

</xs:restriction>

</xs:simpleType>

Restriction d’un type simple

  • Contenu

– xs:minExclusive, xs:minInclusive,

xs:maxExclusive, xs:maxInclusive,

xs:totalDigits, xs:fractionDigits, xs:length,

xs:maxLength, xs:minLength:

xs:enumeration: xs:whiteSpace, xs:pattern

– xs:attribute, xs:attributeGroup,

xs:anyAttribute (contenu simple d’un type complexe)

Union de types simples

<qtes>

<qte valeur="12"/>

<qte valeur="*"/>

</qtes>

Union de types simples (bis)

<xs:attribute name="valeur" use="required">

<xs:simpleType>

<xs:union memberTypes="xs:decimal star"/>

</xs:simpleType>

</xs:attribute>

<xs:simpleType name="star">

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

<xs:enumeration value="*"/>

</xs:restriction>

</xs:simpleType>

Restriction d’un type complexe

  • Permet de réduire le nombre d’instances valides (la description de contenu doit être valide pour le contenu de base, les attributs inchangés peuvent être omis)
  • Contenu

– xs:group, xs:all, xs:choice, xs:sequence

– xs:attribute, xs:attributeGroup, xs:anyAttribute

Réutilisation d


33