XML signifie eXtensible Markup Language. Comme son nom l’indique il s’agit d’un langage à balises mais il permet surtout de créer d’autres langages à balises. On peut le voir comme un ensemble de règles à respecter pour la création de langages à balises. XML est parfois qualifié de métalangage, c’est à dire de langage de langage. XML présente un certain nombre de caractéristiques qui en font tout son intérêt.
Il s’agit d’un standard ouvert ce qui le rend utilisable par tout à chacun.
Il utilise Unicode comme jeu de caractères standard ce qui le rend compatible avec un très grand nombre de systèmes d’écriture.
Il offre la possibilité de contrôler la conformité d’un document grâce à des modèles de documents et à des règles syntaxiques.
Un document XML est facile à lire pour une machine comme pour un humain.
Un document XML va regrouper un certain nombre d’informations en une seule entité. Il n’est pas forcement lié à une notion de fichier, il peut s’agir d’un flux émis sur un réseau entre deux machines.
En plus des règles imposées par XML, le modèle de document sert à décrire les différents éléments qui pourront être utilisés dans un document régit par ce modèle. Pour modéliser un document il existe plusieurs solutions, la DTD (Définition de Type de Document) et le Schéma XML (lui-même écrit en XML).
Tout logiciel qui traite le XML est qualifié de processeur XML. Les navigateurs Web, les éditeurs XML ou encore les validateurs sont quelques exemples de processeurs XML.
Le parseur XML est un processeur XML qui réalise l’analyse syntaxique. Il va décomposer les données selon des règles établies.
Cette partie indique les propriétés générales du document qui sont nécessaires à tous processeurs XML et notamment les parseurs. Les propriétés que peut fournir la déclaration XML sont les suivantes :
<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd"> <article> <title>XML</title> <section> <title>Document XML</title> <para>En voici un exemple.</para> </section> </article>
Version : indique la version de XML utilisée. Elle est obligatoire est doit toujours être précisée. La dernière version est la version 1.1 mais les changements sont mineurs et pour des raisons de compatibilités la version 1.0 reste la plus utilisée.
Encoding : définit le jeu de caractères utilisé dans la document. Dans le cas où le document est écrit en UTF-8 il n’est pas nécessaire de définir cette propriété.
Standalone : permet de savoir si le document fait appel à des entités externes. Deux valeurs sont donc possibles, "yes" s’il est indépendant, "no" s’il ne l’est pas. Ce paramètre est optionnel.
Elle indique le nom de l’élément racine du document ainsi que le la définition de type de document à utiliser. Elle peut aussi comporter la définition d’entités. Les informations fournies ici vont plutôt servir à la validation du document. La déclaration XML et la déclaration de type de document constituent le prologue du document.
La déclaration de l'exemple est la suivante :
<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd">
La syntaxe complète est la suivante :
<!DOCTYPE racine url dtd [ sous-ensemble interne ]>
Le sous-ensemble interne permet de définir des entités dans le document lui-même.
Il est délimité par l’élément racine et structuré à l’aide de sous-éléments.
<article> <title>XML</title> <section> <title>Document XML</title> <para>En voici un exemple.</para> </section> </article>
Pour définir les éléments il nous faut d’abord parler des balises. Les balises sont des valeurs textuelles encadrées par les signes "<" et ">".
Les éléments sont définis à l’aide de balises mais de façons différentes selon leur nature. Ils peuvent soit être des conteneurs de texte ou d’autres éléments soit être vides. La syntaxe d’un élément conteneur est la suivante :
<element-conteneur> contenu</element-conteneur>
Celle d’un élément vide est :
<element-vide />
Le nom d’un élément doit commencer par une lettre ou un "_" et peut ensuite utiliser les lettres, les chiffres et les caractères "-", "_" et ".".
Le nom des éléments est sensible à la casse aussi attention à l’utilisation des lettres majuscules et minuscules. La convention veut que les noms d’éléments soient en minuscules et éviter l’alternance de casse.
Dans le cas où les éléments contiennent des attributs, ils sont dans la première balise. Leur syntaxe est la suivante : nom = "valeur" ou nom=’valeur’.
Un élément peut avoir un nombre quelconque d’attributs mais tous les noms d’attributs doivent être uniques. Les attributs vont permettre d’apporter plus de précisions sur un élément.
Voici quelques exemples :
<elementA attribut1="valeur" attribut2="valeur"> ... </elementA> <elementB attribut3="valeur" />
Un attribut spécial "xml:lang" permet de spécifier la langue d’un document ou de l’un de ces éléments.
<element xml:lang="fr-FR"> ... </element>
Le langage XML utilise un certain nombre de caractères pour délimiter ces éléments et autres attributs. Ceux-ci doivent donc être échappés pour éviter toute confusion. Ces entités caractères prédéfinies par la spécification XML sont au nombre de cinq :
& => &
' => '
" => "
< => <
> => >
Il est possible d’utiliser des commentaires en XML en respectant la syntaxe suivante :
<!-- commentaire -->
Un commentaire peut contenir du texte et des éléments à l’exception d’autres commentaires. Les commentaires doivent être placés après la déclaration XML.
Ces sections permettent de saisir du texte librement sans qu’il soit parsé et même s’il contient des balises ou des entités. Leur syntaxe est :
<![CDATA[ zone textuelle avec <, > ou &. ]] >
XML permet de choisir le nom que l’on souhaite donner aux éléments, aux attributs, leur enchaînement et leur imbrication. Un certain nombre de règles doivent toutefois être respectées pour que le document soit conforme à la spécification XML :
une balise de fin doit suivre une balise de début,
les éléments ne peuvent se chevaucher,
la valeur des attributs doit être encadrée de caractères " ou de caractères ',
respecter les règles de nommage des éléments,
utiliser les entités prédéfinies,
le document dispose d’un seul élément racine.
Si un document respecte ces règles on le qualifie de "bien formé" et il s’agit d’une condition nécessaire pour qu’il soit pris en compte par un parseur XML.
Les éléments qui constituent un document et leur niveau d’imbrication peuvent être représentés sous forme d’un arbre.
Au sommet de l’arbre on trouve l’élément racine qui est toujours unique. Les éléments qui contiennent d’autres éléments sont appelés des noeuds et les éléments placés aux extrémités (qui ne contiennent pas d’autres éléments) sont qualifiés de feuilles.
Les éléments qui contiennent d’autres éléments sont les parents de ces éléments. Les éléments enfants peuvent avoir un seul et unique parent. Des éléments qui ont le même parent sont des éléments frères.
Enfin un élément qui n’a pas d’enfant est qualifié d’élément vide.
Un espace de nom va permettre de regrouper des éléments définis dans une définition de type de document et de leur associer un préfixe d’espace de noms. Ceci va permettre au sein d’un même document de faire référence à plusieurs types de document sans qu’il y ait d’ambiguïté. Ainsi même deux éléments de même nom mais qui appartiennent à des types de document différents, peuvent facilement être dissociés.
Dans l’exemple suivant nous voyons un exemple d’espace de nom qui correspond au langage XSL, au milieu d’éléments docBook. Ils sont facilement identifiables grâce au préfixe "xsl :".
<?xml version="1.0" encoding="utf-8" ?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:output method="xml" encoding="utf-8" /> <xsl:template match="/"> <balise>texte</balise> </xsl:template> </xsl:stylesheet>
La syntaxe pour les éléments ou les attributs d’un espace de nom est "prefixe:nom élément" ou "prefixe:nom attribut". On parle alors d’élément qualifié.
Un espace de nom pour que l’on puisse l’utiliser dans un document doit être référencé avant son utilisation. Sa déclaration se fait sous forme d’un attribut à l’interieur d’un élément et il sera connu de tous ses enfants. La déclaration se fait à l’aide du mot clé "xmlns" suivi de " :" et du préfixe que l’on souhaite lui donner. Enfin on fournit l’url vers la définition de document précédée du signe "=".
Par exemple voici celle utilisée pour une transformation XSL :
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
Il est possible d’omettre le préfixe et les ":" dans le cas de l’espace de nom par défaut comme dans l’exemple suivant :
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns="http://www.w3.org/TR/xhtml1/strict">
Nous avons vu que XML est un langage qui permet de créer d’autres langages à balises. Mais comme tout langage pour être compréhensible il faut connaître les "mots" qui le constituent.
Si l’on prend l’exemple d’un langage de programmation il nous faut pour l’utiliser connaître les instructions disponibles.
C’est la qu’interviennent les modèles de documents qu’ils soient écrits comme nous allons voir avec une DTD ou en XML schema.
Ces modèles vont nous fournir la grammaire du langage qu’ils définissent. La validation consiste à s’assurer qu’un document respecte les règles établies dans son modèle. Si c’est le cas on dit que le document est valide.
Le langage des DTD est présent depuis la première version de XML et de nouveaux langages comme le XML Schema viennent le compléter.
Il s’agit d’un langage à balises mais il ne respecte pas les spécifications de XML. Les balises ont une syntaxe particulière <!XXXXX> et tous les expressions de définition sont en majuscules.
Pour définir un élément il suffit de respecter la syntaxe suivante :
<!ELEMENT nom_element modele_contenu>
Dans la DTD xhtml 1.0 transitional on trouve entre autres :
<!ELEMENT title (#PCDATA)> <!ELEMENT meta EMPTY> <!ELEMENT hr EMPTY>
Il existe cinq types de modèles de contenu :
EMPTY, aucun contenu n’est disponible.
ANY, il n’y a aucune restriction de contenu.
(#PCDATA), l’élément ne peut contenir que du texte.
(element1, element2), l’élément peut contenir les autres éléments qui sont indiqués.
(#PCDATA, element), le contenu de l’élément est mixte. Il peut alors s’agir de données textuelles ou d’autres éléments.
Voici quelques exemples :
<!ELEMENT base EMPTY> <!ELEMENT style (#PCDATA)> <!ELEMENT html (head, body)>
Les éléments de syntaxe suivants permettent de définir des règles entre les éléments :
(xxxx | xxxx | xxxx), permet le choix de l’un de ces éléments.
( xxxx, xxxx, xxxx), séquence d’éléments (l’ordre de définition doit être respecté).
Par défaut les éléments sont présents dans la séquence une et une seule fois mais il est possible de modifier cela en ajoutant à la suite un des caractères suivants :
?, l’élément ou le groupe d’éléments placé avant est optionnel.
+, l’élément ou le groupe d’éléments placé avant doit être présent de 1 à n fois.
*, l’élément ou le groupe d’éléments doit être présent de 0 à n fois.
Quelques exemples :
<!ELEMENT table (caption?, (col*|colgroup*), thead?, tfoot?, (tbody+|tr+))> <!ELEMENT ul (li)+> <!ELEMENT dl (dt|dd)+>
Les attributs liés à un élément peuvent être définis de la façon suivante :
<!ATTLIST nom_element nom_attribut1 type_attribut1 valeur_par_defaut_attribut1 nom_attribut2 type_attribut2 valeur_par_defaut_attribut2 ... >
Parmi les différents types d’attributs on trouve principalement :
CDATA : contient des données textuelles (exception faite des entités caractères).
ID : identifiant unique qui donne à l’élément une étiquette unique.
IDREF : fait référence à un attribut ID d’un autre élément.
(xxxx | xxxx) : énumération des valeurs que peut prendre l’attribut.
NMTOKEN : chaîne de caractères qui commence par une lettre ou les caractères " :" ou "_" puis composée de " :" | [A-Z] | "_"| [a-z]| "-" | "." | [0-9].
Des types "liste" sont disponibles pour le IDREF et NMTOKEN il s’agit dans ce cas de plusieurs valeurs de ces types respectifs séparés par des espaces.
À titre d’exemple :
<!ATTLIST script id ID #IMPLIED charset %Charset; #IMPLIED type %ContentType; #REQUIRED src %URI; #IMPLIED defer (defer) #IMPLIED xml:space (preserve) #FIXED 'preserve' >
Une valeur par défaut peut-être fournie. Elle peut être complétée ou remplacée par un mot clé.
Trois mots clés permettent de définir le comportement des attributs :
#IMPLIED : indique que l’attribut est optionnel ;
#REQUIRED : l’attribut est obligatoire ;
#FIXED : la valeur est fixée et ne peut être modifiée. Ce mot clé est généralement utilisé avec une liste de valeurs.
Il est possible de définir des entités en plus des entités caractères déjà présentes. Les entités créées peuvent être de deux types.
Ces entités sont définies en utilisant la syntaxe suivante :
<! ENTITY nom_entite "valeur">
Elles pourront ensuite être appelées dans le document de la même façon que les entités caractères :
&nom_entite;
Ce type d’entités est uniquement destiné aux DTD et la déclaration se fait de façon différente :
<! ENTITY % nom_entite "valeur">
L’appel de ces entités va lui aussi différer :
%nom_entite;
Elles permettent dans les DTD complexes de mutualiser des déclarations qui pourraient être amener à changer et/ou à être appelées un grand nombre de fois. Toujours dans le même exemple voici la déclaration des évènements JavaScript :
<!ENTITY % events "onclick %Script; #IMPLIED ondblclick %Script; #IMPLIED onmousedown %Script; #IMPLIED onmouseup %Script; #IMPLIED onmouseover %Script; #IMPLIED onmousemove %Script; #IMPLIED onmouseout %Script; #IMPLIED onkeypress %Script; #IMPLIED onkeydown %Script; #IMPLIED onkeyup %Script; #IMPLIED" >
Un schéma XML est un document lui-même XML qui va permettre à l’aide d’éléments XML liés à l’espace de nom de XML Schema, de définir les règles que devra suivre le document pour être valide. La terminologie de XML Schema est proche de celle de l’objet, par exemple quand un document est conforme à un modèle de document, il est qualifié d’instance de ce schéma.
XML Schema permet de définir des éléments de type simple ou complexe. Les éléments de type simple ne contiennent ni attributs ni sous-éléments. Les éléments complexes peuvent être qualifiés à l’aide d’attributs et contenir des sous-éléments.
Contrairement aux DTD, les XML Schema Definition (XSD) permettent de typer le contenu des éléments. Pour cela XSD dispose d’un grand nombre de types simples natifs, dont voici les principaux :
Tableau 9. Types simples XML schema
| Type | Description |
|---|---|
| string | Chaîne de caractères |
| integer | Entier |
| float | Réel |
| date | Date au format ISO |
Il est possible de créer de nouveaux types simples à partir de ceux existants, on parle dans ce cas de dérivation.
La définition de types simples se fait à l’aide d’un élément simpleType et l’utilisation de constraining facets regroupées dans un élément restriction. En voici la liste :
length : taille d’une chaîne de caractères par exemple ;
minLength : taille minimum ;
maxLength : taille maximum ;
pattern : motif à respecter (expression régulière) ;
enumeration : valeur disponible ;
whiteSpace : gestion des caractères blancs (espace, tabulation et saut de ligne) ;
maxInclusive : maximum valeur incluse ;
maxExclusive : maximum valeur exclue ;
minExclusive : minimum valeur exclue ;
minInclusive : minimum valeur incluse ;
totalDigits : nombre de chiffres ;
fractionDigits : nombre de chiffre de la partie décimale.
Fonction du type dérivé toutes ne sont pas disponibles.
Voici un exemple de dérivation d’un type entier pour lequel on limite la valeur entre 0 et 100 :
<xsd:simpleType name='monEntier'> <xsd:restriction base='integer'> <xsd:minInclusive value='0' /> <xsd:maxInclusive value='100' /> </xsd:restriction> </xsd:simpleType>
Les types simples peuvent se décomposer en 3 sous types :
atomique : l’élément sera de ce type si rien n’est précisé.
Les listes : elles sont constituées d’éléments atomiques et sont définies à l’aide de l’élément "list" et de l’attribut "itemType" qui précise le type des valeurs présentes dans la liste. Les différentes valeurs sont délimitées par un espace blanc. Aussi faut-il être vigilant pour les listes à base de chaînes de caractères.
<xsd:simpleType name="maListe"> <xsd:list itemType="xsd:integer" /> </xsd:simpleType>
Un exemple de cet élément peut être le suivant :
<maListe>2005 9 15</maListe>
Le type union : il est composé d’une association entre plusieurs types atomiques et listes. On utilise pour le définir l’élément "union" associé à l’attribut "memberTypes" qui indique tous les types disponibles.
<xsd:simpleType name="monUnion"> <xsd:union memberType="listeCouleur xsd:integer" /> </xsd:simpleType>
Les éléments suivants sont valides :
<monUnion>rouge 23</monUnion> <monUnion>vert</monUnion>
Les types complexes sont une agrégation d’autres éléments (là encore on retrouve la terminologie objet) de type simple ou complexe et d’attributs.
La définition de types complexes se fait à l’aide d’un élément complexType. Cette définition contient des éléments déclarés à l’aide de l’élément element (de type simple ou complexe).
L’attribut name précise le nom que devra porter l’élément.
Le contenu d’un élément complexe peut-être :
un ensemble d’autres éléments (cf. ensemble d’éléments),
un contenu vide : il suffit de ne pas déclarer d’éléments dans complexType.
Un contenu libre : pour cela il suffit de déclarer l’élément avec le type xsd:anyType (Ce type est celui dont tous les autres héritent).
Voici quelques exemples :
<xsd:element name="maChaine" type="xsd:string" /> <xsd:element name="elementVide"> <xsd:complexeType> <xsd:attribute name="unAttribut" type="xsd:string" /> </xsd:complexeType> </xsd:element>
n.b : Il est possible de définir un élément directement dans un élément complexe qui le contient. Ce type d’élément n’aura pas d’existence propre en dehors de son élément parent. Ce type d’élément est qualifié d’élément anonyme.
Plusieurs éléments XSD sont liés au regroupement d’éléments :
sequence : les éléments doivent apparaître dans l’ordre défini,
choice : un seul des éléments définis doit être choisi,
all : tous les éléments doivent apparaître dans un ordre arbitraire,
group : permet de nommer un groupe d’éléments de façon à le rendre réutilisable. Il sera ensuite appelé de la façon suivante <xsd :group ref="nomDuGroupe" />
Il est possible d’apporter un certain nombre d’informations sur l’utilisation des éléments :
minOccurs : nombre minimum d’occurrences de l’élément (par défaut 1),
maxOccurs : nombre maximum d’occurrences de l’élément (par défaut 1),
default : valeur par défaut (s’applique si l’élément est vide),
fixed : impose la valeur de l’élément.
Pour l’attribut maxOccurs il est possible de lui attribuer la valeur unbounded pour ne pas fixer de limite.
Pour créer de nouveaux types il est possible de se baser sur des types existants. Deux méthodes de dérivation sont possibles et elles utilisent l’attribut base pour définir l’élément dérivé. Il n’y a pas de possibilité d’héritage multiple.
Dérivation par restriction : Ce mode de dérivation est le même que pour les types simples, il se fait également à l’aide de l’élément restriction.
Dérivation par extension : Ce mode dérivation va lui consister à ajouter des éléments et/ou des attributs à un élément. L’élément extension permet de définir ce type de dérivation. Voici un exemple :
<xsd:complexType name="derivation"> <xsd:complexeContent> <xsd:extension base="elementDerive"> <xsd:sequence> <xsd:element name="elementEnPlus" type="xsd:string" /> <xsd:element name="elementEnPlusEntier" type="xsd:integer" /> </xsd:sequence> <xsd:attribut name="attributEnPlus" type="xsd:string" /> </xsd:extension> </xsd:complexeContent> </xsd:complexType>
Pour associer un attribut à un élément il suffit d’utiliser l’élément attribute. L’attribut name précise le nom que devra porter l’attribut.
L’attribut peut-être défini en utilisant n’importe quel type simple.
<xsd:attribute name="orderDate" type="xsd:date" />
Les attributs disposent seulement de l’élément attributeGroupe qui permet de regrouper les attributs pour en faciliter la réutilisation.
Il est possible de fournir des informations supplémentaires sur l’attribut :
use : définit si l’attribut peut-être utilisé, s’il est obligatoire ou interdit. required, optional ou prohibited.
default : valeur par défaut si rien n’est précisé (utile uniquement si optionnel).
fixed : impose la valeur de l’attribut.
Pour lier un document à son schéma il faut tout d’abord déclarer dans l’élément racine du document l’espace de noms XMLSchema-instance puis utiliser l’attribut schemaLocation qu’il fournit.
<racine xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mon.url/monSchema.xsd">
Par convention l’espace de noms XMLSchema-instance utilise le préfixe xsi.
Pour accéder aux données il existe différentes API dont les plus répandues sont DOM et SAX. Elles sont disponibles dans la plus part des langages de programmation.
DOM est une API qui permet aux langages de programmation qui l’implémente d’accéder et de manipuler le contenu et la structure de documents XML. Cette interface fait l’objet de différentes recommandations du W3C dont la dernière en date est le DOM level 3.
Toutefois il existe un décalage entre les implémentations et ces recommandations. Par exemple, la librairie libxml2 implémente partiellement le DOM level 2 et Xerces de la fondation Apache le DOM level 2 et le level 3 partiellement.
Le parseur XML transforme le document en un arbre et chaque élément ou attribut est considéré comme un noeud. A chaque noeud correspond un objet DOM. L’arbre construit, les différentes opérations peuvent être réalisées puis l’arbre sera sérialisé de façon à reprendre la forme d’un document XML.
L'interface définit un certain nombre d’objets dont voici les principaux :
Document, pour le document XML,
DocumentType,
Node, pour les noeuds (tous les objets noeuds héritent de cette interface),
Element,
Attr, pour les attributs.
n.b : le document étant chargé dans son intégralité, cela peut demander des ressources importantes si le volume de données est important.
DOM n'est pas recommandé pour le traitement des fichiers XML très lourd (plusieurs centaines de mégaoctets). En effet, le fichier est chargé entièrement en mémoire alors cela peut nuire au système.
Contrairement à DOM, SAX n’est pas une recommandation du W3C mais elle est malgré tout très répandue.
L’API SAX est dite événementielle, c’est à dire que lors du parcours du document XML le programme va réagir aux informations renvoyées.
Par exemple, une action particulière va être effectuée à chaque fois qu’une balise est rencontrée. Les traitements avec SAX sont faits au fur et à mesure de la lecture du document. Le document n’est d’ailleurs pas conservé en mémoire ce qui limite SAX à un travail de lecture.
Pour manipuler un document il faudra utiliser l’interface DOM.
n.b : ces deux interfaces sont intimement liées puisque les implémentations DOM sont généralement réalisées à l’aide d’implémentations de SAX.