Académique Documents
Professionnel Documents
Culture Documents
www.openclassrooms.com
2/209
Sommaire
Sommaire ........................................................................................................................................... 2 Partager .............................................................................................................................................. 4 Structurez vos donnes avec XML ..................................................................................................... 6 Partie 1 : Les bases du XML ............................................................................................................... 8
Qu'est-ce que le XML ? ..................................................................................................................................................... 8
Qu'est ce que le XML ? ............................................................................................................................................................................................... Premire dfinition ...................................................................................................................................................................................................... Une nouvelle dfinition ................................................................................................................................................................................................ Origine et objectif du XML ........................................................................................................................................................................................... La petite histoire du XML ............................................................................................................................................................................................. Les objectifs du XML ................................................................................................................................................................................................... 8 8 8 9 9 9
www.openclassrooms.com
Sommaire
3/209
www.openclassrooms.com
Sommaire
4/209
Exemple .................................................................................................................................................................................................................... 88 La rutilisation des lements ..................................................................................................................................................................................... 89 Pourquoi ne pas tout crire d'un seul bloc ? ............................................................................................................................................................. 89 Diviser un Schma XML ............................................................................................................................................................................................ 90 Crer ses propres types ............................................................................................................................................................................................ 93 L'hritage ................................................................................................................................................................................................................... 95 L'hritage par restriction ............................................................................................................................................................................................ 95 L'hritage par extension .......................................................................................................................................................................................... 103 Les identifiants ........................................................................................................................................................................................................ 105 La syntaxe ............................................................................................................................................................................................................... 105 Exemple .................................................................................................................................................................................................................. 106 Un exemple avec EditiX .......................................................................................................................................................................................... 107 Cration du document XML ..................................................................................................................................................................................... 107 Cration du document XSD .................................................................................................................................................................................... 108 Vrification du Schma XML ................................................................................................................................................................................... 109 Vrification du document XML ................................................................................................................................................................................. 110
www.openclassrooms.com
Partager
5/209
L'extension du fichier ............................................................................................................................................................................................... 156 Le prologue ............................................................................................................................................................................................................. 156 Le corps ................................................................................................................................................................................................................... 156 La balise output ....................................................................................................................................................................................................... 156 Pour rsumer ........................................................................................................................................................................................................... 158 Rfrencer un document XSLT ............................................................................................................................................................................... 158 O et comment rfrencer un document XSLT ? .................................................................................................................................................... 158 Pour rsumer ........................................................................................................................................................................................................... 159
www.openclassrooms.com
Partager
6/209
Par
Mise jour : 15/01/2014 Difficult : Facile 16 visites depuis 7 jours, class 5/807
Vous souhaitez structurer les donnes manipules ou changes par vos programmes ou vos applications mobiles ?
Ne cherchez plus ! XML va vous faciliter la vie ! XML est un langage de balisage gnrique qui permet de structurer des donnes afin qu'elles soient lisibles aussi bien par les humains que par des programmes de toute sorte. Il est souvent utilis pour faire des changes de donnes entre un programme et un serveur ou entre plusieurs programmes. Pour vous donner une illustration concrte, prenons un exemple d'actualit : celui d'une application tlphonique qui met jour ses donnes. L'application demande un serveur web les dernires informations dont il dispose. Aprs tre all les chercher, ce dernier doit les communiquer. C'est l qu'intervient le XML. Le serveur web se sert du XML pour structurer les informations qu'il doit renvoyer l'application tlphonique. Lorsque cette dernire reoit les informations ainsi structures, elle sait comment les lire et les exploiter rapidement ! Dans ce cours destin aux dbutants , nous dcouvrirons ensemble comment crire des documents XML. Cette partie ne nous prendra pas normment de temps, nous en profiterons donc pour dcouvrir ensemble tout ce qui tourne autour de l'univers du XML. Ainsi, nous verrons galement comment : Imposer une structure bien prcise nos documents XML. Les mettre en forme. Lire facilement les donnes contenues dans un document XML. Transformer les documents XML vers d'autres formats comme une page Internet.
Aperu de fichiers que nous aurons l'occasion d'crire dans ce tutoriel V ous l'aurez compris, le programme s'annonce charg ! C'est pourquoi je vous propose de commencer tout de suite.
Ce tutoriel a t conu pour tre lu comme un roman, en suivant l'ordre des chapitres. A moins d'avoir dj de l'exprience dans les technologies abordes dans ce tutoriel, je vous dconseille de sauter des chapitres.
N.B. : Un grand merci Fumble pour ses relectures, ses conseils et ses encouragements tout au long de la rdaction de ce cours. Je souhaite galement remercier AnnaStretter pour ses conseils afin de rendre ce cours plus pdagogique.
www.openclassrooms.com
7/209
www.openclassrooms.com
8/209
Cette dfinition est mes yeux quelque peu barbare et technique, c'est pourquoi, je vous propose d'en dcortiquer les motsclefs.
Un langage informatique
V ous n'tes pas sans savoir qu'en informatique, il existe plusieurs centaines de langages destins des utilisations trs diverses. En vulgarisant un peu (beaucoup !), il est possible de les regrouper en 3 grandes catgories : Les langages de programmation. Les langages de requte. Les langages de description. Les langages de programmation permettent de crer des programmes, des applications mobiles, des sites Internet, des systmes d'exploitation, etc. Certains langages de programmation sont extrmement populaires. En mai 2012, les 10 langages de programmation les plus populaires taient le C, le Java, le C++, l'Objective-C, le C#, le PHP, le Basic, le Python, le Perl et le Javascript. Les langages de requtes permettent quant eux d'interroger des structures qui contiennent des donnes. Parmi les langages de requte les plus connus, on peut par exemple citer le SQL pour les bases de donnes relationnelles, le SPARQL pour les graphes RDF et les ontologies OWL ou encore le XQuery pour les documents XML. Enfin, les langages de description permettent de dcrire et structurer un ensemble de donnes selon un jeu de rgles et des contraintes dfinies. On peut par exemple utiliser ce type de langage pour dcrire l'ensemble des livres d'une bibliothque, ou encore la liste des chansons d'un CD, etc. Parmi les langages de description les plus connus, on peut citer le SGML, le XML ou encore le HTML.
Le terme gnrique signifie que nous allons pouvoir crer nos propres balises. Nous ne sommes pas obligs d'utiliser un ensemble de balises existantes comme c'est par exemple le cas en HTML.
9/209
Aprs les explications que nous venons de voir ensemble, je vous propose une nouvelle dfinition du langage XML bien moins technique que la premire donne au dbut de ce cours. V oici donc cette nouvelle dfinition : le langage XML est un langage qui permet de dcrire des donnes l'aide de balises et de rgles que l'on peut personnaliser. Certaines notions peuvent encore vous sembler abstraites, mais ne vous inquitez pas, tout sera expliqu dans la suite de ce tutoriel.
www.openclassrooms.com
10/209
L'diteur de texte
Il faut savoir qu'un document XML n'est en ralit qu'un simple document texte. C'est pourquoi, il est tout fait possible d'utiliser un diteur de texte pour la rdaction de nos documents XML.
Sous Windows
Sous Windows, un diteur de texte portant le nom de Bloc-notes est gnralement install par dfaut. En thorie, il est suffisant et fonctionnel. Dans la pratique, les fonctionnalits qu'il offre sont limites et des options trs utiles comme la coloration syntaxique ou la numrotation des lignes manquent. Je vous propose donc d'utiliser Notepad++ qui est parfait pour ce que nous souhaitons raliser puisqu'il pallie idalement les manques du Bloc-notes. Il s'agit d'un logiciel gratuit, n'hsitez donc pas le tlcharger !
Tlcharger Notepad++
Je ne vais pas dtailler ici la procdure d'installation qui est classique pour un logiciel tournant sous Windows. Une fois install, lancez le logiciel. V ous devriez avoir une fentre semblable la figure suivante.
www.openclassrooms.com
11/209
Notepad++ Afin d'adapter la coloration syntaxique au langage XML, il vous suffit de slectionner Langage dans la barre de menu puis XML dans la liste. Lorsque vous enregistrerez vos documents, il suffira alors de prciser comme extension " .xml" pour conserver la coloration syntaxique d'une fois sur l'autre.
Sous GNU/Linux
Par dfaut, les distributions Linux sont souvent livres avec de trs bons diteurs de texte. Si vous aimez la console, vous pouvez par exemple utiliser nano, emacs , vi ou encore vim. Si vous prfrez les interfaces graphiques, je vous conseille d'utiliser l'excellent gedit qui normalement doit tre install par dfaut. Si jamais ce n'est pas le cas, la commande suivante vous permettra de l'installer en quelques instants : Code : Console sudo apt-get install gedit
Une fois ouvert, vous devriez voir apparaitre quelque chose comme a :
www.openclassrooms.com
12/209
gedit - photo issue du site officiel du projet Afin d'adapter la coloration syntaxique au langage XML, il vous suffit de slectionner Affichage dans la barre de menu puis Mode de coloration et finalement de choisir le XML dans la liste. Lorsque vous enregistrerez vos documents, il suffira alors de prciser comme extension " .xml" pour conserver la coloration syntaxique une fois sur l'autre.
Sous MAC OS X
Pour les utilisateurs du systme d'exploitation d'Apple, je vous conseille de vous tourner vers jEdit. V ous pouvez le tlcharger ici. La figure suivante vous donne un aperu de son interface :
www.openclassrooms.com
13/209
EditiX
Editix est un diteur XML qui fonctionne sur les plateformes Windows, GNU/Linux ou Mac OS X. En plus de la coloration syntaxique essentielle l'criture de documents XML, ce logiciel nous offre de nombreux outils qui nous seront utiles dans la suite de ce tutoriel comme par exemple la validation des documents .
La version payante
Il existe plusieurs versions de ce logiciel. La dernire en date est EditiX 2013 . Cette version complte est payante, mais plusieurs licences sont disponibles. Les tudiants peuvent par exemple bnficier de 50% de rduction.
www.openclassrooms.com
14/209
Dplacez vous maintenant dans le dossier /opt/ par la commande : Code : Console cd /opt/
Nous allons maintenant extraire les fichiers de larchive que nous avons tlcharge. Pour ce faire, vous pouvez utiliser la commande : Code : Console sudo tar xvzf editix-free-2008.tar.gz
Un dossier nomm editix doit alors apparatre. Il contient les fichiers que nous venons dextraire. V ous pouvez alors supprimer larchive via la commande : Code : Console sudo rm editix-free-2008.tar.gz
On pourrait choisir de s'arrter l et lancer le logiciel en ligne de commande en se rendant dans le rpertoire /opt/editix/bin/ et en excutant le script run.sh via la commande : Code : Console ./run.sh
Cration du launcher
Pour ce faire, faites un clic droit sur le menu Applications de votre tableau de bord (ou sur le Menu si vous tes sur une LMDE par exemple) et cliquez sur Editer le menu . Dans la colonne de gauche, choisissez le menu Programmation puis cliquez sur le bouton Nouvel lment dans la colonne de droite.
www.openclassrooms.com
15/209
Crtation du launcher Remplissez le formulaire avec les informations suivantes : Type : Application Nom : Editix Commande : /opt/editix/bin/run.sh Finalisez la cration du launcher en cliquant sur le bouton Valider. Editix devrait maintenant apparatre dans vos applications et, plus particulirement, dans le menu programmation. Quel que soit votre systme d'exploitation, voici quoi doit ressembler la fentre du logiciel aprs son lancement :
16/209
Concluons cette prsentation avec le logiciel <oXygen/> XML Editor qui, comme Editix, est multiplateformes. Contrairement EditiX, il n'existe pas de version gratuite du logiciel, mais il reste possible de le tester gratuitement pendant 30 jours. Comme pour Editix , <oXygen/> XML Editor propose plusieurs types de licences. Ainsi, les tudiants peuvent obtenir des rductions trs intressantes.
<oXygen/> - photo issue du site officiel du projet Mme si ce n'est pas obligatoire, un logiciel spcialis est conseill. L'utilisation de EditiX sera aborde rgulirement dans ce tutoriel.
www.openclassrooms.com
17/209
Les balises
Dans le tout premier chapitre, je dfinissais le langage XML comme un langage informatique de balisage. En effet, les balises sont les lments de base d'un document XML. Une balise porte un nom qui est entour de chevrons . Une balise commence donc par un < et se termine par un >. Par exemple : <balise> dfinit une balise qui s'appelle " balise". En XML, on distingue 2 types de balises : les balises par paires et les balises uniques .
Il est extrmement important que les balises ouvrantes et fermantes aient exactement le mme nom. XML est sensible la casse (c'est--dire qu'il fait la distinction entre les majuscules et les minuscules) ! Toute balise ouverte doit imprativement tre ferme. C'est une rgle d'or !
Bien videmment, on peut mettre "des choses" entre ces balises. On parle alors de contenu. Par exemple : Code : XML <balise>Je suis le contenu de la balise</balise>
Quelques rgles
Une balise par paires ne peut pas contenir n'importe quoi : elle peut contenir une valeur simple comme par exemple une chane de caractres, un nombre entier, un nombre dcimal, etc. Code : XML <balise1>Ceci est une chane de caractres</balise1> <balise2>10</balise2> <balise3>7.5</balise3>
Une balise par paires peut galement contenir une autre balise. On parle alors d'arborescence.
www.openclassrooms.com
18/209
Faites cependant trs attention, si une balise peut en contenir une autre, il est cependant interdit de les chevaucher. L'exemple suivant n'est pas du XML !
Enfin, une balise par paires peut contenir un mlange de valeurs simples et de balises comme en tmoigne l'exemple suivant : Code : XML <balise1> Ceci est une chane de caractres <balise2>10</balise2> 7.5 </balise1>
www.openclassrooms.com
19/209
Dans l'exemple ci-dessus, l'information principale est le prix. L'attribut devise nous permet d'apporter des informations supplmentaires sur ce prix, mais ce n'est pas l'information principale que souhaite transmettre la balise <prix/>. Une balise peut contenir 0 ou plusieurs attributs. Par exemple : Code : XML <prix devise="euro" moyen_paiement="chque">25.3</prix>
Quelques rgles
Tout comme pour les balises, quelques rgles sont respecter pour les attributs : Les rgles de nommage sont les mmes que pour les balises. La valeur d'un attribut doit imprativement tre dlimite par des guillemets, simples ou doubles. Dans une balise, un attribut ne peut-tre prsent qu'une seule fois.
Les commentaires
Avant de passer la cration de notre premier document XML, j'aimerais vous parler des commentaires . Un commentaire est un texte qui permet de donner une indication sur ce que l'on fait. Il vous permet d'annoter votre fichier et d'expliquer une partie de celui-ci. En XML, les commentaires ont une syntaxe particulire. C'est une balise unique qui commence par <!-- et qui se termine par -->. Code : XML <!-- Ceci est un commentaire ! -->
V oyons tout de suite sur un exemple concret : Code : XML <!-- Description du prix --> <prix devise="euro">12.5</prix>
Certes, sur cet exemple, les commentaires semblent un peu inutiles, mais je vous assure qu'ils vous seront d'une grande aide pendant la rdaction de longs documents XML !
www.openclassrooms.com
20/209
www.openclassrooms.com
21/209
Le prologue
Le prologue correspond la premire ligne de votre document XML. Il donne des informations de traitement. V oici quoi notre prologue ressemble dans cette premire partie du tutoriel : Code : XML <?xml version = "1.0" encoding="UTF-8" standalone="yes" ?>
Comme vous pouvez le remarquer, le prologue est une balise unique qui commence par <?xml et qui se termine par ?>. Si vous ne comprenez pas cette ligne, pas de panique, nous allons tout dcortiquer ensemble pas pas.
La version
Dans le prologue, on commence gnralement par indiquer la version de XML que l'on utilise pour dcrire nos donnes. Pour rappel, il existe actuellement 2 versions : 1.0 et 1.1. noter : le prologue n'est obligatoire que depuis la version 1.1, mais il est plus que conseill de l'ajouter quand mme lorsque vous utilisez la version 1.0. La diffrence entre les 2 versions est une amlioration dans le support des diffrentes versions de l'Unicode. Sauf si vous souhaitez utiliser des caractres chinois dans vos documents XML, il conviendra d'utiliser la version 1.0 qui est encore aujourd'hui la version la plus utilise.
Le jeu de caractres
La seconde information de mon prologue est encoding="UTF-8". Il s'agit du jeu de caractres utilis dans mon document XML. Par dfaut, l'encodage de XML est l'UTF-8, mais si votre diteur de texte enregistre vos documents en ISO8859-1, il suffit de la changer dans le prologue : Code : XML <?xml version = "1.0" encoding="ISO8859-1" standalone="yes" ?>
Un document autonome
La dernire information prsente dans le prologue est standalone="yes". Cette information permet de savoir si votre document XML est autonome ou si un autre document lui est rattach. Il est encore un peu tt pour vous en dire plus. Nous reviendrons sur cette notion dans la partie 2 du tutoriel. Pour le moment,
www.openclassrooms.com
22/209
Le corps
Le corps d'un document XML est constitu de l'ensemble des balises qui dcrivent les donnes. Il y a cependant une rgle trs importante respecter dans la constitution du corps : une balise en paires unique doit contenir toutes les autres. Cette balise est appele lment racine du corps. V oyons tout de suite un exemple : Code : XML <racine> <balise_paire>texte</balise_paire> <balise_paire2>texte</balise_paire2> <balise_paire>texte</balise_paire> </racine>
Bien videmment, lorsque vous crez vos documents XML, le but est d'tre le plus explicite possible dans le nommage de vos balises. Ainsi, le plus souvent, la balise racine aura pour mission de dcrire ce quelle contient. Si je choisis de dcrire un rpertoire, je peux par exemple nommer mes balises comme dans l'exemple suivant : Code : XML <repertoire> <personne>Bernard</personne> <personne>Patrick</personne> </repertoire>
Un document complet
Un document XML, certes simple, mais complet pourrait donc tre le suivant : Code : XML <?xml version = "1.0" encoding="UTF-8" standalone="yes" ?> <repertoire> <personne>Bernard</personne> <personne>Patrick</personne> </repertoire>
www.openclassrooms.com
23/209
Si votre document XML est bien form, flicitation, il est exploitable ! Dans le cas contraire, votre document est inutilisable.
Utilisation d'EditiX
Tout cela est bien beau, me direz-vous, mais depuis le dbut de ce tutoriel, nous parlons du XML sans avoir encore utilis les logiciels du chapitre 2. Nous allons les employer ds maintenant. Dans cette partie, nous allons crer notre premier document XML grce au logiciel EditiX et vrifier qu'il est bien form. Je vous propose d'utiliser le document complet que nous avons construit auparavant : Code : XML <?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <repertoire> <personne>Robert</personne> <personne>John</personne> </repertoire>
Cration d'un document XML Surprise ! V otre document XML n'est pas vierge. V oici ce que vous devriez voir : Code : XML <?xml version="1.0" encoding="UTF-8"?> <!-- New document created with EditiX at Fri May 18 00:11:02 CEST 2012 -->
www.openclassrooms.com
24/209
Comme vous pouvez le constater, EditiX s'est charg pour vous d'crire le prologue de votre document XML. Il a galement pris en charge la rdaction d'un petit commentaire pour vous rappeler la date et l'heure de cration de votre document. Puisque notre document sera autonome, vous pouvez modifier le prologue pour l'indiquer : Code : XML <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
Vrification du document
Nous pouvons vrifier ds maintenant si notre document est bien form. Pour ce faire, vous pouvez cliquer sur l'icne suivante : et slectionner dans la barre de menu XML puis Check this document ou encore utiliser le raccourci clavier Ctrl + K. V ous devriez alors voir une erreur s'afficher. La ligne o se situe l'erreur est reprsente par un rectangle aux bords rouges sur notre espace de travail, comme indiqu sur la figure suivante :
Le document XML contient une erreur Nous avons donc une erreur la ligne 6 de notre document. Pour en savoir plus sur notre erreur, il suffit de regarder en bas de l'cran, voici sur la figure suivante ce que vous devriez voir :
Message d'erreur indiquant que le document n'est pas bien form Pour ceux qui ne parlent pas anglais, voici ce que dit le message : Un document bien form ncessite un lment racine. Il manque donc un lment racine. Compltons tout de suite notre document avec les lments suivant : Code : XML <repertoire> <personne>Robert</personne> <personne>John</personne> </repertoire>
Lancez de nouveau la vrification du document. V ous devriez avoir le message suivant l'cran :
www.openclassrooms.com
25/209
Message indiquant un document XML bien form Flicitation, votre document est bien form !
L'indentation
Il est possible de demander Editix d'indenter automatiquement vos documents une fois crits. Pour ce faire, slectionnez dans la barre de menu XML puis Format et Pretty format (default) ou utilisez le raccourci clavier Ctrl + R. Dans ce mme menu, vous pouvez accder aux paramtres concernant la tabulation.
L'arborescence du document
Editix met votre disposition un outil fort sympathique qui vous permet de visualiser l'arborescence du document en cours d'dition :
Arborescence du document XML On sait ainsi que notre rpertoire contient 2 personnes : Robert et John.
Dans la fentre de dialogue qui vient de s'ouvrir, choisissez l'emplacement dans lequel vous souhaitez stocker votre fichier XML, tapez son nom et cliquez sur Enregistrer. Un document XML est compos de 2 parties : le prologue et le corps . un document XML doit tre bien form pour tre exploitable. EditiX permet de vrifier qu'un document est bien form en seulement quelques clics.
www.openclassrooms.com
26/209
L'nonc
Le but de ce TP est de crer un document XML structurant les donnes d'un rpertoire. V otre rpertoire doit comprendre au moins 2 personnes. Pour chaque personne, on souhaite connatre les informations suivantes : Son sexe (homme ou femme). Son nom. Son prnom. Son adresse. Un ou plusieurs numros de tlphone (tlphone portable, fixe, bureau, etc.). Une ou plusieurs adresses e-mail (adresse personnelle, professionnelle, etc.). Je ne vous donne aucune indication concernant le choix des balises, des attributs et de l'arborescence choisir pour une raison trs simple : lorsque l'on dbute en XML, le choix des attributs, des balises et de l'arborescence est assez difficile. L'objectif est vraiment de vous laisser chercher et vous pousser vous poser les bonnes questions sur l'utilit d'une balise, d'un attribut, etc.
Exemple de solution
Je vous fais part de ma solution. Notez bien que ce n'est qu'une solution parmi les multiples solutions possibles ! Code : XML <?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <repertoire> <!-- John DOE --> <personne sexe="masculin"> <nom>DOE</nom> <prenom>John</prenom> <adresse> <numero>7</numero> <voie type="impasse">impasse du chemin</voie> <codePostal>75015</codePostal> <ville>PARIS</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="fixe">01 02 03 04 05</telephone> <telephone type="portable">06 07 08 09 10</telephone> </telephones> <emails> <email type="personnel">john.doe@wanadoo.fr</email> <email type="professionnel">john.doe@societe.com</email> </emails> </personne> <!-- Marie POPPINS --> <personne sexe="feminin"> <nom>POPPINS</nom> <prenom>Marie</prenom> <adresse> <numero>28</numero> <voie type="avenue">avenue de la rpublique</voie> <codePostal>13005</codePostal> <ville>MARSEILLE</ville> <pays>FRANCE</pays>
www.openclassrooms.com
27/209
Quelques explications
Le sexe
Comme vous pouvez le constater, j'ai fait le choix de renseigner le sexe dans un attribut de la balise <personne/> et non d'en faire une balise part entire. En effet, cette information est, je pense, plus utile l'ordinateur qui lira le document qu' toute personne qui prendrait connaissance de ce fichier. En effet, contrairement une machine, nous avons la capacit de dduire que John est un prnom masculin et Marie, un prnom fminin. Cette information n'est donc pas cruciale pour les personnes qui lisent le fichier.
L'adresse
Il est important que vos documents XML aient une arborescence logique. C'est pourquoi j'ai dcid de reprsenter l'adresse postale par une balise <adresse /> qui contient les informations dtailles de l'adresse de la personne comme le numro de l'immeuble, la voie, le pays, etc. J'ai galement fait le choix d'ajouter un attribut type dans la balise <voie />. Une nouvelle fois, cet attribut est destin tre utilis par une machine. En effet, une machine qui traitera ce fichier, pourra facilement accder au type de la voie sans avoir rcuprer le contenu de la balise <voie/> et tenter d'analyser s'il s'agit d'une impasse, d'une rue, d'une avenue, etc. C'est donc un gain de temps dans le traitement des donnes.
www.openclassrooms.com
28/209
Quelques dfinitions
Dfinition d'une dfinition
Une dfinition d'un document XML est un ensemble de rgles que l'on impose au document. Ces rgles permettent de dcrire la faon dont le document XML doit tre construit. Elles peuvent tre de natures diffrentes. Par exemple, ces rgles peuvent imposer la prsence d'un attribut ou d'une balise, imposer l'ordre d'apparition des balises dans le document ou encore, imposer le type d'une donne (nombre entier, chane de caractres, etc.).
Un document valide
Dans la partie prcdente, nous avons vu ce qu'tait un document bien form. Cette seconde partie est l'occasion d'aller un peu plus loin et de voir le concept de document valide. Un document valide est un document bien form conforme une dfinition. Cela signifie que le document XML respecte toutes les rgles qui lui sont imposes dans les fameuses dfinitions.
Le plus souvent, par un programme informatique ! V ous pouvez par exemple crire un programme informatique qui traite les donnes contenues dans un document XML respectant une dfinition donne. Imposer une dfinition aux documents que votre programme exploite permet d'assurer un automatisme et un gain de temps prcieux : Le document n'est pas valide : je ne tente pas de l'exploiter. Le document est valide : je sais comment l'exploiter. Pour terminer cette longue introduction, sachez que vous avez le choix entre deux technologies pour crire les dfinitions de vos documents XML : les DTD ou les schmas XML.
29/209
Comme nous l'avons dj prcis dans l'introduction de cette seconde partie, le but est d'crire une dfinition de nos documents XML, c'est--dire, de construire un ensemble de rgles qui vont rgir la construction du document XML. Grce l'ensemble de ces rgles, nous allons ainsi dfinir l'architecture de notre document XML et la hirarchie qui existe entre les balises de celui-ci. Ainsi, on pourra prciser lenchanement et le contenu des balises et des attributs contenus dans le document XML. Finalement, sachez qu'avec les DTD, vous ne pourrez pas toujours tout faire, la technologie commenant en effet vieillir. Mais comme elle est encore beaucoup utilise, il est indispensable qu'elle soit tudie dans ce tutoriel.
Une rgle peut donc se dcouper en 3 mots clefs : ELEMENT, balise et contenu.
30/209
Cette rgle signifie que la balise <personne /> contient la balise <nom />. Le document XML respectant cette rgle ressemble donc cela : Code : XML <personne> <nom>John DOE</nom> </personne>
Nous n'avons dfini aucune rgle pour la balise <nom/>. Le document n'est, par consquent, pas valide. En effet, dans une DTD, il est impratif de dcrire tout le document sans exception. Des balises qui n'apparaissent pas dans la DTD ne peuvent pas tre utilises dans le document XML.
nous avions dj dfini une rgle pour la balise <personne/> : Code : XML <!ELEMENT personne (nom)>
Nous pouvons maintenant complter notre DTD en ajoutant une rgle pour la balise <nom/>. Par exemple, si l'on souhaite que cette balise contienne une valeur simple, on crira : Code : XML
www.openclassrooms.com
31/209
Au final, la DTD de notre document XML est donc la suivante : Code : XML <!ELEMENT personne (nom)> <!ELEMENT nom (#PCDATA)>
Le document XML rpondant la dfinition DTD prcdente est le suivant : Code : XML <personne> <nom /> </personne>
noter : lors de l'utilisation du mot clef EMPTY, l'usage des parenthses n'est pas obligatoire !
Les documents XML suivants sont bien valides : Code : XML <!-- valeur simple --> <personne> <nom>John DOE</nom> </personne>
www.openclassrooms.com
32/209
Bien que le mot-clef ANY existe, il est souvent dconseill de l'utiliser afin de restreindre le plus possible la libert de rdaction du document XML.
Comme pour le mot-clef EMPTY, l'usage des parenthses n'est pas obligatoire pour le mot-clef ANY!
La squence
Une squence permet de dcrire lenchanement impos des balises. Il suffit d'indiquer le nom des balises en les sparant par des virgules. Code : XML <!ELEMENT balise (balise2, balise3, balise4, balise5, etc.)>
Prenons l'exemple suivant : Code : XML <!ELEMENT <!ELEMENT <!ELEMENT <!ELEMENT personne (nom, prenom, age)> nom (#PCDATA)> prenom (#PCDATA)> age (#PCDATA)>
Cette dfinition impose que la balise <personne /> contienne obligatoirement les balises <nom />, <prenom /> et <age /> dans cet ordre. Regardons alors la validit des documents XML qui suivent : Code : XML <!-- valide --> <personne> <nom>DOE</nom> <prenom>John</prenom> <age>24</age> </personne> <!-- invalide --> <!-- les balises ne sont pas dans le bon ordre --> <personne> <prenom>John</prenom> <nom>DOE</nom> <age>24</age> </personne>
www.openclassrooms.com
33/209
La liste de choix
Une liste de choix permet de dire qu'une balise contient l'une des balises dcrites. Il suffit d'indiquer le nom des balises en les sparant par une barre verticale. Code : XML <!ELEMENT balise (balise2 | balise3 | balise4 | balise5 | etc.)>
Prenons l'exemple suivant : Code : XML <!ELEMENT personne (nom | prenom)> <!ELEMENT nom (#PCDATA)> <!ELEMENT prenom (#PCDATA)>
Cette dfinition impose que la balise <personne /> contienne obligatoirement la balise <nom /> ou la balise <prenom />. Regardons alors la validit des documents XML ci-dessous : Code : XML <!-- valide --> <personne> <nom>DOE</nom> </personne> <!-- valide --> <personne> <prenom>John</prenom> </personne> <!-- invalide --> <!-- les 2 balises prenom et nom ne peuvent pas tre prsentes en mme temps. --> <personne> <prenom>John</prenom> <nom>DOE</nom> </personne>
www.openclassrooms.com
34/209
La balise optionnelle
Une balise peut tre optionnelle. Pour indiquer qu'une balise est optionnelle, on fait suivre son nom par un point dinterrogation. Code : XML <!ELEMENT balise (balise2, balise3?, balise4)>
Prenons l'exemple suivant : Code : XML <!ELEMENT personne (nom, prenom?)> <!ELEMENT nom (#PCDATA)> <!ELEMENT prenom (#PCDATA)>
Cette dfinition impose que la balise <personne /> contienne obligatoirement la balise <nom /> puis ventuellement <prenom />. Regardons alors la validit de ces documents XML : Code : XML <!-- valide --> <personne> <nom>DOE</nom> </personne> <!-- valide --> <personne> <nom>DOE</nom> <prenom>John</prenom> </personne> <!-- invalide --> <!-- l'ordre des balises n'est pas respect --> <personne> <prenom>John</prenom> <nom>DOE</nom> </personne>
www.openclassrooms.com
35/209
Soit l'ensemble de rgles suivant : Code : XML <!ELEMENT <!ELEMENT <!ELEMENT <!ELEMENT repertoire (personne*)> personne (nom, prenom)> nom (#PCDATA)> prenom (#PCDATA)>
Cette dfinition impose que la balise <repertoire /> contienne entre 0 et une infinit de fois la balise <personne />. La balise <personne />, quant elle, doit obligatoirement contenir les balises <nom /> et <prenom /> dans cet ordre. Regardons alors la validit des documents XML : Code : XML <!-- valide --> <repertoire> <personne> <nom>DOE</nom> <prenom>John</prenom> </personne> <personne> <nom>POPPINS</nom> <prenom>Marie</prenom> </personne> </repertoire> <!-- valide --> <repertoire> <personne> <nom>DOE</nom> <prenom>John</prenom> </personne> </repertoire> <!-- valide --> <repertoire /> <!-- invalide --> <!-- il manque la balise prenom dans la seconde balise personne--> <repertoire> <personne> <nom>DOE</nom> <prenom>John</prenom> </personne> <personne> <nom>POPPINS</nom> </personne> </repertoire>
La balise rpte
Une balise peut tre rpte plusieurs fois . Pour indiquer une telle balise, on fait suivre son nom par un plus . Code : XML <!ELEMENT balise (balise2, balise3+, balise4)>
www.openclassrooms.com
36/209
Prenons l'exemple suivant : Code : XML <!ELEMENT <!ELEMENT <!ELEMENT <!ELEMENT repertoire (personne+)> personne (nom, prenom)> nom (#PCDATA)> prenom (#PCDATA)>
Cette dfinition impose que la balise <repertoire /> contienne au minimum une fois la balise <personne />. La balise <personne /> quant elle doit obligatoirement contenir les balises <nom /> et <prenom /> dans cet ordre. Regardons alors la validit des documents XML suivants : Code : XML <!-- valide --> <repertoire> <personne> <nom>DOE</nom> <prenom>John</prenom> </personne> <personne> <nom>POPPINS</nom> <prenom>Marie</prenom> </personne> </repertoire> <!-- valide --> <repertoire> <personne> <nom>DOE</nom> <prenom>John</prenom> </personne> </repertoire> <!-- invalide --> <!-- la balise personne doit tre prsente au moins une fois--> <repertoire />
Un document valide est un document bien form conforme une dfinition. Un document conforme une dfinition est un document qui respecte toutes les rgles qui lui sont imposes dans les fameuses dfinitions. Il existe les DTD internes et les DTD externes . Il est possible d'crire de nombreuses rgles grce aux DTD. Le mot clef ELEMENT permet de d'crire les rgles relatives aux balises XML.
www.openclassrooms.com
37/209
Les attributs
Dans le chapitre prcdent, nous avons dcouvert la syntaxe permettant de dfinir des rgles sur les balises de nos documents XML. V ous allez voir que le principe est le mme pour dfinir des rgles nos attributs .
La syntaxe
Pour indiquer que notre rgle porte sur un attribut, on utilise le mot clef ATTLIST. On utilise alors la syntaxe suivante : Code : XML <!ATTLIST balise attribut type mode>
Une rgle peut donc se diviser en 5 mots clefs : ATTLIST, balise, attribut, type et mode.
Cas d'un attribut ayant pour type la liste des valeurs possibles
Nous allons tudier ici le cas d'un attribut ayant pour type une liste de valeurs . Les diffrentes valeurs possibles pour l'attribut sont spares par une barre verticale . Code : XML
www.openclassrooms.com
38/209
Reprenons une nouvelle fois la balise <personne />. Nous avons vu que cette balise possde un attribut sexe. Nous allons ici imposer la valeur que peut prendre cette attribut : soit masculin, soit fminin. V oici ce quoi la rgle portant sur l'attribut dans notre DTD doit ressembler : Code : XML <!ATTLIST personne sexe (masculin|fminin) mode>
Quelques exemple de documents XML possibles : Code : XML <!-- valide --> <personne sexe="masculin" /> <!-- valide --> <personne sexe="fminin" /> <!-- invalide --> <personne sexe="autre" />
Soit la rgle suivante : Code : XML <!ATTLIST personne sexe CDATA mode>
Notre document XML rpondant cette rgle peut ressembler cela : Code : XML <!-- valide --> <personne sexe="masculin" /> <!-- valide --> <personne sexe="fminin" />
www.openclassrooms.com
39/209
Prenons par exemple la rgle suivante : Code : XML <!ATTLIST personne position ID mode>
V oici quelques exemples de documents XML : Code : XML <!-- valide --> <personne position="POS-1" /> <personne position="POS-2" /> <personne position="POS-3" /> <!-- invalide --> <personne position="POS-1" /> <personne position="POS-1" /> <personne position="POS-2" />
Cas d'un attribut ayant pour type une rfrence un identifiant unique
Il est tout fait possible que dans votre document, un de vos attributs fasse rfrence un identifiant. Cela permet souvent de ne pas crire 100 fois les mmes informations. Par exemple, votre document XML peut vous servir reprsenter des liens de parent entre des personnes. Grce aux rfrences, nous n'allons pas devoir imbriquer des balises XML dans tous les sens pour tenter de reprsenter le pre d'une personne ou le fils d'une personne. Pour faire rfrence un identifiant unique, on utilise le mot clef IDREF. Prenons par exemple la rgle suivante : Code : XML
www.openclassrooms.com
40/209
Cette rgle signifie que la balise personne a 2 attributs : id qui est l'identifiant unique de la personne et father qui fait rfrence une autre personne. Illustrons immdiatement avec un exemple XML : Code : XML <!-- valide --> <father id="PER-1" /> <child id="PER-2" father="PER-1" /> <!-- invalide --> <!-- l'identifiant PER-0 n'apparat nulle part --> <father id="PER-1" /> <child id="PER-2" father="PER-0" />
Dans cet exemple, la personne PER-2 a pour pre la personne PER-1 . Ainsi, on matrialise bien le lien entre ces 2 personnes.
V oici alors quelques exemple de documents XML possibles : Code : XML <!-- valide --> <personne sexe="masculin" /> <!-- valide --> <personne sexe="fminin" /> <!-- invalide --> <personne />
www.openclassrooms.com
41/209
Si l'on reprend l'exemple prcdent, on peut indiquer qu'il n'est pas obligatoire de renseigner le sexe d'une personne par la rgle suivante : Code : XML <!ATTLIST personne sexe CDATA #IMPLIED>
V oici alors quelques exemple de documents XML possibles : Code : XML <!-- valide --> <personne sexe="masculin" /> <!-- valide --> <personne sexe="fminin" /> <!-- valide --> <personne sexe="15" /> <!-- valide --> <personne />
V oici alors quelques exemple de documents XML possibles : Code : XML <!-- valide --> <personne sexe="masculin" /> <!-- valide --> <personne sexe="fminin" /> <!-- valide --> <!-- l'attribut sexe vaut "masculin" --> <personne />
www.openclassrooms.com
42/209
Cette situation peut par exemple se rencontrer lorsque l'on souhaite travailler dans une devise bien prcise et que l'on souhaite qu'elle apparaisse dans le document. Par exemple, la rgle suivante permet d'indiquer que la devise doit obligatoirement apparatre et a pour seule valeur possible l'euro. Code : XML <!ATTLIST objet devise CDATA #FIXED "Euro">
V oici alors quelques exemple de documents XML possibles : Code : XML <!-- valide --> <objet devise="Euro" /> <!-- invalide --> <objet devise="Dollar" /> <!-- invalide --> <objet />
Les entits
Une autre notion assez importante concernant le DTD est la notion d'entit.
Dfinition
Une entit peut-tre considre comme un alias permettant de rutiliser des informations au sein du document XML ou de la dfinition DTD. Au cours de ce chapitre, nous reviendrons sur les 3 types d'entits qui existent : les entits gnrales , les entits paramtres et les entits externes .
La syntaxe
V oyons tout de suite la syntaxe d'une entit gnrale : Code : XML <!ENTITY nom "valeur">
Pour utiliser une entit gnrale dans notre document XML, il suffit d'utiliser la syntaxe suivante : Code : XML
www.openclassrooms.com
43/209
Afin d'illustrer un peu plus clairement mes propos, voyons tout de suite un exemple : Code : XML <!ENTITY samsung "Samsung"> <!ENTITY apple "Apple"> <telephone> <marque>&samsung;</marque> <modele>Galaxy S3</modele> </telephone> <telephone> <marque>&apple;</marque> <modele>iPhone 4</modele> </telephone>
Au moment de son interprtation, les rfrences aux entits seront remplaces par leurs valeurs respectives, ce qui donne une fois interprt : Code : XML <telephone> <marque>Samsung</marque> <modele>Galaxy S3</modele> </telephone> <telephone> <marque>Apple</marque> <modele>iPhone 4</modele> </telephone>
La syntaxe
V oyons tout de suite la syntaxe d'une entit paramtre : Code : XML <!ENTITY % nom "valeur">
Pour utiliser une entit paramtre dans notre DTD, il suffit d'utiliser la syntaxe suivante : Code : XML %nom;
www.openclassrooms.com
44/209
Prenons par exemple ce cas o des tlphones ont pour attribut une marque : Code : XML <telephone marque="Samsung" /> <telephone marque="Apple" />
Normalement, pour indiquer que l'attribut marque de la balise <telephone/> est obligatoire et qu'il doit contenir la valeur Samnsung ou Apple, nous devons crire la rgle suivante : Code : XML <!ATTLIST telephone marque (Samsung|Apple) #REQUIRED>
l'aide d'une entit paramtre, cette mme rgle s'crit de la faon suivante : Code : XML <!ENTITY % listeMarques "marque (Samsung|Apple) #REQUIRED"> <!ATTLIST telephone %listeMarques; >
Encore une fois, au moment de son interprtation, les rfrences aux entits seront remplaces par leurs valeurs respectives.
La syntaxe
V oyons tout de suite la syntaxe d'une entit externe : Code : XML <!ENTITY nom SYSTEM "URI">
Pour utiliser une entit externe dans notre XML, il suffit d'utiliser la syntaxe suivante : Code : XML &nom;
www.openclassrooms.com
45/209
Si l'on reprend notre premier exemple, voici ce que cela donne : Code : XML <!ENTITY samsung SYSTEM "samsung.xml"> <!ENTITY apple SYSTEM "apple.xml"> <telephone> &samsung; <modele>Galaxy S3</modele> </telephone> <telephone> &apple; <modele>iPhone 4</modele> </telephone>
Le contenu des fichiers samsung.xml et apple.xml sera par exemple le suivant : Code : XML <!-- Contenu du fichier samsung.xml --> <marque>Samsung</marque> <!-- Contenu du fichier apple.xml --> <marque>Apple</marque>
Au moment de son interprtation, les rfrences aux entits seront remplaces par leurs valeurs respectives, ce qui donne une fois interprt : Code : XML <telephone> <marque>Samsung</marque> <modele>Galaxy S3</modele> </telephone> <telephone> <marque>Apple</marque> <modele>iPhone 4</modele> </telephone>
Le mot clef ATTLIST permet d'crire les rgles relatives aux attributs d'une balise. Les entits permettent de jouer les fainants en rutilisant des lments qui reviennent souvent dans un document.
www.openclassrooms.com
46/209
Dfinition
Une DTD interne est une DTD qui est crite dans le mme fichier que le document XML. Elle est gnralement spcifique au document XML dans lequel elle est crite.
La syntaxe
Une DTD interne s'crit dans ce qu'on appelle le DOCTYPE. On le place sous le prologue du document et au dessus du contenu XML. V oyons plus prcisment la syntaxe : Code : XML <!DOCTYPE racine [ ]>
La DTD interne est ensuite crite entre les []. Dans ce DOCTYPE, le mot racine doit tre remplac par le nom de la balise qui forme la racine du document XML.
Un document XML rpondant cet nonc peut tre le suivant : Code : XML <?xml version = "1.0" encoding="UTF-8" standalone="yes" ?> <boutique> <telephone> <marque>Samsung</marque> <modele>Galaxy S3</modele> </telephone> <telephone> <marque>Apple</marque>
www.openclassrooms.com
47/209
La dfinition DTD est la suivante : Code : XML <!ELEMENT <!ELEMENT <!ELEMENT <!ELEMENT boutique (telephone*)> telephone (marque, modele)> marque (#PCDATA)> modele (#PCDATA)>
Le document XML complet avec la DTD interne sera par consquent le suivant : Code : XML <?xml version = "1.0" encoding="UTF-8" standalone="yes" ?> <!DOCTYPE boutique [ <!ELEMENT boutique (telephone*)> <!ELEMENT telephone (marque, modele)> <!ELEMENT marque (#PCDATA)> <!ELEMENT modele (#PCDATA)> ]> <boutique> <telephone> <marque>Samsung</marque> <modele>Galaxy S3</modele> </telephone> <telephone> <marque>Apple</marque> <modele>iPhone 4</modele> </telephone> <telephone> <marque>Nokia</marque> <modele>Lumia 800</modele> </telephone> </boutique>
Maintenant que vous savez ce qu'est une DTD interne, passons sans plus attendre la DTD externe !
www.openclassrooms.com
48/209
La syntaxe
L'tude de la syntaxe d'une DTD externe est l'occasion de vous rvler qu'il existe en ralit 2 types de DTD : les DTD externes PUBLIC et les DTD externes SYSTEM. Dans les 2 cas et comme pour une DTD interne, c'est dans le DOCTYPE que cela se passe.
Si on l'applique un document xHTML, on obtient alors le DOCTYPE suivant : Code : XML <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
Pour tre honnte, nous n'allons jamais utiliser les DTD externes PUBLIC dans ce tutoriel, c'est pourquoi je vous propose de passer immdiatement aux DTD externes SYSTEM.
Afin d'illustrer mes propos, je vous propose de reprendre l'exemple de la boutique de tlphone que j'ai utilis dans la partie sur la DTD interne. V oici un rappel de l'nonc : Citation : Enonc Une boutique possde plusieurs tlphones. Chaque tlphone est d'une certaine marque et d'un certain modle, tous les 2 reprsents par une chane de caractre.
www.openclassrooms.com
49/209
Si la DTD ne change pas, elle doit cependant tre place dans un fichier part, par exemple le fichier doc1.dtd. V oici son contenu : Code : XML <!ELEMENT <!ELEMENT <!ELEMENT <!ELEMENT boutique (telephone*)> telephone (marque, modele)> marque (#PCDATA)> modele (#PCDATA)>
Le document XML complet avec la DTD externe sera alors le suivant (on part ici du principe que le fichier XML et DTD sont stocks au mme endroit) : Code : XML <?xml version = "1.0" encoding="UTF-8" standalone="yes" ?> <!DOCTYPE boutique SYSTEM "doc1.dtd"> <boutique> <telephone> <marque>Samsung</marque> <modele>Galaxy S3</modele> </telephone> <telephone> <marque>Apple</marque> <modele>iPhone 4</modele> </telephone> <telephone> <marque>Nokia</marque> <modele>Lumia 800</modele> </telephone> </boutique>
www.openclassrooms.com
50/209
Il est maintenant temps de lever le mystre ! Dans le cas d'une DTD externe, nos documents XML ne sont plus autonomes, en effet, ils font rfrence un autre fichier qui fournit la DTD. Afin que le document contenant la DTD soit bien pris en compte, nous devons l'indiquer en passant simplement la valeur de l'attribut standalone " no". V oici ce que cela donne : Code : XML <?xml version = "1.0" encoding="UTF-8" standalone="no" ?> <!DOCTYPE boutique SYSTEM "doc1.dtd"> <boutique> <telephone> <marque>Samsung</marque> <modele>Galaxy S3</modele> </telephone> <telephone> <marque>Apple</marque> <modele>iPhone 4</modele> </telephone> <telephone> <marque>Nokia</marque> <modele>Lumia 800</modele> </telephone> </boutique>
www.openclassrooms.com
51/209
Si vous essayez de lancer la vrification du document, vous devriez normalement obtenir un message d'erreur, comme celui indiqu la figure suivante :
Message d'erreur indiquant que le document DTD est introuvable Ce message est, pour le moment, compltement normal puisque nous n'avons pas encore cr notre document DTD.
Cration d'un document DTD V otre document DTD n'est normalement pas vierge. V oici ce que vous devriez avoir :
www.openclassrooms.com
52/209
Replacez le contenu par notre vritable DTD : Code : XML <!ELEMENT <!ELEMENT <!ELEMENT <!ELEMENT boutique (telephone*)> telephone (marque, modele)> marque (#PCDATA)> modele (#PCDATA)>
Enregistrez ensuite votre document avec le nom boutique.dtd au mme endroit que votre document XML.
Vrification de la DTD
V ous pouvez vrifier que votre DTD n'a pas d'erreur de syntaxe en cliquant sur l'icne ou bien en slectionnant dans la
barre de menu DTD/Schema puis Check this DTD ou encore en utilisant le raccourci clavier Ctrl + K. V ous devriez normalement avoir un message d'information de cet type :
www.openclassrooms.com
53/209
www.openclassrooms.com
54/209
L'nonc
Le but de ce TP est de crer la DTD du rpertoire labor dans le premier TP. Pour rappel, voici les informations que l'on souhaite connatre pour chaque personne : Son sexe (homme ou femme). Son nom. Son prnom. Son adresse. Un ou plusieurs numros de tlphone (tlphone portable, fixe, bureau, etc.). Une ou plusieurs adresses e-mail (adresse personnelle, professionnelle, etc.). V oici le document XML que nous avions construit : Code : XML <?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <repertoire> <!-- John DOE --> <personne sexe="masculin"> <nom>DOE</nom> <prenom>John</prenom> <adresse> <numero>7</numero> <voie type="impasse">impasse du chemin</voie> <codePostal>75015</codePostal> <ville>PARIS</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="fixe">01 02 03 04 05</telephone> <telephone type="portable">06 07 08 09 10</telephone> </telephones> <emails> <email type="personnel">john.doe@wanadoo.fr</email> <email type="professionnel">john.doe@societe.com</email> </emails> </personne> <!-- Marie POPPINS --> <personne sexe="feminin"> <nom>POPPINS</nom> <prenom>Marie</prenom> <adresse> <numero>28</numero> <voie type="avenue">avenue de la rpublique</voie> <codePostal>13005</codePostal> <ville>MARSEILLE</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="bureau">04 05 06 07 08</telephone> </telephones> <emails> <email type="professionnel">contact@poppins.fr</email> </emails> </personne> </repertoire>
www.openclassrooms.com
55/209
Une solution
Une fois de plus, je vous fais part de ma solution ! Le fichier XML avec le DOCTYPE : Code : XML <?xml version="1.0" encoding="UTF-8" standalone="no" ?> <!DOCTYPE repertoire SYSTEM "repertoire.dtd"> <repertoire> <!-- John DOE --> <personne sexe="masculin"> <nom>DOE</nom> <prenom>John</prenom> <adresse> <numero>7</numero> <voie type="impasse">impasse du chemin</voie> <codePostal>75015</codePostal> <ville>PARIS</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="fixe">01 02 03 04 05</telephone> <telephone type="portable">06 07 08 09 10</telephone> </telephones> <emails> <email type="personnel">john.doe@wanadoo.fr</email> <email type="professionnel">john.doe@societe.com</email> </emails> </personne> <!-- Marie POPPINS --> <personne sexe="feminin"> <nom>POPPINS</nom> <prenom>Marie</prenom> <adresse> <numero>28</numero> <voie type="avenue">avenue de la rpublique</voie> <codePostal>13005</codePostal> <ville>MARSEILLE</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="professionnel">04 05 06 07 08</telephone> </telephones> <emails> <email type="professionnel">contact@poppins.fr</email> </emails> </personne> </repertoire>
Le fichier DTD : Code : XML <!-- Racine --> <!ELEMENT repertoire (personne*)> <!-- Personne -->
www.openclassrooms.com
56/209
Un bref commentaire
Dans cette solution, je suis all au plus simple en indiquant que pour les types de tlphones, d'e-mails et de voies, j'accepte toutes les chanes de caractres. Libre vous de crer de nouvelles rgles si vous souhaitez que, par exemple, le choix du type de la voie ne soit possible qu'entre rue, avenue, impasse, etc.
www.openclassrooms.com
57/209
Un nouveau format
Tout d'abord, les DTD ne sont pas au format XML. Nous avons d apprendre un nouveau langage avec sa propre syntaxe et ses propres rgles. La principale consquence est que, pour exploiter une DTD, nous allons tre oblig d'utiliser un outil diffrent de celui qui exploite un fichier XML. Il est vrai que dans notre cas, nous avons utilis le mme outil, savoir EditiX , mais vos futurs programmes, logiciels ou applications mobiles devront forcment exploiter la DTD et le fichier XML diffremment, l'aide, par exemple, d'une API diffrente.
Le typage de donnes
Le second dfaut que l'on retiendra dans ce cours est que les DTD ne permettent pas de typer des donnes. Comme vous avez pu le voir, on se contente d'indiquer qu'une balise contient des donnes, mais impossible de prciser si l'on souhaite que a soit un nombre entier, un nombre dcimal, une date, une chane de caractres, etc.
Les contraintes
Nous dcouvrirons aussi que les Schmas XML permettent d'tre beaucoup plus prcis que les DTD lors de l'criture des diffrentes contraintes qui rgissent un document XML.
L'extension du fichier
Comme pour les DTD, nous prendrons l'habitude de sparer les donnes formates avec XML et le Schma XML associ dans 2 fichiers distincts. Bien que c'est les Schmas XML soient crits avec un langage de type XML, le fichier n'a pas cette extension. Un fichier dans lequel est crit un Schma XML porte l'extension " .xsd".
www.openclassrooms.com
58/209
Le prologue
Puisque c'est le XML qui est utilis, il ne faut pas droger la rgle du prologue. Ainsi, la premire ligne d'un Schma XML est : Code : XML <?xml version="1.0" encoding="UTF-8" ?>
Je ne dtaille pas ici les diffrents lments du prologue puisque je l'ai dj fait lors de la premire partie dans le chapitre traitant de la structure d'un document XML. Si vous avez des doutes, je vous encourage vivement relire cette partie !
Le corps
Comme pour un fichier XML classique, le corps d'un Schma XML est constitu d'un ensemble de balises dont nous verrons le rle dans les prochains chapitres. Cependant, une chose ne change pas : la prsence d'un lment racine, c'est--dire la prsence d'une balise qui contient toutes les autres. Mais, contrairement un fichier XML, son nom nous est impos. Code : XML <!-- Prologue --> <?xml version="1.0" encoding="UTF-8" ?> <!-- Elment racine --> <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> </xsd:schema>
Comme vous pouvez le voir dans le code prcdent, l'lment racine est <xsd:schema />. Si l'on regarde de plus prt, on remarque la prsence de l'attribut xmlns:xsd. xmlns nous permet de dclarer un espace de noms . Si ce vocabulaire ne vous parle pas, je vous encourage lire le chapitre ddi cette notion en annexe de ce tutoriel. A travers la dclaration de cet espace de noms , tous les lments doivent commencer par xsd:.
L'espace de noms
Code : XML xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
La location
Le second attribut nous permet d'indiquer notre fichier XML o se situe le fichier contenant le Schma XML. 2 possibilits s'offrent alors nous : les schmas XML qui dcrivent un espace de noms et ceux qui ne dcrivent pas un espace
www.openclassrooms.com
59/209
Pour rsumer
Pour rsumer, voici ce quoi nos fichiers XML ressembleront : Code : XML <?xml version="1.0" encoding="UTF-8"?> <racine xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="chemin_vers_fichier.xsd"> </racine>
Les Schmas XML offrent plus de possibilits que les DTD. Les Schmas XML s'crivent l'aide d'un langage de type XML. Un fichier dans lequel est crit un Schma XML porte l'extension ".xsd".
www.openclassrooms.com
60/209
Quelques exemples
Prenons quelques exemples de fichiers XML, et regardons ensemble s'ils peuvent tre considrs comme des types simples : Code : XML <!-- Ne contient ni attribut ni aucun autre lment => lment simple --> <nom>ROBERT</nom> <!-- Contient un attribut => n'est pas un lment simple --> <!-- Cependant l'attribut "sexe" est un lment simple --> <personne sexe="masculin>Robert DUPONT</personne> <!-- La balise personne contient d'autres lments (les balises nom et prnom) => n'est pas un lment simple --> <personne> <!-- Ne contient ni attribut ni aucun autre lment => lment simple --> <nom>DUPONT</nom> <!-- Ne contient ni attribut ni aucun autre lment => lment simple --> <prenom>Robert</prenom> </personne>
J'espre que ces exemples vous permettent de mieux comprendre ce qu'est un lment simple.
www.openclassrooms.com
61/209
Au sein d'un Schma XML, les lments prcdents seront dclars de la sorte : Code : XML <xsd:element name="nom" type="xsd:string" /> <xsd:element name="prenom" type="xsd:string" /> <xsd:element name="age" type="xsd:int" />
String est utilis pour qualifier une chane de caractres et int est utilis pour qualifier un nombre entier. La liste complte des types qu'il est possible d'utiliser est fournie un peu plus loin dans ce tutoriel.
V oici alors quelques exemple de documents XML possibles : Code : XML <!-- valide --> <prenom>Jean</prenom> <!-- valide --> <prenom>Marie</prenom>
www.openclassrooms.com
62/209
Valeur constante
S'il est possible d'indiquer une valeur par dfaut, il est galement possible d'imposer une valeur. Cette valeur inchangeable est appele constante. Pour indiquer une valeur constante, c'est l'attribut fixed qui est utilis au niveau de la balise <element /> du Schma XML. Par exemple, si je souhaite obliger toute les personnes de mon document XML porter le prnom Robert, voici la rgle crire : Code : XML <xsd:element name="prenom" type="xsd:string" fixed="Robert" />
V oyons alors la validit des lignes XML suivantes : Code : XML <!-- valide --> <prenom>Robert</prenom> <!-- invalide --> <prenom>Marie</prenom> <!-- invalide --> <prenom/>
Les attributs
Comme je vous le disais un peu plus tt dans ce tutoriel, dans un Schma XML, tous les attributs d'une balise XML sont considrs comme des lments simples. En effet, ils ne peuvent prendre comme valeur qu'un type simple, c'est--dire un nombre, une chane de caractre, une date, etc.
Dclarer un attribut
Bien qu'un attribut soit un lment simple, nous n'allons pas utiliser le mot clef element pour dclarer un attribut. C'est le mot attribut qui est utilis. Encore une fois, n'oubliez pas de faire prcder son utilisation par xsd: Cette balise prend 2 attributs : un nom et un type. Code : XML <xsd:attribut name="mon_nom" type="xsd:mon_type" />
Prenons par exemple la ligne XML suivante : Code : XML <personne sexe="masculin">Robert DUPONT</personne>
www.openclassrooms.com
63/209
Je ne vais pas dtailler ici comment dclarer la balise. En effet, puisqu'elle contient un attribut, c'est ce qu'on appelle un lment complexe et nous verrons comment faire un peu plus tard. Cependant, voici comment dclarer l'attribut dans notre Schma XML : Code : XML <xsd:attribut name="sexe" type="xsd:string" />
Valeur constante
S'il est possible d'indiquer une valeur par dfaut, il est galement possible d'imposer une valeur. Cette valeur inchangeable est appele constante. Pour indiquer une valeur constante, c'est l'attribut fixed qui est utilis au niveau de la balise <attribut /> du Schma XML. Par exemple, si je souhaite obliger toutes les personnes de mon document XML porter le prnom Robert, voici la rgle crire : Code : XML <xsd:attribut name="prenom" type="xsd:string" fixed="Robert" />
Attribut obligatoire
Tels que nous les dclarons depuis le dbut de ce chapitre, les attributs sont, par dfaut, optionnels. Pour indiquer qu'un attribut est obligatoire, nous devons renseigner la proprit use laquelle nous affectons la valeur required. Par exemple, si je souhaite obliger l'utilisation de l'attribut prenom, voici la rgle crire : Code : XML <xsd:attribut name="prenom" type="xsd:string" use="required" />
Un lment simple est un lment qui ne contient qu'une valeur dont le type est dit simple comme par exemple une balise qui ne contient aucun attribut et dans laquelle aucune autre balise n'est imbrique. Pour dcrire un lment simple, on utilise la balise <xsd:element />. Il est possible de dfinir une valeur par dfaut ou une valeur constante un lment simple. Un attribut est galement un lment simple. Pour dcrire un attribut, on utilise la balise <xsd:attribut />. Il est possible de dfinir une valeur par dfaut, une valeur constante un lment simple ou rendre obligatoire un attribut.
www.openclassrooms.com
64/209
normalizedString reprsente une chane de caractres normalise token language NMTOKEN reprsente une chane de caractres normalise sans espace au dbut et la fin reprsente le code d'une langue reprsente une chane de caractre "simple"
reprsente une liste de NMTOKEN reprsente un nom XML reprsente un nom XML sans le caractre : reprsente un identifiant unique
IDREF
rfrence un identifiant
IDREFS
ENTITY
ENTITIES
Plus en dtails
Le type string
Le type string est l'un des premiers types que nous ayons vu ensemble. Il reprsente une chane de caractres et peut donc contenir un peu tout et n'importe quoi. Il est cependant important de noter que certains caractres spciaux comme le & doivent tre crits avec leur notation HTML. Une liste des caractres spciaux et de leur notation HTML est disponible ici. Bien que nous ayons dj vu plusieurs exemples ensemble, je vous en propose un nouveau afin que ce type n'ait plus aucun secret pour vous. Soit la rgle de Schma XML suivante :
www.openclassrooms.com
65/209
Les diffrentes lignes XML ci-dessous sont alors valides : Code : XML <string>France</string> <string>Site du zro !</string> <string>&</string>
Le type normalizedString
Le type normalizedString est bas sur le type string et reprsente une chane de caractres normalise, c'est--dire, une chane de caractres qui peut contenir tout et n'importe quoi l'exception de tabulations, de sauts de ligne et de retours chariot. Dans la pratique, il n'est pas interdit de les crire, mais ils seront automatiquement remplacs par des espaces. Puisque le type normalizedString est bas sur le type string , toutes les rgles du type string s'applique galement au type normalizedString . Ainsi, les caractres spciaux comme le & doivent tre crits avec leur notation HTML. Je ne le prciserai pas chaque fois, mais cette rgle est toujours vraie. Un type hrite toujours de toutes les rgles du type sur lequel il se base.
Le type token
Le type token est bas sur le type normalizedString et reprsente une chane de caractres normalise sans espace au dbut ni la fin. Une nouvelle fois, dans la pratique, il n'est pas interdit de les crire. Les espaces prsents au dbut et la fin seront automatiquement supprims.
Le type language
Le type language est bas sur le type token et reprsente, comme son nom le laisse deviner, une langue. Cette langue doit tre identifie par 2 lettres (selon la norme ISO 639 dont la liste est disponible par sur wikipedia). Ces 2 caractres peuvent ventuellement tre suivi d'un code pays (selon la norme ISO 3166 dont la liste est une nouvelle fois disponible sur wikipedia). Considrons la rgle suivante : Code : XML <xsd:element name="langue" type="xsd:language" />
Les diffrentes lignes XML ci-dessous sont alors valides : Code : XML <langue>fr</langue> <langue>en</langue> <langue>en-GB</langue>
www.openclassrooms.com
66/209
Le type NMTOKEN
Le type NMTOKEN est bas sur le type token et reprsente une chane de caractres "simple", c'est--dire une chane de caractres sans espace qui ne contient que les symboles suivants : Des lettres. Des chiffres. Les caractres spciaux . - _ et : Si la chane de caractres contient des espaces au dbut ou la fin, ils seront automatiquement supprims. Afin d'assurer une compatibilit entre les Schmas XML et les DTD, il convient de n'utiliser le type NMTOKEN que pour un attribut.
Le type NMTOKENS
Le type NMTOKENS reprsente une liste de NMTOKEN spars par un espace. Une nouvelle fois, afin d'assurer une compatibilit entre les Schmas XML et les DTD, il convient de n'utiliser le type NMTOKENS seulement pour un attribut. Soit la rgle suivante issue d'un Schma XML : Code : XML <xsd:attribut name="liste" type="xsd:NMTOKENS" />
Les diffrentes lignes XML ci-dessous sont alors valides : Code : XML <balise list="A:1_B C-2.">contenu de la balise</balise> <balise list="AZERTY 123456 QSDFGH">contenu de la balise</balise>
Le type Name
Le type Name est bas sur le type token et reprsente un nom XML, c'est--dire une chane de caractres sans espace qui ne contient que les symboles suivants : Des lettres. Des chiffres. Les caractres spciaux . - _ et : La diffrence avec le type NMTOKEN est qu'une chane de caractres de type Name doit obligatoirement commencer par une lettre, ou l'un des 2 caractres spciaux suivants : _ et :
Le type NCName
Le type NCName est bas sur le type Name. Il hrite donc de toutes les rgles du type Name auxquelles une nouvelle rgles doit tre ajoute : le type NCName ne peut pas contenir le caractre spcial :
www.openclassrooms.com
67/209
Le type ID
Le type ID est bas sur le type NCName, il hrite donc de toutes les rgles de ce type. Comme son nom le laisse deviner, un ID reprsente un identifiant. Il doit donc contenir des valeurs uniques. A ce titre, il est impossible de lui dfinir une valeur fixe ou par dfaut. Comme pour d'autres types vu prcdemment, un ID ne doit tre utilis qu'avec les attributs afin d'assurer une compatibilit entre les Schmas XML et les DTD.
Le type IDREF
Le type IDREF fait rfrence un ID existant dans le document XML. Tout comme le type ID, il est bas sur le type NCName et hrite donc de toutes les rgles de ce type. Puisque le type ID n'est utilisable qu'avec des attributs, il en est naturellement de mme pour le type IDREF.
Le type IDREFS
Si le type NMTOKENS reprsente une liste de NMTOKEN spars par un espace, le type IDREFS reprsente lui une liste de IDREF spars par un espace. Afin d'assurer une compatibilit entre les Schmas XML et les DTD, il convient de n'utiliser le type IDREFS que pour un attribut. Illustrons son utilisation avec un exemple : Code : XML <xsd:attribut name="enfants" type="xsd:IDREFS" />
Le type ENTITY
Le type ENTITY permet de faire rfrence une entit le plus souvent non XML et dclar dans des fichiers DTD. Ce type est bas sur le type NCName, il hrite donc de toutes ses rgles. Une nouvelle fois, afin d'assurer une compatibilit entre les Schmas XML et les DTD, il convient de n'utiliser le type ENTITY que pour un attribut. Une nouvelle fois, je vous propose d'illustrer son utilisation par un exemple : Code : XML <xsd:attribut name="marque" type="xsd:ENTITY" />
www.openclassrooms.com
68/209
Le type ENTITIES
Finalement, le dernier type que nous verrons dans cette catgorie est le type ENTITIES . Il permet de faire rfrence une liste d'ENTITY spars par un espace. Puisque c'tait dj le cas pour le type ENTITY, le type ENTITIES n'chappe pas la rgle et ne doit tre utilis qu'avec un attribut.
Plus en dtails
Le type duration
Le type duration, comme son nom le laisse deviner, reprsente une dure. Cette dure s'exprime en nombre d'annes, de mois, de jours, d'heures, de minutes et de secondes selon une expression qui n'est pas des plus simples savoir PnYnMnDTnHnMnS. Je vous propose de la dcortiquer : P marque le dbut de l'expression. nY reprsente le nombre d'annes (year) o n est un nombre entier. nM reprsente le nombre de mois (month) o n est un nombre entier. nD reprsente le nombre de jours (day) o n est un nombre entier. T permet de sparer la partie date de l'expression de sa partie heure. nH reprsente le nombre d'heures (hour) o n est un nombre entier. nM reprsente le nombre de minutes (minute) o n est un nombre entier. nS reprsente le nombre de secondes (second) o n est un nombre entier ou dcimal. L'expression peut-tre prcd du signe - dans le cas o l'on souhaite exprimer une dure ngative. Bien videmment, tous les champs ne doivent pas forcment tre renseigns. Ainsi, il est possible de ne renseigner que les heures, les minutes, etc. Dans le cas o l'expression n'exprime qu'une date, le symbole T ne doit plus figurer. Je vous accorde que toutes ces rgles ne sont pas facile assimiler, c'est pourquoi je vous propose de voir quelques exemples : Code : XML <xsd:element name="duree" type="xsd:duration" />
www.openclassrooms.com
69/209
Code : XML <!-- 42 ans et 6 minutes --> <duree>P42YT6M</duree> <!-- -2 heures --> <duree>-PT2H</duree> <!-- 2 jours --> <duree>P2D</duree> <!-- 10.5 secondes --> <duree>PT10.5S</duree>
Le type date
Le type date permet d'exprimer une date. A l'image du type duration, une date s'exprime selon une expression bien spcifique savoir YYYY-MM-DD. Une nouvelle fois, je vous propose de dcortiquer tout a : YYYY reprsente l'anne (year) sur 4 chiffres ou plus. MM reprsente le mois (month) sur 2 chiffres. DD reprsente le jour (day) galement sur 2 chiffres.
Dans le cas o l'on souhaite exprimer une date avant Jsus-Christ, un signe - peut-tre plac devant l'expression. V oyons ensemble quelques exemples : Code : XML <xsd:element name="madate" type="xsd:date" />
Code : XML <!-- 13 janvier 1924 --> <madate>1924-01-13</madate> <!-- 12 dcembre 34 avant JC --> <madate>-0034-12-12</madate> <!-- 4 novembre 12405 --> <madate>12405-11-04</madate>
Le type time
Le type time permet d'exprimer une heure. Encore une fois, une expression bien spcifique doit tre respecte : hh:mm:ss. Pour continuer avec nos bonnes habitudes, dcortiquons ensemble cette expression : hh reprsente les heures (hour) sur 2 chiffres. mm reprsente les minutes (minute) sur 2 chiffres. ss reprsente les secondes (second) sur 2 chiffres entiers ou virgule.
www.openclassrooms.com
70/209
Code : XML <!-- 10 heures et 24 minutes --> <monheure>10:24:00</monheure> <!-- 2,5 secondes --> <monheure>00:00:02.5</monheure>
Le type dateTime
Le type dateTime peut tre considr comme un mlange entre le type date et le type time. Ce nouveau type permet donc de reprsenter une date ET une heure. Une nouvelle fois, une expression particulire doit tre respecte : YYYY-MM-DDThh:mm:ss. Je ne vais pas spcifiquement revenir sur cette expression. En effet, comme vous pouvez le constater, il s'agit des expressions du type date et du type time spares par la lettre T. Je vous laisse vous rfrer aux types date et time pour les rgles appliquer.
Le type gYear
Le type gYear reprsente une anne sur 4 chiffres ou plus. Dans le cas o l'on souhaite exprimer une anne avant Jsus-Christ, un signe - peut-tre plac devant l'expression.
Le type gYearMonth
Le type gYearMonth reprsente une anne et un mois. Comme pour tous les types que nous venons de voir dans ce chapitre, le type gYearMonth doit respecter une expression particulire : YYYY-MM. V ous l'aurez compris, les rgles sont toujours les mmes. Je vous laisse donc vous reporter au paragraphe traitant du type date pour plus d'informations.
Le type gMonth
Le type gMonth reprsente un mois sur 2 chiffres prcds du symbole --. Non, ce n'est pas une erreur de frappe, le symbole est bien --. V oyons un exemple : Code : XML <xsd:element name="mois" type="xsd:gMonth" />
www.openclassrooms.com
71/209
Le type gMonthDay
Le type gMonthDay reprsente un mois et un jour. Une nouvelle fois, une expression particulire doit tre utilise afin d'exprimer ce nouveau type : --MM-DD. Une nouvelle fois, les rgles sont les mmes que celles que nous avons dj utilis prcdemment notamment pour le type date et me type gYearMonth.
Le type gDay
Finalement, nous allons terminer ce chapitre avec le type gDay qui reprsente un jour sur 2 chiffres prcds du symbole ---. Afin de terminer ce chapitre en beaut, voici quelques exemples : Code : XML <xsd:element name="journee" type="xsd:gDay" />
Code : XML <!-- le troisime jour du mois --> <journee>---03</journee> <!-- le douzime jour du mois --> <journee>---12</journee>
www.openclassrooms.com
72/209
bas sur le type unsignedLong bas sur le type unsignedInt bas sur le type unsignedShort
Comme bien souvent en informatique, il convient d'crire d'crire les nombres dcimaux avec un point et non une virgule. Par exemple 4.2, 5.23, etc.
Plus en dtails
Le type float
Comme vous avez dj pu le lire dans le tableau rcapitulatif, le type float reprsente un nombre flottant sur 32 bits et conforme la norme IEEE 754. Je suis parfaitement conscient que cette dfinition est incomprhensible pour la plupart des gens, c'est pourquoi nous allons grandement la simplifier. Le type float t emprunt aux langages de programmation comme le langage C et est encore aujourd'hui utilis dans des langages plus rcents comme Java ou C#. Il reprsente un nombre flottant, c'est--dire un nombre entier ou dcimal, se trouvant entre les valeurs 3.4x10^-38 et 3.4x10^38. A cette plage de valeurs, 3 autres peuvent tre ajoutes : -INF pour moins l'infini. +INF pour plus l'infini. NaN pour Not a Number, c'est--dire pour dsigner une valeur non numrique. Il est tout fait possible d'crire un nombre de type float avec des exposants. Il convient alors d'utiliser la notation E ou e. Pour mieux comprendre toutes ces rgles, je vous propose de regarder ensemble quelques exemples : Code : XML <xsd:element name="nombre" type="xsd:float" />
Le type double
Le type double est trs proche du type float, si ce n'est qu'il reprsente un nombre flottant sur 64 bits et conforme la norme IEEE 754 au lieu des 32 bits du type float. Concrtement, cette diffrence se traduit par le fait qu'un nombre de type double se trouvant entre les valeurs 1.7x10^-308 et 1.7x10^308.
www.openclassrooms.com
73/209
On retrouve galement la rgle de l'exposant. Je vous laisse vous rfrer la dfinition du type float pour plus de dtails.
Le type decimal
Comme son nom le laisse deviner, le type decimal reprsente un nombre dcimal, c'est--dire un nombre qui peut-tre entier ou virgule. Ce nombre peut-tre positif ou ngatif et donc tre prcd du symbole + ou -. Dans le cas d'un nombre o la partie entire est gale zro, il n'est pas obligatoire de l'crire. V oyons tout de suite quelques exemples afin d'illustrer cette dfinition : Code : XML <xsd:element name="nombre" type="xsd:decimal" />
Le type integer
Le type integer est bas sur le type decimal et reprsente un nombre entier, c'est--dire un nombre sans virgule. Comme pour le type dcimal , un nombre de type integer peut tre prcd par le symbole + ou -.
Le type long
Le type long est bas sur le type integer si ce n'est qu'un nombre de type long doit forcment tre compris entre les valeurs -9 223 372 036 854 775 808 et 9 223 372 036 854 775 807.
Le type int
Le type int est bas sur le type long si ce n'est qu'un nombre de type int doit forcment tre compris entre les valeurs -2 147 483 648 et 2 147 483 647.
Le type short
Le type short est bas sur le type int si ce n'est qu'un nombre de type short doit forcment tre compris entre les valeurs -32 768 et 32 768.
Le type byte
Le type byte est bas sur le type short si ce n'est qu'un nombre de type byte doit forcment tre compris entre les valeurs -128 et 127.
www.openclassrooms.com
74/209
Le type nonPositiveInteger
Bas sur le type integer, le type nonPositiveInteger reprsente un nombre entier qui n'est pas positif. Concrtement, cela correspond un nombre ngatif ou au nombre zro. V oyons ensemble un exemple : Code : XML <xsd:element name="nombre" type="xsd:nonPositiveInteger" />
Le type negativeInteger
Bas sur le type nonPositiveInteger, le type negativeInteger reprsente un nombre entier strictement ngatif, c'est--dire strictement infrieur zro.
Le type nonNegativeInteger
Bas sur le type integer, le type nonNegativeInteger reprsente un nombre entier qui n'est pas ngatif, c'est--dire un nombre suprieur ou gal zro. Soit l'exemple suivant : Code : XML <xsd:element name="nombre" type="xsd:nonPositiveInteger" />
Le type positiveInteger
Bas sur le type nonNegativeInteger, le type positiveIntegerreprsente un nombre entier strictement positif, c'est--dire strictement suprieur zro.
Le type unsignedLong
Le type unsignedLong est bas sur le type nonNegativeInteger et reprsente un entier compris entre les valeurs 0 et 18 446 744
www.openclassrooms.com
75/209
Le type unsignedInt
Le type unsignedInt est bas sur le type unsignedLong et reprsente un entier compris entre les valeurs 0 et 4 294 967 295.
Le type unsignedShort
Le type unsignedShort est bas sur le type unsignedInt et reprsente un entier compris entre les valeurs 0 et 65 535.
Le type unsignedByte
Le type unsignedByte est bas sur le type unsignedShort et reprsente un entier compris entre les valeurs 0 et 255.
base64Binary reprsente une donne binaire au format Base64 hexBinary reprsente une donne binaire au format hexadecimal
Plus en dtails
Le type boolean
Le type boolean, comme son nom le laisse deviner, reprsente un boolen. Pour ceux qui ignorent de quoi il s'agit, un boolen permet d'indiquer l'un des 2 tats suivant : vrai ou faux. Si 2 tats sont possibles, 4 valeurs sont en ralits acceptes : true qui reprsente l'tat vrai. false qui reprsente l'tat faux. 1 qui reprsente l'tat vrai. 0 qui reprsente l'tat faux. Conscient que cette notion n'est pas forcment facile comprendre lorsque cest la premire fois qu'on la rencontre, je vais tenter de l'illustrer avec un exemple. Notre exemple va nous permettre, via un attribut, de savoir si une personne est un animal ou pas. Code : XML <xsd:attribute name="animal" type="xsd:boolean" />
Code : XML <!-- Victor Hugo n'est pas un animal --> <personne animal="false">Victor Hugo</personne>
www.openclassrooms.com
76/209
Le type QName
Le type QName reprsente un nom qualifi. C'est un concept qui s'appuie sur l'utilisation des espaces de nom.
Le type NOTATION
Le type NOTATION permet d'identifier et dcrire du contenu XML ou non comme par exemple une image.
Le type anyURI
Comme son nom l'indique, le type anyURI reprsente une URI (Uniform Resource Identifier). Une URI est une chane de caractre qui permet d'identifier une ressource. On distingue gnralement 2 types d'URI : Les URL (Uniform Resource Locator) est probablement la forme d'URI la plus connue et je suis sr que ce nom vous parle. En effet, les URL sont utiliss pour dcrire l'adresse d'une ressource sur un rseau. Par exemple http://www.siteduzero.com et ftp://ftp.rfc-editor.org/in-notes/rfc2396.txt sont deux URL possibles. Les URN (Uniform Resource Name) sont quant eux utiliss pour identifier une ressource dans un espace de noms. Je ne vais pas m'attarder sur les URN car nous reviendrons plus tard dans ce cours sur la notion des espaces de nom. Une URI permet d'identifier une ressource de manire relative ou absolue. V oyons ensemble quelques exemples : Code : XML <xsd:attribute name="adresse" type="xsd:anyURI"/>
Code : XML <!-- URI absolu --> <image adresse="http://www.siteduzero.com/bundles/common/images/spreadsheetV32.png" /> <!-- URI relatif --> <image adresse="../bundles/common/images/spreadsheetV32.png"/>
Le type base64Binary
Le type base64Binary reprsente une donne binaire au format Base64. V ous trouverez plus d'informations ce sujet sur Wikipedia. Comme de nombreux types que nous avons vu, le type base64Binary impose le respect de plusieurs rgles : Seules les lettres (majuscules ou minuscules), les chiffres et les symboles + / et = sont autoriss. Le nombre de caractres qui composent la chane doit tre un multiple de 4. Dans le cas o le symbole = est utilis, de nouvelles rgles doivent tre respectes :
www.openclassrooms.com
77/209
Il ne peut apparatre qu'en fin de chane, une fois ou deux. Dans le cas o il est utilis qu'une seule fois, il doit forcment tre prcd des caractres A Q g ou w. Dans le cas o il est utilis 2 fois, il doit forcment tre prcd des caractres A E I M Q U Y c g k o s w 0 (zro) 4 ou 8.
Le type hexBinary
Le type hexBinary reprsente une donne binaire au format hexadecimal. Si comme pour le type base64Binary quelques rgles sont respecter, elles sont bien plus simples dans le cas du type hexBinary . Ainsi, seuls les lettres entre A et F (majuscules ou minuscules), ainsi que les chiffres sont autoriss. A noter : le nombre de caractres composant la chane doit forcment tre un multiple de 2. Il existe 4 grandes familles de types simples. Ces familles permettent d'tre trs prcis quant la description des lments simples et des attributs.
www.openclassrooms.com
78/209
Abordons maintenant diffrents exemples qui vont nous permettre de voir et de comprendre comment dclarer des lments complexes dans un Schma XML.
www.openclassrooms.com
79/209
V oici comment le dclarer : Code : XML <xsd:element name="personne"> <xsd:complexType> <!-- contenu ici --> </xsd:complexType> </xsd:element>
Quelques exemples
Je vous propose de voir quelques exemples d'lments complexes dont le contenu est dit simple. Code : XML <!-- contient un attribut et du texte --> <prix devise="euros">35</prix> <!-- contient un attribut et du texte --> <voiture marque="Renault">Clio</voiture>
Du ct du Schma XML
La syntaxe
Pour dclarer un lment complexe faisant rfrence une balise contenant des attributs et du texte, voici la syntaxe utiliser : Code : XML
www.openclassrooms.com
80/209
Un exemple
Reprenons l'exemple d'un prix prenant pour attribut une devise : Code : XML <prix devise="euros">35</prix>
V oici alors le schma XML associ : Code : XML <xsd:element name="prix"> <xsd:complexType> <xsd:simpleContent> <xsd:extension base="xsd:positiveInteger"> <xsd:attribute name="devise" type="xsd:string" /> </xsd:extension> </xsd:simpleContent> </xsd:complexType> </xsd:element>
Dans le cas o la balise que l'on cherche dcrire contient plusieurs attributs, il convient de tout simplement les lister entre les balises <xsd:extension/>. Par exemple : Code : XML <voiture marque="Renault" type="essence">Clio</voiture>
Code : XML <xsd:element name="voiture"> <xsd:complexType> <xsd:simpleContent> <xsd:extension base="xsd:string"> <xsd:attribut name="marque" type="xsd:string" /> <xsd:attribut name="type" type="xsd:string" /> </xsd:extension> <xsd:simpleContent> </xsd:complexType> </xsd:element>
www.openclassrooms.com
81/209
Comme vous pouvez le constater, on se contente de mettre la suite les diffrents attributs qui composent l'lment. noter que l'ordre dans lequel les attributs sont dclars dans le Schma XML n'a aucune importance.
Ce que j'appelle contenu "standard", c'est le contenu d'un lment complexe qui n'est compos que d'autres lments (simples ou complexes) ou uniquement d'attributs.
Quelques exemples
Comme pour le contenu simple, voyons quelques exemples de contenu "standard" : Code : XML <!-- contient d'autres lments --> <personne> <nom>DUPONT</nom> <prenom>Robert</prenom> </prenom> <!-- contient un attribut --> <voiture marque="Renault" />
V oici alors le Schma XML associ : Code : XML <xsd:element name="voiture"> <xsd:complexType> <xsd:attribut name="marque" type="xsd:string" /> </xsd:complexType> </xsd:element>
Il n'y a, pour le moment, rien de bien compliqu. On se contente d'imbriquer une balise <xsd:attribut /> dans une balise <xsd:complexType />. Si l'on tente de complexifier un petit peu les choses, nous allons nous rendre compte que, dans le fond, rien ne change. Prenons
www.openclassrooms.com
82/209
Regardons alors le Schma XML : Code : XML <xsd:element name="voiture"> <xsd:complexType> <xsd:attribut name="marque" type="xsd:string" /> <xsd:attribut name="modele" type="xsd:string" /> </xsd:complexType> </xsd:element>
Comme vous pouvez le constater, on se contente de mettre la suite les diffrents attributs qui composent l'lment. Une fois de plus, l'ordre dans lequel les balises <xsd:attribut /> sont places n'a aucune importance.
La squence
Une squence est utilise lorsque l'on souhaite spcifier que les lments contenus dans un type complexe doivent apparatre dans un ordre prcis. V oici comment se dclare une squence au niveau d'un Schma XML : Code : XML <xsd:element name="mon_nom"> <xsd:complexType> <xsd:sequence> <!-- liste des lments --> </xsd:sequence> <!-- listes des attributs --> </xsd:complexType> </xsd:element>
V oyons tout de suite un exemple : Code : XML <xsd:element name="personne"> <xsd:complexType> <xsd:sequence> <xsd:element name="nom" type="xsd:string"/> <xsd:element name="prenom" type="xsd:string"/> </xsd:sequence> <xsd:attribute name="sexe" type="xsd:string" /> </xsd:complexType> </xsd:element>
www.openclassrooms.com
83/209
Cet extrait signifie que la balise <personne /> qui possde l'attribut sexe, contient les balises <nom /> et <prenom /> dans cet ordre. Illustrons alors cet exemple : Code : XML <!-- valide --> <personne sexe="masculin"> <nom>DUPONT</nom> <prenom>Robert</prenom> </personne> <!-- invalide => les balises nom et prenom sont inverses --> <personne sexe="masculin"> <prenom>Robert</prenom> <nom>DUPONT</nom> </personne>
Le type all
Le type all est utilis lorsque l'on veut spcifier que les lments contenu dans un type complexe peuvent apparatre dans n'importe quel ordre. Ils doivent cependant tous apparatre une et une seule fois. V oici comment se dclare le type all au niveau d'un Schma XML : Code : XML <xsd:element name="mon_nom"> <xsd:complexType> <xsd:all> <!-- liste des lments --> </xsd:all> <!-- listes des attributs --> </xsd:complexType> </xsd:element>
V oyons tout de suite un exemple : Code : XML <xsd:element name="personne"> <xsd:complexType> <xsd:all> <xsd:element name="nom" type="xsd:string"/> <xsd:element name="prenom" type="xsd:string"/> </xsd:all> </xsd:complexType> </xsd:element>
Cet extrait signifie donc que la balise <personne /> contient les balises <nom /> et <prenom /> dans n'importe quel ordre. Illustrons alors cet exemple :
www.openclassrooms.com
84/209
Le choix
Un choix est utilis lorsque l'on veut spcifier qu'un lment contenu dans un type complexe soit choisi dans une liste prdfinie. V oici comment se dclare un choix au niveau d'un Schma XML : Code : XML <xsd:element name="mon_nom"> <xsd:complexType > <xsd:choice> <!-- liste des lments --> </xsd:choice> <!-- listes des attributs --> </xsd:complexType> </xsd:element>
V oyons sans plus tarder un exemple : Code : XML <xsd:element name="personne"> <xsd:complexType> <xsd:choice> <xsd:element name="nom" type="xsd:string"/> <xsd:element name="prenom" type="xsd:string"/> </xsd:choice> </xsd:complexType> </xsd:element>
Cet extrait signifie donc que la balise <personne /> contient soit la balise <nom />, soit <prenom />. Illustrons cet exemple : Code : XML <!-- valide --> <personne sexe="masculin"> <nom>DUPONT</nom> </prenom> <!-- valide --> <personne sexe="masculin">
www.openclassrooms.com
85/209
Ce document XML permet d'identifier une personne via son nom et son prnom. V oyons alors le Schma XML qui dfinit notre document XML : Code : XML <?xml version="1.0" encoding="UTF-8"?> <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <xsd:element name="personne"> <xsd:complexType> <xsd:sequence> <xsd:element name="identite"> <xsd:complexType> <xsd:sequence> <xsd:element name="nom" type="xsd:string"/> <xsd:element name="prenom" type="xsd:string"/> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:schema>
En soit, il n'y a rien de compliqu. Il convient juste de reprer que lorsque l'on place un lment complexe au sein d'un autre lment complexe, dans notre cas, une identit dans une personne, il convient d'utiliser une squence, un choix ou un type all .
www.openclassrooms.com
86/209
Un exemple
Afin d'illustrer cette dfinition, je vous propose de nous appuyer sur un exemple : Code : XML <balise1> Ceci est une chane de caractres <balise2>10</balise2> 7.5 </balise1>
Du ct du Schma XML
La syntaxe
Pour dclarer un lment complexe au contenu mixte, voici la syntaxe utiliser : Code : XML <xsd:element name="mon_nom"> <xsd:complexType mixed="true"> <!-- liste des lments --> </xsd:complexType> <!-- liste des attributs --> </xsd:element>
Un exemple
Prenons l'exemple d'une facture fictive dans laquelle on souhaite identifier l'acheteur et la somme qu'il doit payer. Code : XML <facture><acheteur>Zozor</acheteur>, doit payer <somme>1000</somme> .</facture>
V oici comment le traduire au sein d'un Schma XML : Code : XML <xsd:element name="facture"> <xsd:complexType mixed="true"> <xsd:sequence> <xsd:element name="acheteur" type="xsd:string" /> <xsd:element name="somme" type="xsd:int" /> </xsd:sequence> </xsd:complexType> </xsd:element>
Comme vous pouvez le remarquer, j'ai utilis la balise <xsd:sequence /> pour encapsuler la liste des balises contenues
www.openclassrooms.com
87/209
dans la balise <facture />, mais vous pouvez bien videmment adapter votre cas de figure et choisir parmi les balises que nous avons vu dans le chapitre prcdent, savoir : <xsd:sequence />. <xsd:all />. <xsd:choice />. Un lment complexe est un lment qui contient d'autres lments ou des attributs. Un lment complexe est dcrit grce la balise<xsd:complexType />. Un lment complexe a 3 types de contenus possibles : les contenus simples , "standards" et mixtes .
www.openclassrooms.com
88/209
Le nombre d'occurrences
Dans le chapitre prcdent, nous avons vu comment crire des lments de type complexe. Je peux maintenant vous avouer que je vous ai cach quelques petites choses. Nous allons les dcouvrir ensemble ds prsent. La premire concerne le nombre doccurrences d'une balise. Pour vous aider bien comprendre cette notion, je vous propose d'tudier un morceau de Schma XML que nous avons dj vu. Il s'agit de celui d'une personne qui possde un nom et un prnom : Code : XML <xsd:complexType name="personne"> <xsd:sequence> <xsd:element name="nom" type="xsd:string"/> <xsd:element name="prenom" type="xsd:string"/> </xsd:sequence> </xsd:complexType>
Comme je vous le disais prcdemment, cet extrait signifie que la balise <personne /> contient les balises <nom /> et <prenom /> dans cet ordre. La notion d'occurrence va nous permettre de prciser si les balises, dans le cas de notre exemple <nom /> et <prenom />, peuvent apparatre plusieurs fois, voire pas du tout.
Exemple
Je vous propose de terminer ce chapitre en l'illustrant par un exemple. Code : XML <xsd:complexType name="personne">
www.openclassrooms.com
89/209
Dans l'extrait de Schma XML ci-dessus, on remarque que pour l'lment prenom, le nombre minimum d'occurrences est 2 tandis qu'il n'y a pas de maximum. Cela signifie, que dans notre fichier XML, cette balise devra apparatre entre 2 et une infinit de fois comme en tmoigne les extraits de fichier XML suivants : Code : XML <personne> <nom>Zozor</nom> <prenom>Robert</prenom> <prenom>Bernard</prenom> </personne> <personne> <nom>Zozor</nom> <prenom>Robert</prenom> <prenom>Bernard</prenom> <prenom>Paul</prenom> <prenom>Pierre</prenom> </personne>
www.openclassrooms.com
90/209
Ce document XML reprsente une banque et ses clients. Pour chaque client, on connat son identit, le montant de son livret A ainsi que le montant de son compte courant. Avec nos connaissances actuelles, voici ce quoi ressemble le Schma XML qui dcrit ce document XML : Code : XML <?xml version="1.0" encoding="UTF-8"?> <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <xsd:element name="banque"> <xsd:complexType > <xsd:sequence> <xsd:element name="client"> <xsd:complexType> <xsd:sequence> <xsd:element name="identite" maxOccurs="unbounded" > <xsd:complexType> <xsd:sequence> <xsd:element name="nom" type="xsd:string" /> <xsd:element name="prenom" type="xsd:string" /> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="comptes"> <xsd:complexType> <xsd:sequence> <xsd:element name="livretA"> <xsd:complexType> <xsd:sequence> <xsd:element name="montant" type="xsd:double" /> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="courant"> <xsd:complexType> <xsd:sequence> <xsd:element name="montant" type="xsd:double" /> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:schema>
Cette construction d'un seul bloc, galement appel construction "en poupes russes" n'est pas des plus lisibles. Afin de rendre notre Schma XML un peu plus clair et comprhensible, je vous propose de le diviser. Sa lecture en sera grandement facilite.
www.openclassrooms.com
91/209
Dans cette partie nous allons voir comment "casser" cette criture "en poupes russes" afin de rendre notre Schma XML plus comprhensible et plus accessible. L'ide est assez simple dans son ensemble. On dclare de manire globale les diffrents lments qui composent notre Schma XML, puis, dans nos structures complexes, on y fait rfrence.
La syntaxe
La dclaration d'un lment ne change pas par rapport ce que nous avons vu jusqu' maintenant, qu'il s'agisse d'un lment simple ou d'un lment complexe. tablir une rfrence est alors trs simple grce au mot clef ref : Code : XML <xsd:element ref="mon_nom" />
Je vous propose d'illustrer l'utilisation de ce nouveau mot clef via un exemple. Nous allons dcomposer l'identit d'un client. Pour rappel, voici ce que nous avons crit dans notre premier essai : Code : XML <xsd:element name="identite" maxOccurs="unbounded" > <xsd:complexType> <xsd:sequence> <xsd:element name="nom" type="xsd:string" /> <xsd:element name="prenom" type="xsd:string" /> </xsd:sequence> </xsd:complexType> </xsd:element>
Nous allons donc faire une dclaration globale des lments nom et prenom afin d'y faire rfrence dans l'lment complexe identite. Code : XML <!-- dclaration globale de certains lments --> <xsd:element name="nom" type="xsd:string" /> <xsd:element name="prenom" type="xsd:string" /> <xsd:element name="identite" maxOccurs="unbounded" > <xsd:complexType> <xsd:sequence> <xsd:element ref="nom" /> <xsd:element ref="prenom" /> </xsd:sequence> </xsd:complexType> </xsd:element>
Comme vous pouvez le constater, l'ensemble est dj plus lisible. Cette mthode nous permet galement de rutiliser des lments qui reviennent plusieurs fois comme par exemple l'lment montant prsent dans le compte courant et le livret A d'un client.
www.openclassrooms.com
92/209
Comme vous pouvez le constater, c'est mieux, mais selon moi, ce n'est pas encore a. Plutt que de dclarer globalement uniquement des lments simples comme le montant , le nom ou le prenom, pourquoi ne pas dclarer globalement des lments complexes comme l'identit du client ou encore le livret A ou le compte courant. V oyons alors le rsultat : Code : XML <?xml version="1.0" encoding="UTF-8"?> <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
www.openclassrooms.com
93/209
www.openclassrooms.com
94/209
La syntaxe
Dclarer un nouveau type, n'est pas plus compliqu que ce que nous avons vu jusqu' prsent. Il est cependant important de noter une petite chose. Les types que nous allons crer peuvent tre de 2 natures : simple ou complexe. Dbutons avec la cration et l'utilisation d'un type simple. La cration d'un type simple est utile lorsque par exemple dans un Schma XML, plusieurs chanes de caractres ou plusieurs nombres ont des restrictions similaires. Code : XML <!-- cration --> <xsd:simpleType name="mon_type_perso"> <xsd:restriction base="mon_type"> <!-- liste des restrictions --> </xsd:restriction> </xsd:simpleType> <!-- utilisation--> <xsd:element name="mon_nom" type="mon_type_perso" />
Continuons avec la cration et l'utilisation d'un type complexe : Code : XML <!-- cration --> <xsd:ComplexeType name="mon_type_perso"> <!-- personnalisation du type complexe --> </xsd:ComplexeType> <!-- utilisation--> <xsd:element name="mon_nom" type="mon_type_perso" />
www.openclassrooms.com
95/209
L'hritage
L'hritage est un concept que l'on retrouve dans la plupart des langages de programmation orient objet. Certes le XML n'est pas un langage de programmation, mais a ne l'empche pas d'assimiler cette notion. Pour faire simple, l'hritage permet de rutiliser des lments d'un Schma XML pour en construire de nouveaux. Si vous avez encore du mal comprendre le concept, ne vous inquitez pas, nous allons utiliser des exemples afin de l'illustrer. En XML, 2 types d'hritages sont possibles : Par restriction. Par extension. Dans les 2 cas, c'est le mot clef base que nous utiliserons pour indiquer un hritage.
Dfinition
Une restriction est une notion qui peut s'appliquer aussi bien aux lments qu'aux attributs et qui permet de dterminer plus prcisment la valeur attendue via la dtermination d'un certain nombre de contraintes. Par exemple, jusqu' maintenant, nous sommes capables de dire qu'un lment ou qu'un attribut doit contenir un nombre entier strictement positif. Grce aux restrictions , nous allons pouvoir pousser le concept jusqu'au bout en indiquant qu'un lment qu'un attribut doit contenir un nombre entier strictement positif compris entre 1 et 100. Lorsque l'on dclare une restriction sur un lment, la syntaxe suivante doit tre respecte :
www.openclassrooms.com
96/209
La syntaxe est quasiment identique dans le cas d'un attribut : Code : XML <xsd:attribute name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base"> <!-- dtail de la restriction --> </xsd:restriction> </xsd:simpleType> </xsd:attribute>
V ous avez trs probablement remarqu l'attribut base dans la balise <restriction />. Il s'agit du type de votre balise et donc de votre restriction. Il suffit donc de choisir un type simple dans la liste de ceux que nous avons vu dans les chapitres prcdents (xsd:string, xsd:int, etc.).
Le tableau rcapitulatif
Nom de la restriction minExclusive minInclusive maxExclusive maxInclusive totalDigits fractionDigits length minLength maxLength enumeration whiteSpace pattern Description permet de dfinir une valeur minimale exclusive permet de dfinir une valeur minimale inclusive permet de dfinir une valeur maximale exclusive permet de dfinir une valeur maximale inclusive permet de dfinir le nombre exact de chiffres qui composent un nombre permet de dfinir le nombre de chiffres autoriss aprs la virgule permet de dfinir le nombre exact de caractres d'une chane permet de dfinir le nombre minimum de caractres d'une chane permet de dfinir le nombre maximum de caractres d'une chane permet d'numrer la liste des valeurs possibles permet de dterminer le comportement adopter avec les espaces permet de dfinir des expressions rationnelles
Plus en dtails
Pour dcrire la syntaxe des diffrentes restrictions, je vais m'appuyer sur la balise <xsd:element />, mais n'oubliez pas que toutes les rgles que nous voyons dans ce chapitre sont galement valables pour la balise <xsd:attribute />.
www.openclassrooms.com
97/209
La restriction minExclusive
La restriction minExclusive s'applique un lment de type numrique et permet de dfinir sa valeur minimale. Comme son nom le laisse deviner, la valeur indique est exclue des valeurs que peut prendre l'lment. V oici sa syntaxe : Code : XML <xsd:element name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base"> <xsd:minExclusive value="ma_valeur" /> </xsd:restriction> </xsd:simpleType> </xsd:element>
Afin d'illustrer cette premire restriction, prenons par exemple l'ge d'une personne que l'on souhaite obligatoirement majeure : Code : XML <xsd:complexType name="personne"> <xsd:attribute name="age"> <xsd:simpleType> <xsd:restriction base="xsd:nonNegativeInteger"> <xsd:minExclusive value="17" /> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:complexType>
Code : XML <!-- valide --> <personne age="18" /> <!-- valide --> <personne age="43" /> <!-- invalide --> <personne age="17" />
La restriction minInclusive
La restriction minInclusive ressemble normment la restriction minExclusive que nous venons de voir si ce n'est que la valeur indique peut-tre prise par l'lment. V oici sa syntaxe : Code : XML <xsd:element name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base">
www.openclassrooms.com
98/209
La restriction maxExclusive
La restriction maxExclusive s'applique un lment de type numrique et permet de dfinir sa valeur maximale. Comme son nom le laisse deviner, la valeur indique est exclue des valeurs que peut prendre l'lment. V oici sa syntaxe : Code : XML <xsd:element name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base"> <xsd:maxExclusive value="ma_valeur" /> </xsd:restriction> </xsd:simpleType> </xsd:element>
La restriction maxInclusive
La restriction maxInclusive ressemble normment la restriction maxExclusive que nous venons de voir si ce n'est que la valeur indique peut-tre prise par l'lment. V oici sa syntaxe : Code : XML <xsd:element name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base"> <xsd:maxInclusive value="ma_valeur" /> </xsd:restriction> </xsd:simpleType> </xsd:element>
La restriction totalDigits
La restriction totalDigits s'applique un lment de type numrique et permet de dfinir le nombre exact de chiffres qui composent le nombre. Sa valeur doit obligatoirement tre suprieure zro. V oici sa syntaxe : Code : XML <xsd:element name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base"> <xsd:totalDigits value="ma_valeur" /> </xsd:restriction> </xsd:simpleType> </xsd:element>
www.openclassrooms.com
99/209
Je vous propose d'illustrer tout de suite cette restriction avec un exemple. Une nouvelle fois prenons l'ge d'une personne. Imaginons un contexte dans lequel l'ge d'une personne doit obligatoirement tre compris entre 10 et 99. Il doit donc tre obligatoirement compos de 2 chiffres : Code : XML <xsd:complexType name="personne"> <xsd:attribute name="age"> <xsd:simpleType> <xsd:restriction base="xsd:nonNegativeInteger"> <xsd:totalDigits value="2" /> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:complexType>
Code : XML <!-- valide --> <personne age="18" /> <!-- valide --> <personne age="43" /> <!-- invalide --> <personne age="4" />
La restriction fractionDigits
La restriction fractionDigits s'applique un lment de type numrique et permet de dfinir le nombre maximal de chiffres qui composent une dcimale. Sa valeur peut-tre suprieure ou gale zro. V oici sa syntaxe : Code : XML <xsd:element name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base"> <xsd:fractionDigits value="ma_valeur" /> </xsd:restriction> </xsd:simpleType> </xsd:element>
La restriction length
La restriction length permet de dfinir le nombre exact de caractres qui composent une chane. La valeur renseigne doit obligatoirement tre suprieure ou gale zro. V oici sa syntaxe : Code : XML <xsd:element name="mon_nom"> <xsd:simpleType>
www.openclassrooms.com
100/209
Pour illustrer l'utilisation de la La restriction length, prenons par exemple une empreinte SHA1. Pour faire simple, une empreinte SHA1 est un nombre hexadcimal compos de 40 caractres : Code : XML <xsd:complexType name="sha1"> <xsd:simpleType> <xsd:restriction base="xsd:hexBinary"> <xsd:length value="40" /> </xsd:restriction> </xsd:simpleType> </xsd:complexType>
Code : XML <!-- valide --> <sha1>edf7a6029d6bdfb68447677a1d76639725f795f1</sha1> <!-- valide --> <sha1>a94a8fe5ccb19ba61c4c0873d391e987982fbbd3</sha1> <!-- invalide --> <sha1>test</sha1>
La restriction minLength
La restriction minLength permet de dfinir le nombre minimum de caractres qui composent une chane. La valeur renseigne doit obligatoirement tre suprieure ou gale zro. V oici sa syntaxe : Code : XML <xsd:element name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base"> <xsd:minLength value="ma_valeur" /> </xsd:restriction> </xsd:simpleType> </xsd:element>
La restriction maxLength
La restriction maxLength permet de dfinir le nombre maximum de caractres qui composent une chane. La valeur renseigne doit obligatoirement tre suprieure ou gale zro. V oici sa syntaxe : Code : XML
www.openclassrooms.com
101/209
La restriction enumeration
La restriction enumeration, comme son nom le laisse deviner, cette restriction permet d'numrer la liste des valeurs possibles pour un lment ou un attribut. V oici sa syntaxe : Code : XML <xsd:element name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base"> <xsd:enumeration value="valeur1" /> <xsd:enumeration value="valeur2" /> <!-- liste des valeurs... --> </xsd:restriction> </xsd:simpleType> </xsd:element>
Afin d'illustrer cette restriction, prenons l'exemple d'une personne comme nous l'avons dj fait plusieurs reprises dans ce tutoriel. Une personne possde un nom, un prnom, et est normalement un homme ou une femme. crivons alors la rgle d'un Schma XML permettant de dcrire une personne : Code : XML <xsd:complexType name="personne"> <xsd:sequence> <xsd:element name="nom" type="xsd:string"/> <xsd:element name="prenom" type="xsd:string"/> </xsd:sequence> <xsd:attribute name="sexe"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:enumeration value="masculin" /> <xsd:enumeration value="feminin" /> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:complexType>
Code : XML <!-- valide --> <personne sexe="masculin"> <nom>DUPONT</nom> <prenom>Robert</prenom> </personne> <!-- valide -->
www.openclassrooms.com
102/209
La restriction whiteSpace
La restriction whiteSpace permet de spcifier le comportement adopter par un lment lorsqu'il contient des espaces. Les espaces peuvent tre de diffrentes formes comme par exemple les tabulations, les retours la ligne, etc. 3 valeurs sont possibles : Preserve : cette valeur permet de prserver tous les espaces. Replace : cette valeur permet de remplacer tous les espaces (tabulations, retour la ligne, etc.) par des espaces "simples". Collapse : cette valeur permet de supprimer les espaces en dbut et fin de chane, de remplacer les tabulations et les retours la ligne par un espace "simple" et de remplacer les espaces multiples par un espace "simple".
V oici sa syntaxe : Code : XML <xsd:element name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base"> <xsd:whiteSpace value="ma_valeur" /> </xsd:restriction> </xsd:simpleType> </xsd:element>
La restriction pattern
La restriction pattern permet de dfinir des expressions rationnelles (galement appeles expressions rgulires). Une expression rationnelle est un motif qui permet de dcrire le contenu attendu. Ainsi l'aide des expressions rationnelles, il est possible de dire que le contenu attendu doit forcment dbuter par une majuscule, se terminer un point, dbuter par un caractre spcial, ne pas contenir la lettre "z", etc. Les expressions rationnelles sont un langage part entire sur lequel nous n'allons pas revenir dans ce cours, mais ne vous inquitez pas, vous trouverez facilement sur Internet de nombreuses ressources francophones sur le sujet. V oici sa syntaxe : Code : XML <xsd:element name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base"> <xsd:pattern value="ma_valeur" /> </xsd:restriction> </xsd:simpleType> </xsd:element>
www.openclassrooms.com
103/209
Afin d'illustrer cette dernire restriction, prenons l'exemple du prnom non compos d'une personne. On souhaite qu'il dbute par une majuscule et soit suivi par plusieurs caractres minuscules : Code : XML <xsd:complexType name="prenom"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:pattern value="[A-Z][a-z]+" /> </xsd:restriction> </xsd:simpleType> </xsd:complexType>
Code : XML <!-- valide --> <prenom>Robert</prenom> <!-- valide --> <prenom>Zozor</prenom> <!-- invalide --> <prenom>bernard</prenom>
Dfinition
Une extension est une notion qui permet d'ajouter des informations un type existant. On peut, par exemple, vouloir ajouter un lment ou un attribut. Lorsque l'on dclare une extension sur un lment, c'est toujours le mot clef "base" qui est utilis : Code : XML <!-- contenu complexe --> <xsd:complexType name="mon_nom"> <xsd:complexContent> <xsd:extension base="type_de_base"> <!-- dtail de l'extension --> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <!-- contenu simple --> <xsd:complexType name="mon_nom"> <xsd:simpleContent> <xsd:extension base="type_de_base"> <!-- dtail de l'extension --> </xsd:restriction> </xsd:complexContent> </xsd:complexType>
www.openclassrooms.com
104/209
Exemple
Je vous propose de mettre en application cette nouvelle notion d'hritage par extension au travers d'un exemple. Reprenons les donnes clientes d'une banque que nous manipulions dans le chapitre prcdent. Dans cette exemple, nous avions dfini un type " compte" appliqu au compte courant et au livret A de notre client : Code : XML <?xml version="1.0" encoding="UTF-8"?> <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <!-- dclaration des lments --> <xsd:element name="montant" type="xsd:double" /> <xsd:element name="identite" maxOccurs="unbounded" > <xsd:complexType> <xsd:sequence> <xsd:element name="nom" type="xsd:string" /> <xsd:element name="prenom" type="xsd:string" /> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:complexType name="compte"> <xsd:sequence> <xsd:element ref="montant" /> </xsd:sequence> </xsd:complexType> <xsd:element name="comptes"> <xsd:complexType> <xsd:sequence> <xsd:element name="livretA" type="compte" /> <xsd:element name="courant" type="compte" /> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="client"> <xsd:complexType> <xsd:sequence> <xsd:element ref="identite" /> <xsd:element ref="comptes" /> </xsd:sequence> </xsd:complexType> </xsd:element> <!-- Schma XML --> <xsd:element name="banque"> <xsd:complexType > <xsd:sequence> <xsd:element ref="client" /> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:schema>
Imaginons maintenant que le compte courant et le livret A soient un peu diffrents. Par exemple, un compte courant n'a gnralement pas de taux d'intrts tandis que le livret A en a un. Malgr ce petit changement, le livret A et le compte courant restent sensiblement identiques. C'est l que l'hritage par extension intervient. Nous allons tendre le type compte en y ajoutant un attribut pour crer ainsi un nouveau type : celui d'un compte avec des intrts. Code : XML <!-- le montant --> <xsd:element name="montant" type="xsd:double" />
www.openclassrooms.com
105/209
Les identifiants
Nous avons dj vu que dans un Schma XML, il est possible d'identifier des ressources et d'y faire rfrence grce aux mots clefs ID et IDREF. Il est cependant possible d'aller plus loin et d'tre encore plus prcis grce 2 nouveaux mots clefs : key et keyref . Pour bien comprendre la suite de chapitre, il est ncessaire de connatre le fonctionnement d'une technologie qu'on appelle XPath, technologie que nous aborderons en plus en dtail dans la prochaine partie. Pour le moment, retenez simplement que cette technologie nous permet de slectionner avec prcision des lments formant un document XML.
La syntaxe
L'lment key
Au sein d'un Schma XML, l'lment <key /> est compos : D'un lment <selector /> contenant une expression XPath afin d'indiquer l'lment rfrencer. D'un ou plusieurs lments <field /> contenant une expression XPath afin d'indiquer l'attribut servant d'identifiant. Ce qui nous donne : Code : XML <xsd:key name="nom_identifiant"> <selector xpath="expression_XPath" /> <!-- liste d'lments field --> <field xpath="expression_XPath" /> </xsd:key>
L'lment keyref
L'lment <keyref /> se construit sensiblement comme l'lment <key />. Il est donc compos : D'un lment <selector /> contenant une expression XPath afin d'indiquer l'lment rfrencer. D'un ou plusieurs lments <field /> contenant une expression XPath afin d'indiquer l'attribut servant d'identifiant.
www.openclassrooms.com
106/209
Exemple
Afin d'illustrer cette nouvelle notion, je vous propose de d'tudier le document XML suivant : Code : XML <famille> <pere id="PER-1" /> <enfant id="PER-2" pere="PER-1" /> </famille>
Dans cet exemple, une famille est compose d'un pre et d'un enfant dont chacun possde un identifiant unique au travers de l'attribut id. L'enfant possde galement un attribut pere qui contient l'identifiant de son pre. Je vous propose de construire ensemble le Schma XML correspond au document XML. Commenons par dcrire l'lment <pere /> : Code : XML <xsd:element name="pere"> <xsd:complexType> <xsd:attribut name="id" type="xsd:NCName" /> </xsd:complexType> </xsd:element>
Continuons avec l'lment <enfant /> : Code : XML <xsd:element name="enfant"> <xsd:complexType> <xsd:attribut name="id" type="xsd:NCName" /> <xsd:attribut name="pere" type="xsd:NCName" /> </xsd:complexType> </xsd:element>
Terminons avec l'lment <famille /> : Code : XML <xsd:element name="famille"> <xsd:complexType> <xsd:sequence> <xsd:element ref="pere" /> <xsd:element ref="enfant" /> </xsd:sequence>
www.openclassrooms.com
107/209
Modifions ce dernier lment afin d'y ajouter nos identifiants. Pour le moment, je vous demande d'accepter les expressions XPath prsentes dans le Schma XML. Dans la partie suivante, vous serez normalement en mesure de les comprendre. Code : XML <xsd:element name="famille"> <xsd:complexType> <xsd:sequence> <xsd:element ref="pere" /> <xsd:element ref="enfant" /> </xsd:sequence> </xsd:complexType> <!-- identifiant du pre --> <xsd:key name="pereId"> <xsd:selector xpath="./pere" /> <xsd:field xpath="@id" /> </xsd:key> <!-- identifiant de l'enfant --> <xsd:key name="enfantId"> <xsd:selector xpath="./enfant" /> <xsd:field xpath="@id" /> </xsd:key> > <!-- rfrence l'identifiant du pre dans l'lment enfant --
<xsd:key name="pereIdRef" refer="pereId"> <xsd:selector xpath="./enfant" /> <xsd:field xpath="@pere" /> </xsd:key> </xsd:element>
www.openclassrooms.com
108/209
Si vous essayez de lancer la vrification du document, vous devriez normalement avoir le message d'erreur suivant (voir la figure suivante).
Message d'erreur indiquant que le Schma XML est introuvable Ce message est pour le moment compltement normal puisque nous n'avons pas encore cr notre document XSD.
Cration d'un Schma XML V otre document XSD n'est normalement pas vierge. V oici ce que vous devriez avoir : Code : XML <?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
www.openclassrooms.com
109/209
Replacez le contenu par notre vritable Schma XML : Code : XML <?xml version="1.0" encoding="UTF-8"?> <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <!-- dclaration des lments --> <xsd:element name="montant" type="xsd:double" /> <xsd:element name="identite" > <xsd:complexType> <xsd:sequence> <xsd:element name="nom" type="xsd:string" /> <xsd:element name="prenom" type="xsd:string" /> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:complexType name="compte"> <xsd:sequence> <xsd:element ref="montant" /> </xsd:sequence> </xsd:complexType> <xsd:element name="comptes"> <xsd:complexType> <xsd:sequence> <xsd:element name="livretA" type="compte" /> <xsd:element name="courant" type="compte" /> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="client"> <xsd:complexType> <xsd:sequence> <xsd:element ref="identite" /> <xsd:element ref="comptes" /> </xsd:sequence> </xsd:complexType> </xsd:element> <!-- Schma XML --> <xsd:element name="banque"> <xsd:complexType > <xsd:sequence> <xsd:element ref="client" maxOccurs="unbounded" /> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:schema>
Enregistrez ensuite votre document avec le nom banque.xsd au mme endroit que votre document XML.
www.openclassrooms.com
110/209
Message indiquant que le document XML est valide Le nombre d'occurrences d'un lment s'exprime grce aux mots clefs minOccurs et maxOccurs . Le mot clef ref permet de faire rfrence des lments dans le but de les rutiliser plusieurs fois au sein du Schma XML. L'hritage permet de rutiliser des lments d'un Schma XML pour en construire de nouveaux. Il existe 2 types d'hritages : l'hritage par restriction et l'hritage par extension.
www.openclassrooms.com
111/209
L'nonc
Le but de ce TP est de crer le Schma XML du rpertoire que nous avons dj vu. Pour rappel, voici les informations que l'on souhaite connatre pour chaque personne : Son sexe (homme ou femme). Son nom. Son prnom. Son adresse. Un ou plusieurs numros de tlphone (tlphone portable, fixe, bureau, etc.). Une ou plusieurs adresses e-mail (adresse personnelle, professionnelle, etc.).
V oici le document XML que nous avions construit : Code : XML <?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <repertoire> <!-- John DOE --> <personne sexe="masculin"> <nom>DOE</nom> <prenom>John</prenom> <adresse> <numero>7</numero> <voie type="impasse">impasse du chemin</voie> <codePostal>75015</codePostal> <ville>PARIS</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="fixe">01 02 03 04 05</telephone> <telephone type="portable">06 07 08 09 10</telephone> </telephones> <emails> <email type="personnel">john.doe@wanadoo.fr</email> <email type="professionnel">john.doe@societe.com</email> </emails> </personne> <!-- Marie POPPINS --> <personne sexe="feminin"> <nom>POPPINS</nom> <prenom>Marie</prenom> <adresse> <numero>28</numero> <voie type="avenue">avenue de la rpublique</voie> <codePostal>13005</codePostal> <ville>MARSEILLE</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="bureau">04 05 06 07 08</telephone> </telephones> <emails> <email type="professionnel">contact@poppins.fr</email> </emails>
www.openclassrooms.com
112/209
Une solution
Comme chaque fois, je vous fais part de ma solution. Le fichier XML avec le Schma XML rfrenc : Code : XML <?xml version="1.0" encoding="UTF-8" standalone="no" ?> <repertoire xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="repertoire.xsd"> <!-- John DOE --> <personne sexe="masculin"> <nom>DOE</nom> <prenom>John</prenom> <adresse> <numero>7</numero> <voie type="impasse">impasse du chemin</voie> <codePostal>75015</codePostal> <ville>PARIS</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="fixe">01 02 03 04 05</telephone> <telephone type="portable">06 07 08 09 10</telephone> </telephones> <emails> <email type="personnel">john.doe@wanadoo.fr</email> <email type="professionnel">john.doe@societe.com</email> </emails> </personne> <!-- Marie POPPINS --> <personne sexe="feminin"> <nom>POPPINS</nom> <prenom>Marie</prenom> <adresse> <numero>28</numero> <voie type="avenue">avenue de la rpublique</voie> <codePostal>13005</codePostal> <ville>MARSEILLE</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="bureau">04 05 06 07 08</telephone> </telephones> <emails> <email type="professionnel">contact@poppins.fr</email> </emails> </personne> </repertoire>
Le fichier XSD : Code : XML <?xml version="1.0" encoding="UTF-8"?> <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <!-- balises isoles --> <xsd:element name="nom" type="xsd:string"/> <xsd:element name="prenom" type="xsd:string"/>
www.openclassrooms.com
113/209
www.openclassrooms.com
114/209
Un bref commentaire
Dans cette solution, je suis all au plus simple. Libre vous de crer de nouvelles rgles si vous souhaitez par exemple utiliser un pattern prcis pour les numros de tlphone ou les adresses e-mails.
www.openclassrooms.com
115/209
L'arbre XML
Dans le chapitre prcdent, je vous disais que DOM est une technologie compltement indpendante de toute plate-forme et langage de programmation et qu'elle se contente de fournir une manire d'exploiter les documents XML. En ralit, lorsque votre document XML est lu par un parseur DOM, le document est reprsent en mmoire sous la forme d'un arbre dans lequel les diffrents lments sont lis les uns aux autres par une relation parent/enfant. Il est ensuite possible de passer d'un lment un autre via un certain nombre de fonctions que nous verrons dans le chapitre suivant. Je vous propose d'illustrer cette notion d'arbre grce un exemple. Soit le document XML suivant : Code : XML <?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <repertoire> <!-- John DOE --> <personne sexe="masculin"> <nom>DOE</nom> <prenom>John</prenom> <telephones> <telephone type="fixe">01 02 03 04 05</telephone> <telephone type="portable">06 07 08 09 10</telephone> </telephones> </personne> </repertoire>
www.openclassrooms.com
116/209
Modlisation d'un arbre XML Pour bien comprendre quoi correspondent les couleurs et les formes, voici la lgende en figure suivante.
Lgende des icnes utilises dans l'arbre XML Dans nos futurs programmes c'est donc ce genre d'arbres que nous allons parcourir afin d'obtenir les informations que l'on souhaite exploiter en passant d'un lment un autre. Mais avant de voir comment procder, je vous propose de revenir sur le vocabulaire utilis par DOM.
www.openclassrooms.com
117/209
Lors de la description des diffrents lments, je vais tenter d'tre le plus neutre possible en me dtachant de tout langage de programmation. Cependant, des connaissances en programmation objet sont ncessaires pour comprendre ce chapitre.
Document
Dfinition
Le document comme son nom le laisse deviner dsigne le document XML dans son ensemble. Il est donc compos : Du prologue. Du corps .
La classe
Grce la classe Document nous allons pouvoir exploiter aussi bien le prologue que le corps de nos documents XML. Cette classe va galement se rvler indispensable lorsque nous allons vouloir crer ou modifier des documents XML. En effet, via les nombreuses mthodes proposes, nous allons pouvoir ajouter des lments, des commentaires, des attributs, etc.
Node
Dfinition
Un Node ou Nud en franais peut-tre vritablement considr comme l'lment de base d'un arbre XML. Ainsi, toute branche ou feuille est un nud. Un lment est donc un nud, tout comme une valeur et un attribut. Je vous propose de reprendre le schma vu prcdemment et de tenter d'identifier 3 nuds parmi tous ceux prsents (voir la figure suivante).
www.openclassrooms.com
118/209
Des nuds
La classe
La classe Node nous permet d'obtenir un certain nombre d'informations lors de l'exploitation d'un document XML. Ainsi, il est possible d'obtenir le type du nud (attribut, valeur, etc.) son nom, sa valeur, la liste des nuds fils, le nud parent, etc. Cette classe propose galement un certain nombre de mthodes qui vont nous aider crer et modifier un document XML en offrant par exemple la possibilit de supprimer un nud, ou d'en remplacer un par un autre, etc.
Element
Dfinition
Un Element reprsente une balise d'un document XML. Si l'on reprend le schma de l'arbre XML du dessus, les lments sont en bleu.
La classe
La classe Element, en plus de nous fournir le nom de la balise, nous offre de nombreuses fonctionnalits comme par exemple la possibilit de rcuprer les informations d'un attribut ou encore de rcuprer la listes des noeuds d'un lment portant un nom spcifique.
Attr
www.openclassrooms.com
119/209
Dfinition
Un Attr dsigne un attribut. Si l'on reprend le schma de l'arbre XML du dessus, les attributs sont en orange.
La classe
La classe Attr, permet d'obtenir un certain nombre d'information concernant les attributs comme son nom ou encore sa valeur. Cette classe va galement nous tre utile lorsque l'on voudra crer ou modifier des documents XML.
Text
Dfinition
Un Text dsigne le contenu d'une balise. Si l'on reprend le schma de l'arbre XML du dessus, ils sont en vert.
La classe
En plus de la donne textuelle, la classe Text, permet de facilement modifier un document XML en proposant par exemple des mthodes de suppression ou de remplacement de contenu.
www.openclassrooms.com
120/209
Cette ligne de code s'accompagne de l'importation du package : Code : Java import javax.xml.parsers.DocumentBuilderFactory;
www.openclassrooms.com
121/209
Pour pouvoir utiliser la classe DocumentBuilder, le package suivant est ncessaire : Code : Java import javax.xml.parsers.DocumentBuilder;
Puisque l'appel la fonction newDocumentBuilder(), peut lever une exception, il convient de le placer dans un bloc de type try/catch : Code : Java try { final DocumentBuilder builder = factory.newDocumentBuilder(); } catch (final ParserConfigurationException e) { e.printStackTrace(); }
La gestion de cette exception oblige galement importer le package : Code : Java import javax.xml.parsers.ParserConfigurationException;
Comme chaque nouvelle instruction, des packages doivent tre imports : Code : Java import java.io.File; import org.w3c.dom.Document;
De nouvelles exceptions pouvant tre leves, il convient galement de modifier leurs captures dans des blocs catch. V oici alors
www.openclassrooms.com
122/209
La gestion de ces nouvelles exceptions nous oblige galement importer quelques packages : Code : Java import java.io.IOException; import org.xml.sax.SAXException;
Comme je vous le disais dans le chapitre prcdent, un Document reprsente le document XML dans son intgralit. Il contient son prologue et son corps . Nous allons pouvoir le vrifier en affichant les lments du prologue, savoir : La version XML utilise. L'encodage utilis. S'il s'agit d'un document "standalone" ou non. Code : Java //Affiche la version de XML System.out.println(document.getXmlVersion()); //Affiche l'encodage System.out.println(document.getXmlEncoding()); //Affiche s'il s'agit d'un document standalone System.out.println(document.getXmlStandalone());
A l'excution du programme, voici ce que vous devriez avoir l'cran : Code : Console UTF-8 1.0 true
Si l'on compare cet affichage au prologue du document XML, on se rend compte que les informations correspondent bien.
www.openclassrooms.com
123/209
Une nouvelle fois, pour pouvoir utiliser la classe Element, le package suivant doit tre import : Code : Java import org.w3c.dom.Element;
Nous pouvons ds maintenant vrifier que ce que nous venons de rcuprer est bien l'lment racine de notre document en affichant son nom : Code : Java System.out.println(racine.getNodeName());
Aprs excution du programme, voici ce que vous devriez avoir l'cran : Code : Console repertoire
www.openclassrooms.com
124/209
Nous pouvons galement nous amuser afficher le nom de chacun des nuds via le code suivant : Code : Java final int nbRacineNoeuds = racineNoeuds.getLength(); for (int i = 0; i<nbRacineNoeuds; i++) { System.out.println(racineNoeuds.item(i).getNodeName()); }
V ous devriez alors avoir le rsultat suivant : Code : Console #text #comment #text personne #text
On retrouve bien notre balise <personne /> au milieu d'autres nuds de type text et comment. Nous allons maintenant lgrement modifier notre boucle afin de n'afficher l'cran que les nuds tant des lments. Grce la mthode getNodeType() de la classe Node : Code : Java for (int i = 0; i<nbRacineNoeuds; i++) { if(racineNoeuds.item(i).getNodeType() == Node.ELEMENT_NODE) { final Node personne = racineNoeuds.item(i); System.out.println(personne.getNodeName()); } }
A l'excution de votre programme, vous devriez normalement avoir le rsultat suivant : Code : Console personne
A noter : si vous avions voulu rcuprer le commentaire, nous aurions compar le type de notre nud la constante Node.COMMENT_NODE. Avant de passer l'affichage de la suite du document XML, nous allons tenter d'afficher le sexe de la personne, qui pour rappel est un attribut. Il existe plusieurs manires de faire plus ou moins gnriques. La mthode la plus gnrique est de faire appelle la mthode getAttributes() de la classe Node qui nous renvoie l'ensemble des attributs du nud. Dans notre cas, nous allons utiliser la mthode getAttribute(nom) qui nous renvoie la valeur de l'attribut spcifi en paramtre. Cette mthode n'est cependant pas accessible partir de la classe Node, il convient donc de "caster" notre nud en un Element pour pouvoir l'appeler : Code : Java
www.openclassrooms.com
125/209
A l'cran devrait alors s'afficher le rsultat suivant : Code : Console personne sexe : masculin
Ainsi, nous venons de rcuprer tous les lments d'une personne ayant pour nom "nom". Dans notre cas, nous savons qu'une personne ne peut avoir qu'un seul prnom, nous pouvons donc prciser que nous voulons le premier lment de la liste : Code : Java final Element nom = (Element) personne.getElementsByTagName("nom").item(0);
Finalement, si l'on souhaite afficher le Text de la balise, il nous suffit d'appeler la mthode getTextContent() : Code : Java System.out.println(nom.getTextContent());
V ous devriez alors voir s'afficher l'cran le nom de la seule personne dclare dans notre document XML : Code : Console DOE
www.openclassrooms.com
126/209
V ous devriez alors voir s'afficher l'cran la liste des numros de tlphones : Code : Console fixe : 01 02 03 04 05 portable : 06 07 08 09 10
Le code complet
Nous venons donc de lire ensemble notre premier document XML ! Pour ceux qui en auraient besoin, vous trouverez le code complet du petit programme que nous venons d'crire juste en dessous : Code : Java import java.io.File; import java.io.IOException; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import import import import import org.w3c.dom.Document; org.w3c.dom.Element; org.w3c.dom.Node; org.w3c.dom.NodeList; org.xml.sax.SAXException;
public class ReadXMLFile { public static void main(final String[] args) { /* * Etape 1 : rcupration d'une instance de la classe "DocumentBuilderFactory" */ final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
www.openclassrooms.com
127/209
final Element personne = (Element) racineNoeuds.item(i); //Affichage d'une personne System.out.println("\n*************PERSONNE************"); System.out.println("sexe : " + personne.getAttribute("sexe")); /* * Etape 6 : rcupration du nom et du prnom */ final Element nom = (Element) personne.getElementsByTagName("nom").item(0); final Element prenom = (Element) personne.getElementsByTagName("prenom").item(0); //Affichage du nom et du prnom System.out.println("nom : " + nom.getTextContent()); System.out.println("prnom : " + prenom.getTextContent()); /* * Etape 7 : rcupration des numros de tlphone */ final NodeList telephones = personne.getElementsByTagName("telephone"); final int nbTelephonesElements = telephones.getLength(); for(int j = 0; j<nbTelephonesElements; j++) { final Element telephone = (Element) telephones.item(j); //Affichage du tlphone System.out.println(telephone.getAttribute("type") + " : " +
www.openclassrooms.com
128/209
www.openclassrooms.com
129/209
Cette ligne de code s'accompagne de l'importation du package suivant : Code : Java import javax.xml.parsers.DocumentBuilder;
Bien que nous l'ayons dj vu dans le chapitre prcdent, n'oubliez pas qu'une exception peut tre leve, c'est pourquoi cette instruction doit tre place dans un bloc de type try/catch : Code : Java try { final DocumentBuilder builder = factory.newDocumentBuilder(); } catch (final ParserConfigurationException e) { e.printStackTrace(); }
La gestion de cette exception nous oblige galement importer le package suivant : Code : Java import javax.xml.parsers.ParserConfigurationException;
Pour pouvoir utiliser la classe Document, n'oubliez pas d'importer le package suivant : Code : Java import org.w3c.dom.Document;
www.openclassrooms.com
130/209
A noter que l'utilisation de la classe Element s'accompagne de l'importation du package : Code : Java import org.w3c.dom.Element;
Maintenant que notre lment racine est dclar, nous pouvons l'ajouter notre document : Code : Java document.appendChild(racine);
Pour pouvoir dclarer un commentaire, n'oubliez pas d'importer le package suivant : Code : Java import org.w3c.dom.Comment;
Il convient ensuite d'ajouter notre commentaire la suite de notre document et plus spcifiquement la suite de notre lment racine. Si l'on se rfre l'arbre XML, le commentaire est rellement un sous lment de l'lment racine. C'est pourquoi celui-ci est ajout en tant qu'enfant de l'lment racine : Code : Java racine.appendChild(commentaire);
www.openclassrooms.com
131/209
Nous pouvons maintenant nous attaquer la cration de la balise <personne />. Il s'agit d'un lment au mme titre que l'lment racine que nous avons dj vu. Puisque la balise est au mme niveau que le commentaire, il convient de l'ajouter en tant qu'enfant de l'lment racine : Code : Java final Element personne = document.createElement("personne"); racine.appendChild(personne);
Si l'on s'arrte ici, on omet d'ajouter l'attribut "sexe" pourtant prsent dans la balise <personne /> du document XML que l'on souhaite crer. Ajouter un attribut un lment est en ralit trs simple et se fait via la mthode setAttribute() de la classe Element. Cette mthode prend 2 paramtres : le nom de l'attribut et sa valeur. Code : Java personne.setAttribute("sexe", "masculin");
Ici, La nouveaut concerne le renseignement de la valeur contenu dans les balises, savoir John DOE dans notre exemple. Pour ce faire, il convient d'ajouter nos balises un enfant de type Text. Cet enfant doit tre cr avec la mthode createTextNode() du document qui prend en paramtre la valeur : Code : Java nom.appendChild(document.createTextNode("DOE")); prenom.appendChild(document.createTextNode("John"));
www.openclassrooms.com
132/209
Ne vous inquitez pas, les 2 possibilits seront abordes dans ce tutoriel. Pour pouvoir afficher notre document XML, nous allons avoir besoin de plusieurs objets Java. Le premier est une instance de la classe TransformerFactory : Code : Java final TransformerFactory transformerFactory = TransformerFactory.newInstance();
La rcupration de cette instance s'accompagne de l'importation du package suivant : Code : Java import javax.xml.transform.TransformerFactory;
Nous allons utiliser cette instance pour crer un objet Transformer. C'est grce lui que nous pourrons afficher notre document XML par la suite : Code : Java final Transformer transformer = transformerFactory.newTransformer();
A noter que la fonction newTransformer() peut lever une exception de type TransformerConfigurationException qu'il est important de capturer via un bloc catch. N'oubliez pas d'importer les packages suivants : Code : Java import javax.xml.transform.Transformer; import javax.xml.transform.TransformerConfigurationException;
Pour afficher le document XML, nous utiliserons la mthode transform() de notre transformer. Cette mthode prend en compte 2 paramtres :
www.openclassrooms.com
133/209
A noter qu'une exception de type TransformerConfiguration est susceptible d'tre leve : Code : Java import javax.xml.transform.TransformerException;
En ce qui nous concerne, la source que l'on souhaite afficher est notre document XML. Cependant, nous ne pouvons pas passer notre objet document tel quel. Il convient de le transformer lgrement sous la forme d'un objet DOMSource : Code : Java final DOMSource source = new DOMSource(document);
Pour pouvoir utiliser cette classe, il convient d'importer le package suivant : Code : Java import javax.xml.transform.dom.DOMSource;
Maintenant que nous avons la source, occupons nous de la sortie. La sortie est en ralit un objet StreamResult. C'est ici que nous allons prciser si nous souhaitons afficher notre document dans un fichier ou dans la console de notre IDE : Code : Java //Code utiliser pour afficher dans un fichier final StreamResult sortie = new StreamResult(new File("F:\\file.xml")); //Code utiliser pour afficher dans la console final StreamResult sortie = new StreamResult(System.out);
Encore une fois, l'importation d'un package est ncessaire : Code : Java import javax.xml.transform.stream.StreamResult;
Avant d'excuter notre programme, il nous reste encore quelques petits dtails rgler : l'criture du prologue et le formatage de l'affichage.
www.openclassrooms.com
134/209
Commenons par le prologue. Nous allons renseigner ses diffrentes proprits via la mthode setOutputProperty() de notre transformer qui prend en paramtre le nom du paramtre et sa valeur : Code : Java transformer.setOutputProperty(OutputKeys.VERSION, "1.0"); transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); transformer.setOutputProperty(OutputKeys.STANDALONE, "yes");
Pour pouvoir utiliser les constantes de la classe OutputKeys, il convient d'importer le package suivant : Code : Java import javax.xml.transform.OutputKeys;
Si nous excutons notre programme maintenant, tout sera crit sur une seule ligne, ce qui n'est pas trs lisible, vous en conviendrez. C'est pourquoi nous allons donner quelques rgles de formatage notre transformer. En effet, ce que l'on souhaite c'est que notre document soit indent. Chaque niveau diffrent de notre document XML sera alors dcal de 2 espaces : Code : Java transformer.setOutputProperty(OutputKeys.INDENT, "yes"); transformer.setOutputProperty("{http://xml.apache.org/xslt}indentamount", "2");
Le code complet
Nous venons donc de crer notre premier document XML ! Pour ceux qui en auraient besoin, vous trouverez le code complet du petit programme que nous venons d'crire juste en dessous : Code : Java import java.io.File; import import import import import import import import import import javax.xml.parsers.DocumentBuilder; javax.xml.parsers.DocumentBuilderFactory; javax.xml.parsers.ParserConfigurationException; javax.xml.transform.OutputKeys; javax.xml.transform.Transformer; javax.xml.transform.TransformerConfigurationException; javax.xml.transform.TransformerException; javax.xml.transform.TransformerFactory; javax.xml.transform.dom.DOMSource; javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Comment; import org.w3c.dom.Document; import org.w3c.dom.Element; public class ReadXMLFile { public static void main(final String[] args) { /* * Etape 1 : rcupration d'une instance de la classe "DocumentBuilderFactory" */ final DocumentBuilderFactory factory =
www.openclassrooms.com
135/209
www.openclassrooms.com
136/209
} catch (final ParserConfigurationException e) { e.printStackTrace(); } catch (TransformerConfigurationException e) { e.printStackTrace(); } catch (TransformerException e) { e.printStackTrace(); } }
V ous savez maintenant lire et crire un document XML grce l'implmentation Java de l'API DOM. Exceptionnellement, il n'y aura pas de TP sur cette technologie. En effet, DOM tant implment dans de nombreux langages de programmation, il est impossible pour moi de proposer une correction dans chacun des langages utiliss !
www.openclassrooms.com
137/209
Un peu de vocabulaire
Avant d'tudier de manire plus approfondie comment crire des expressions XPaths, il convient de revenir sur quelques notions de vocabulaire qui seront indispensables pour bien comprendre la suite du cours. Pour ce faire, je vous propose de reprendre un document XML que nous avons dj vu plusieurs fois dans ce cours et l'utiliser pour illustrer les notions que nous allons voir : Code : XML <?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <repertoire> <!-- John DOE --> <personne sexe="masculin"> <nom>DOE</nom> <prenom>John</prenom> <telephones> <telephone type="fixe">01 02 03 04 05</telephone> <telephone type="portable">06 07 08 09 10</telephone> </telephones> </personne> </repertoire>
www.openclassrooms.com
138/209
Parent
Le parent d'un nud est le nud qui est directement au dessus de lui d'un point de vue hirarchique. Chaque nud a au moins un parent. Par exemple, le nud repertoire est le parent du nud personne qui est lui mme le parent des noeuds nom, prenom et telephones .
Enfant
Un nud a pour enfants tous les noeuds situs un niveau en dessous dans la hirarchie. Un nud peut donc avoir une infinit d'enfants.
www.openclassrooms.com
139/209
Par exemple, le nud repertoire a pour enfant le nud personne qui a lui mme plusieurs enfants : les noeuds nom, prenom et telephones .
Descendant
Un nud a pour descendants tous les noeuds situs en dessous dans la hirarchie. Un nud peut donc avoir une infinit de descendants. Par exemple, le nud repertoire a pour descendants les nuds personne, nom, prenom et telephones .
Anctre
Un nud a pour anctres tous les noeuds situs en dessus dans la hirarchie. Un nud peut donc avoir plusieurs anctres. Par exemple, le nud telephones a pour anctres les nuds personne et repertoire.
Frre
Un nud a pour frres tous les noeuds situs au mme niveau dans la hirarchie. Un nud peut donc avoir une infinit de frres. Par exemple, le nud nom a pour frres les nuds prenom et telephones .
www.openclassrooms.com
140/209
Arbre XML d'un document XML Si je veux rcuprer par exemple le numro de fixe voici le chemin parcourir : Etape 1 : nud " repertoire". Etape 2 : descendre au nud enfant " personne". Etape 3 : descendre au nud enfant " telephones ". Etape 4 : descendre au nud enfant " telephone" dont l'attribut est " fixe". Sans rentrer dans les dtails, l'expression XPath correspondante ressemblera quelque chose comme a : Code : XPath /tape1/tape2/tape3/tape4
Si le principe est toujours le mme, il est possible d'exprimer vos chemins de 2 manires : Un chemin relatif . Un chemin absolu.
www.openclassrooms.com
141/209
Bien que nous ayons dj vu un exemple, je vous propose d'illustrer cette dfinition par un nouvel exemple dans lequel nous allons rcuprer le prnom de la personne dcrite dans notre arbre XML : Etape 1 : nud " repertoire". Etape 2 : descendre au nud enfant " personne". Etape 3 : descendre au nud enfant " prenom". L'expression XPath correspondante ressemblera alors a : Code : XPath /tape1/tape2/tape3
XPath est une technologie qui permet d'extraire des informations d'un document XML via l'criture de d'expressions. Parent, enfant, descendant, anctre et frre sont des notions importantes comprendre afin de manipuler XPath. Les expressions XPath peuvent tre crites l'aide d'un chemin relatif ou absolu.
www.openclassrooms.com
142/209
L'axe
L'axe va nous permettre de dfinir le sens de la recherche. Par exemple, si l'on souhaite se diriger vers un nud enfant ou au contraire remonter vers un nud parent voir un anctre.
Le nud
Ce second lment va nous permettre d'affiner notre recherche en indiquant explicitement le nom d'un nud ou le type de nud dont les informations nous intressent.
Les prdicats
Comme prcis un peu plus haut, ce dernier lment est facultatif . Les prdicats , dont le nombre n'est pas limit, agissent comme un filtre et vont nous permettre de gagner en prcision lors de nos recherches. Ainsi, grce aux prdicats , il sera par exemple possible de slectionner les informations une position prcise. Maintenant que nous savons comment former une tape, il nous reste apprendre la syntaxe nous permettant de les ordonner et ainsi de pouvoir crire une tape compatible avec XPath : Code : XPath axe::nud[predicat][predicat]...[predicat]
Les axes
Comme nous l'avons vu dans la partie prcdente, un axe est le premier lment formant une tape. Son rle est de dfinir le sens de la recherche. Bien videmment, le choix du sens est structur par un vocabulaire prcis que nous allons tudier maintenant.
Le tableau rcapitulatif
Nom de l'axe ancestor ancestor-or-self attribute Description oriente la recherche vers les anctres du nud courant oriente la recherche vers le nud courant et ses anctres oriente la recherche vers les attributs du nud courant
www.openclassrooms.com
143/209
descendant-or-self oriente la recherche vers le nud courant et ses descendants following following-sibling parent preceding preceding-sibling self oriente la recherche vers les nuds suivant le nud courant oriente la recherche vers les frres suivants du nud courant oriente la recherche vers le pre du nud courant oriente la recherche vers les nuds prcdant le nud courant oriente la recherche vers les frres prcdents du nud courant oriente la recherche vers le nud courant
Pour votre culture gnrale, sachez qu'il existe galement un axe nomm namespace qui permet d'orienter la recherche vers un espace de noms. Je l'ai volontairement retir du tableau rcapitulatif car nous ne l'utiliserons pas dans le cadre de ce tutoriel.
Quelques abrviations
Tout au long de notre dcouverte des axes, des tests de nuds et des prdicats, nous allons dcouvrir qu'il est possible d'utiliser des abrviations afin de rendre la syntaxe de nos expressions XPath plus claire et concise.
L'axe child
Pour les axes, il existe une abrviation possible et elle concerne l'axe child. En ralit, lorsque l'on souhaite orienter la recherche vers l'axe child, ce n'est pas ncessaire de le prciser. Il s'agit de l'axe par dfaut.
Le tableau rcapitulatif
Nom Description
nom du nud oriente la recherche vers le nud dont le nom a explicitement t spcifi * node() text() comment() oriente la recherche vers tous les nuds oriente la recherche vers tous les types de nuds (lments, commentaires, attributs, etc.) oriente la recherche vers les nuds de type texte oriente la recherche vers les nuds de type commentaire
A noter : il existe galement d'autres valeurs possibles comme par exemple processing-instruction(). Je l'ai volontairement retir du tableau rcapitulatif car nous ne l'utiliserons pas dans le cadre de ce tutoriel.
Quelques exemples
Puisque les prdicats sont facultatifs dans les expressions XPath, je vous propre de voir d'ores et dj quelques exemples. Pour les exemples, nous allons nous appuyer sur le document XML que nous avons dj utilis :
www.openclassrooms.com
144/209
Il est possible de simplifier l'criture de cette expression. En effet, comme je l'ai dit dans le chapitre sur les axes, l'axe child est celui par dfaut, il n'est donc pas ncessaire de le prciser. Ainsi, il est possible de simplifier notre expression de la sorte : Code : XPath /repertoire/personne/adresse/pays
www.openclassrooms.com
145/209
Maintenant que vous tes un peu plus l'aise avec la syntaxe de XPath, je vous propose de voir un exemple un peu plus exotique. Le but est de trouver maintenant l'expression XPath permettant de trouver tous les commentaires de notre document XML. Dans ce nouvel exemple, une seule tape est en ralit ncessaire et consiste slectionner tous les descendants du nud racine qui sont des commentaires. Tentons maintenant de traduire cette tape sous la forme d'expressions XPath : On slectionne tous les descendants avec l'expression descendant. On filtre les commentaires avec l'expression comment(). Ce qui nous donne : Code : XPath /descendant::comment()
Quelques abrviations
Tout comme pour les axes, il existe quelques abrviations dont je vous conseille d'abuser afin de rendre vos expressions XPath plus lisibles et lgres.
L'expression /descendant-or-self::node()/
Dans nos expressions XPath, il est possible de remplacer l'expression " /descendant-or-self::node()/ " par " // ". Ainsi, l'expression : Code : XML /descendant-or-self::node()/pays
www.openclassrooms.com
146/209
L'expression self::node()
Notre deuxime abrviation va nous permettre de remplacer l'expression " /self::node()/ " par " .". Ainsi, l'expression : Code : XML /repertoire/personne/self::node()
L'expression parent::node()
Notre dernire abrviation va nous permettre de remplacer l'expression " /parent::node()/ " par " ..".
Les prdicats
Nous venons donc de voir deux des trois lments formant une tape dans une expression XPath. Dans ce chapitre, nous allons donc aborder l'lment manquant : les prdicats .
Le tableau rcapitulatif
Nom du prdicat attribute count() last() position() Description permet d'affiner la recherche en fonction d'un attribut permet de compter le nombre de nuds permet de slectionner le dernier nud d'une liste permet d'affiner la recherche en fonction de la position d'un nud
A noter : il existe galement d'autres valeurs possibles comme par exemple name(), id() ou encore string-length(). Je les ai volontairement retires du tableau rcapitulatif car nous ne l'utiliserons pas dans le cadre de ce tutoriel.
Un prdicat peut galement contenir une expression XPath correspondant une tape. Nous verrons notamment ce cas dans le TP.
Quelques exemples
www.openclassrooms.com
147/209
Premier exemple
Dans notre premier exemple, le but va tre de rcuprer le nud contenant le numro de tlphone fixe de John DOE. Bien videmment, il existe plusieurs faon d'y arriver. Je vous propose d'utiliser celle qui pousse le moins rflchir : nous allons slectionner tous les descendants du nud racine et filtrer sur la valeur de l'attribut type. Ce qui nous donne : Code : XPath /descendant::*[attribute::type="fixe"]
Bien videmment, cette mthode est prescrire car elle peut avoir de nombreux effets de bord. Il est possible de procder autrement en prcisant le chemin complet : Code : XPath /repertoire/personne/telephones/telephone[attribute::type="fixe"]
Terminons ce premier exemple en slectionnant les numros de tlphones qui ne sont pas des numros de tlphones fixes. Une fois de plus, il existe plusieurs faons de procder. La premire, qui a priori est la plus simple, consiste remplacer dans notre expression prcdente l'oprateur d'galit "=" par l'oprateur de non galit " !=" : Code : XPath /repertoire/personne/telephones/telephone[attribute::type!="fixe"]
www.openclassrooms.com
148/209
A noter : la double ngation nous fait revenir notre point de dpart. En effet, les 2 expressions suivantes sont quivalentes : Code : XPath /repertoire/personne/telephones/telephone[not(attribute::type!="fixe")]
Deuxime exemple
Aprs avoir manipul les attributs, je vous propose maintenant de manipuler les positions. Ainsi, notre deuxime exemple consiste slectionner le premier numro de tlphone de John DOE. Commenons par dtailler les tapes en franais : Etape 1 : descendre au nud " repertoire". Etape 2 : descendre au nud " personne". Etape 3 : descendre au nud " telephones ". Etape 4 : slectionner le premier nud " telephone". Traduisons maintenant ces tapes sous la forme d'expressions XPath : Etape 1 : repertoire. Etape 2 : personne. Etape 3 : telephones. Etape 4 : telephone[position()=1]. Ce qui nous donne : Code : XML /repertoire/personne/telephones/telephone[position()=1]
Si l'on souhaite maintenant slectionner le dernier nud "tlphone" de la liste, on modifiera l'expression de la manire suivante : Code : XML /repertoire/personne/telephones/telephone[last()]
Quelques abrviations
Comme pour les axes, nous n'allons voir ici qu'une seule abrviation et elle concerne le prdicat attribute qu'il est possible de remplacer par le symbole " @". Ainsi, l'expression :
www.openclassrooms.com
149/209
Le document XML
Commencez par crer dans EditiX un document XML contenant les informations suivantes : Code : XML <?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <repertoire> <!-- John DOE --> <personne sexe="masculin"> <nom>DOE</nom> <prenom>John</prenom> <adresse> <numero>7</numero> <voie type="impasse">impasse du chemin</voie> <codePostal>75015</codePostal> <ville>PARIS</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="fixe">01 02 03 04 05</telephone> <telephone type="portable">06 07 08 09 10</telephone> </telephones> <emails> <email type="personnel">john.doe@wanadoo.fr</email> <email type="professionnel">john.doe@societe.com</email> </emails> </personne> <!-- Marie POPPINS --> <personne sexe="feminin"> <nom>POPPINS</nom> <prenom>Marie</prenom> <adresse> <numero>28</numero> <voie type="avenue">avenue de la rpublique</voie> <codePostal>13005</codePostal> <ville>MARSEILLE</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="bureau">04 05 06 07 08</telephone> </telephones> <emails> <email type="professionnel">contact@poppins.fr</email> </emails> </personne>
www.openclassrooms.com
150/209
La vue XPath
Afin de pouvoir excuter des expressions XPath, nous allons devoir afficher la vue ddie au sein de EditiX. Pour ce faire, vous pouvez slectionner dans la barre de menu XMLpuis XPath viewou encore utiliser le raccourci clavier Ctrl + Shift + 4. La fentre suivante doit alors apparatre :
Vue XPath dans EditiX Comme vous pouvez le constater, cette vue se compose de plusieurs lments : Un champ dans lequel toutes nos expressions seront crites. 2 boutons permettant de choisir si notre expression utilise un chemin relatif ou absolu. Une puce permettant de choisir la version de XPath utiliser (prenez l'habitude de travailler avec la version 2). Des onglets permettant notamment d'afficher les informations slectionnes par nos expressions.
www.openclassrooms.com
151/209
Rsultat d'une expression XPath dans EditiX Le rsultat est bien celui souhait ! Une tape est compose d'un axe, d'un nud ou type de nud et d'un ou plusieurs prdicats . L'axe par dfaut est l'axe child. De nombreuses abrviations permettent de simplifier l'criture des expressions XPath.
www.openclassrooms.com
152/209
www.openclassrooms.com
153/209
Une solution
Comme chaque fois, je vous fais part de ma solution.
Expression n1
Le but de cette premire expression tait de slectionner tous les nuds descendants du deuxime nud " personne" : Code : XPath /repertoire/personne[position()=2]/descendant::*
Expression n2
Le but de cette expression tait de slectionner le nud " personne" correspondant un individu ayant au moins 2 numros de tlphone : Code : XPath /repertoire/personne[count(telephones/telephone) > 1]
Expression n3
Le but de cette troisime expression tait de slectionner tous les nuds " personne" :
www.openclassrooms.com
154/209
Expression n4
Le but de cette expression tait de slectionner le deuxime nud " personne" dont le pays de domiciliation est la France : Code : XPath /repertoire/personne[adresse/pays="FRANCE"][position()=2]
Expression n5
Le but de la dernire expression tait de slectionner tous les nuds " personne" de sexe masculin le pays de domiciliation est les Etats-Unis : Code : XPath /repertoire/personne[@sexe="masculin"][adresse/pays="USA"]
www.openclassrooms.com
155/209
Introduction XSLT
Tout au long de ce tutoriel, nous avons dcouvert de nombreuses technologies rgulirement utilises en parallle d'un document XML. Chaque technologie ayant un but trs prcis : crire une dfinition ou encore exploiter les donnes contenus dans un document XML, par exemple. Dans cette quatrime partie, nous allons aborder une nouvelle technologie appele XSLT. Cette technologie va nous permettre de transformer nos documents XML, c'est--dire, de crer de nouveaux documents partir des informations contenues dans un document XML. Comme d'habitude, nous allons dbuter en douceur. Ce premier chapitre a donc pour objectif de faire connaissance avec la technologie qui va nous occuper dans les prochains chapitres.
Comment a marche ?
Le principe de fonctionnement est assez simple : un document XSLT est associ un document XML afin de crer un nouveau document d'une nature diffrente ou identique.
www.openclassrooms.com
156/209
L'extension du fichier
Comme c'tait le cas pour les DTD et les schmas XML, nous allons prendre l'habitude d'crire nos documents XSLT dans un fichier distinct du document XML dont les donnes seront transformes. L'extension porte par les documents XSLT est " .xsl ".
Le prologue
Puisque la technologie XSLT utilise un langage de type XML, nous n'allons pas droger la rgle du prologue. Ainsi, la premire ligne d'un document XSLT est : Code : XML <?xml version="1.0" encoding="UTF-8" ?>
Comme vous pouvez le constater, le prologue est identique ce que nous avons dj vu pour les documents XML et les schmas XML. Si vous avez besoin de vous rafrachir la mmoire sur les diffrents lments qui composent ce prologue, je vous invite relire la partie 1 de ce tutoriel traitant du sujet.
Le corps
Le corps d'un fichier XSLT, au mme titre qu'un document XML classique est constitu d'un ensemble de balises dont l'lment racine. Comme c'tait dj le cas pour un schma XML, l'lment racine d'un document XSLT est impos. Code : XML <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> </xsl:stylesheet>
Comme vous pouvez le constater, l'lment racine est donc <xsl:stylesheet />. On remarque la prsence de 2 attributs dans cet lment racine. Le premier est le numro de version que l'on souhaite utiliser. Dans le cadre de ce tutoriel, c'est la version 1 que nous allons utiliser. Bien qu'une version 2 existe, la premire version de XSLT reste encore aujourd'hui majoritairement utilise. Le second attribut qui est xmlns:xsl nous permet de dclarer un espace de noms . Une nouvelle fois, si vous n'tes pas l'aise avec cette notion, je vous encourage lire le chapitre ddi aux espaces de nom en annexe de ce tutoriel. Via la dclaration de cet espace de noms, toutes les balises utilises dans un document XSLT doivent tre prfixes par xsl:.
La balise output
Directement aprs l'lment racine, nous allons prendre l'habitude de placer l'lment <xsl:output />. Cet lment permet de dcrire le document produit l'issue des diffrentes transformations. Cet lment prend plusieurs attributs.
www.openclassrooms.com
157/209
L'attribut method
Ce premier attribut permet de prciser le type du document produit l'issue des transformations. 3 valeurs existent : xml si le document produire est un document XML. html si le document produire est un document HTML. text si le document produire est un document texte. A noter : dans la seconde version de XSLT, il existe une quatrime valeur : xhtml si le document produire est un document xHTML.
L'attribut encoding
Ce second attribut permet de prciser l'encodage du document produit l'issue des transformations. Un grand nombre de valeurs existent pour renseigner la valeur de l'attribut encoding : UTF-8. ISO-8859-1. etc.
L'attribut indent
Ce troisime attribut permet d'indiquer si l'on souhaite que le document produit l'issue des transformations soit indent ou non. 2 valeurs sont possibles : Yes. No.
V oyons maintenant un exemple nous permettant de produire un document HTML 4 : Code : XML
www.openclassrooms.com
158/209
Pour rsumer
Pour rsumer, voici quoi ressembleront nos documents XSLT : Code : XML <!-- le prologue --> <?xml version="1.0" encoding="UTF-8" ?> <!-- l'lment racine --> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <!-- l'lment output --> <xsl:output method="html" encoding="UTF-8" doctype-public="-//W3C//DTD HTML 4.01//EN" doctype-system="http://www.w3.org/TR/html4/strict.dtd" indent="yes" /> <!-- reste du document XSLT --> </xsl:stylesheet>
Comme vous pouvez le voir, cette balise un peu spciale possde 2 attributs sur lesquels il est intressant de revenir rapidement.
L'attribut type
Il permet de dfinir le type du document que nous souhaitons rfrencer. Dans notre cas, puisqu'il s'agit d'un document XSLT, il convient de renseigner la clef " text/xsl ".
L'attribut href
www.openclassrooms.com
159/209
Cet attribut, trs connu de ceux qui manipulent rgulirement le HTML et ses variantes, permet d'indiquer l'URI du document que l'on souhaite rfrencer. Dans mon exemple, il s'agit d'un chemin relatif puisque le document XML et le document XSLT sont situs dans le mme dossier.
Pour rsumer
V oici quoi nos fichiers XML ressembleront : Code : XML <?xml version="1.0" encoding="UTF-8"?> <?xml-stylesheet type="text/xsl" href= "mon_document.xsl" ?> <racine> <!-- contenu du document XML --> </racine>
Un document XSLT est associ un document XML afin de crer un nouveau document. L'extension porte par les documents XSLT est " .xsl ". Un document XSLT doit tre rfrenc dans le document XML qu'il transforme.
www.openclassrooms.com
160/209
Les templates
Le chapitre prcdent nous a permis de dcouvrir la technologie XSLT et notamment la structure gnrale d'un document. Dans ce nouveau chapitre, nous allons nous attaquer au corps d'un document XSLT. Le corps d'un document XSLT est compos d'un ensemble de templates . C'est cette notion que nous allons approfondir dans ce chapitre. Nous allons voir, tape par tape, comment crire un template et ainsi slectionner et exploiter les informations du document XML transformer.
Lorsque nous crirons nos templates, il est important de renseigner l'un ou l'autre des 2 attributs match et name, jamais les deux en mme temps. Nous verrons dans la suite de ce tutoriel que, suivant l'attribut renseign, le template ne sera pas utilis de la mme faon.
www.openclassrooms.com
161/209
Le document XML
Code : XML <?xml version="1.0" encoding="UTF-8"?> <?xml-stylesheet type="text/xsl" href="transformation.xsl" ?> <personne> <nom>BATTE</nom> <prenom>Man</prenom> </personne>
Comme il est possible de le lire dans ce document XML, ce dernier est associ le document XSLT transformation.xsl . C'est lui qui contient toutes les instructions qui permettent de transformer les donnes du document XML en un document HTML.
Le document XSLT
Pour notre exemple, voici le contenu de du document transformation.xsl : Code : XML <?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:output method="html" encoding="UTF-8" doctype-public="-//W3C//DTD HTML 4.01//EN" doctype-system="http://www.w3.org/TR/html4/strict.dtd" indent="yes" /> <xsl:template match="/"> <html> <head> <title>Mon premier document XSLT</title> </head> <body> <p>Bonjour !</p> </body> </html> </xsl:template> </xsl:stylesheet>
Revenons sur les diffrents lments qui composent ce document XSLT. Attardons nous tout d'abord sur la balise <xsl:output /> dont le contenu ne doit pas vous tre inconnu. Les attributs de cette balise nous permettent d'indiquer que nous souhaitons un document HTML 4 dont le contenu sera indent et encod en UTF-8. Regardons maintenant du ct de notre premier template. Nous pouvons nous apercevoir qu'il possde l'attribut " select", qui slectionne toutes les donnes de notre document XML via l'expression XPath" / ". Revenons maintenant sur la relle nouveaut de ce document XSLT savoir, le contenu du template. Ici, il s'agit tout simplement de l'criture d'un document HTML qui, en ralit, n'exploite absolument pas les donnes slectionnes dans le document XML. Ainsi, le document produit suite l'application de ce template sera toujours le mme, peu importe les donnes fournies par le document XML. Ne vous inquitez pas, nous verrons comment exploiter les donnes slectionnes dans la suite du tutoriel.
Le rsultat
www.openclassrooms.com
162/209
Plusieurs choses importantes sont noter. Tout d'abord, on retrouve bien les informations que nous avions prcises dans la balise <xsl:output /> de notre document XSLT savoir les informations sur le Doctype, les informations sur l'encodage ainsi que l'indentation du document.
Les fonctions
Aprs avoir cr notre premier template dans le chapitre prcdent, je vous propose maintenant de nous attaquer aux diffrentes fonctions que le XSLT met notre disposition. Ces fonctions vont nous permettre d'exploiter les donnes slectionnes par nos templates afin de procder des transformations plus ou moins complexes. Dans la suite de ce chapitre, le document XML utilis sera le suivant : Code : XML <?xml version="1.0" encoding="UTF-8" ?> <?xml-stylesheet type="text/xsl" href="transformation.xsl" ?> <repertoire> <!-- John DOE --> <personne sexe="masculin"> <nom>DOE</nom> <prenom>John</prenom> <adresse> <numero>7</numero> <voie type="impasse">impasse du chemin</voie> <codePostal>75015</codePostal> <ville>PARIS</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="fixe">01 02 03 04 05</telephone> <telephone type="portable">06 07 08 09 10</telephone> </telephones> <emails> <email type="personnel">john.doe@wanadoo.fr</email> <email type="professionnel">john.doe@societe.com</email> </emails> </personne> <!-- Marie POPPINS --> <personne sexe="feminin"> <nom>POPPINS</nom> <prenom>Marie</prenom> <adresse> <numero>28</numero> <voie type="avenue">avenue de la rpublique</voie> <codePostal>13005</codePostal> <ville>MARSEILLE</ville> <pays>FRANCE</pays>
www.openclassrooms.com
163/209
Afin de gagner en clart, je ne vais pas rcrire chaque fois la totalit du document XSLT utilis. Je me contenterai d'crire uniquement l'unique template que notre document contiendra. Ainsi, la structure gnrale du document transformation.xsl est la suivante : Code : XML <?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:output method="html" encoding="UTF-8" doctype-public="-//W3C//DTD HTML 4.01//EN" doctype-system="http://www.w3.org/TR/html4/strict.dtd" indent="yes" /> <!-- template --> </xsl:stylesheet>
La fonction value-of
Syntaxe et explications
La fonction <xsl:value-of />, que l'on peut traduire en franais par " valeur de", nous permet d'extraire la valeur d'un lment XML ou la valeur de ses attributs. Cette fonction possde un attribut select auquel il convient de renseigner une expression XPath permettant alors de slectionner les informations extraire : Code : XML <xsl:value-of select="expression XPath" />
www.openclassrooms.com
164/209
Exemple
A titre d'exemple, je vous propose d'crire un template qui va afficher le type du numro de tlphone et le numro en lui mme de Marie POPPINS : Code : XML <xsl:template match="/"> <html> <head> <title>Test de la fonction value-of</title> </head> <body> <p>Type du numro : <xsl:value-of select="repertoire/personne[nom='POPPINS']/telephones/telephone/@type" /></p> <p>Numro : <xsl:value-of select="repertoire/personne[nom='POPPINS']/telephones/telephone" /></p> </body> </html> </xsl:template>
Comme vous pouvez le constater, notre template contient 2 fonctions <xsl:value-of />. La premire extrait l'attribut " type" de l'unique numro de tlphone de Marie POPPINS, tandis que le seconde extrait la valeur de l'lment proprement parler, le tout grce des expressions XPath. Le document HTML produit est alors le suivant : Code : HTML <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Test de la fonction value-of</title> </head> <body> <p>Type du numro : professionnel</p> <p>Numro : 04 05 06 07 08</p> </body> </html>
La fonction for-each
Syntaxe et explications
La fonction <xsl:for-each />, que l'on peut traduire en franais par " pour chaque" est une fonction qui permet de boucler sur un ensemble d'lments. Par exemple, si l'on souhaite appliquer une transformation l'ensemble des numros de tlphone d'une personne, nous allons tous les slectionner l'aide d'une expression XPath, puis, grce la fonction <xsl:for-each />, il sera possible de parcourir l'ensemble des rsultats obtenus pour y appliquer une transformation particulire.
www.openclassrooms.com
165/209
Comme pour la fonction <xsl:value-of />, la fonction <xsl:for-each /> possde un attribut select auquel il convient de renseigner une expression XPath permettant alors de slectionner les informations extraire : Code : XML <xsl:for-each select="expression XPath" />
Exemple
Pour illustrer l'utilisation de la fonction <xsl:for-each />, je vous propose d'crire un template qui va afficher pour chaque adresse e-mail de John DOE son type et son contenu : Code : XML <xsl:template match="/"> <html> <head> <title>Test de la fonction for-each</title> </head> <body> <xsl:for-each select="repertoire/personne[nom='DOE']/emails/email"> <p>Type de l'adresse e-mail : <xsl:value-of select="@type" /></p> <p>adresse e-mail : <xsl:value-of select="." /></p> </xsl:for-each> </body> </html> </xsl:template>
Comme vous pouvez le constater, notre template contient une fonction <xsl:for-each/> dont le rle est de slectionner l'ensemble des adresse e-mails de John DOE. A l'intrieur de cette fonction, nous sommes alors capable d'exploiter individuellement les diffrentes adresses grce la fonction <xsl:value-of /> que nous avons vu prcdemment. Le document HTML produit est alors le suivant : Code : HTML <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Test de la fonction for-each</title> </head> <body> <p>Type de l'adresse e-mail : personnel</p> <p>adresse e-mail : john.doe@wanadoo.fr</p> <p>Type de l'adresse e-mail : professionnel</p> <p>adresse e-mail : john.doe@societe.com</p> </body> </html>
La fonction sort
Syntaxe et explications
www.openclassrooms.com
166/209
La fonction <xsl:sort /> est une fonction qui permet de trier un ensemble d'lments par ordre croissant ou dcroissant. Puisque l'on souhaite trier un ensemble d'lments, la fonction <xsl:sort /> est gnralement utilise au sein de la fonction <xsl:for-each /> que nous venons de voir. Elle possde au moins un attribut select auquel il convient de renseigner une expression XPath permettant alors de slectionner les informations trier. La fonction <xsl:sort /> accepte galement d'autres attributs qui sont cependant optionnels : Order qui accepte les valeurs ascending (croissant) et descending (dcroissant) permet de prciser le sens du tri. Par dfaut, c'est un tri croissant qui est effectu. Case-order qui accepte les valeurs upper-first (les majuscules d'abord) et lower-first (les minuscules d'abord) permet de prciser qui des majuscules et des minuscules est prioritaire pour effectuer les tri. Data-type qui accepte les valeurs text (texte) et number (nombre) permet prciser si les donnes trier sont des nombres ou du texte. Lang qui accepte pour valeur le code d'une langue (fr pour la langue franaise, es pour la langue espagnole, it pour l'italien, etc.) qui permet de prciser la langue des lments trier. Cet attribut est notamment utile afin de trier des lments dont la langue possde quelques caractres spcifiques comme par exemple le norvgien, le sudois, etc. Code : XML <xsl:sort select="expression XPath" order="ascending|descending" case-order="upper-first|lower-first" data-type="text|number" lang="fr|es|it|..." />
Exemple
Pour illustrer l'utilisation de la fonction <xsl:sort />, je vous propose d'crire un template qui va afficher le nom et le prnom des personnes contenues dans notre document XML, par ordre alphabtique : Code : XML <xsl:template match="/"> <html> <head> <title>Test de la fonction sort</title> </head> <body> <xsl:for-each select="repertoire/personne"> <xsl:sort select="nom"/> <xsl:sort select="prenom"/> <p><xsl:value-of select="nom" /> <xsl:value-of select="prenom" /></p> </xsl:for-each> </body> </html> </xsl:template>
Notre template contient une fonction <xsl:for-each/> permettant de boucler sur toutes les personnes contenu dans notre document XML. Il contient galement deux fonctions <xsl:sort /> permettant de trier par ordre alphabtique de nom et prnom l'ensemble des personnes. noter : le caractre "  " est un caractre qui une fois la transformation effectue sera simplement remplac par un espace dans notre document HTML. Le document HTML produit est le suivant : Code : HTML <!DOCTYPE html
www.openclassrooms.com
167/209
La fonction if
Syntaxe et explications
La fonction <xsl:if /> est une fonction qui permet de conditionner une transformation. Par exemple, grce cette fonction, il sera possible de n'appliquer une transformation qu'aux personnes de sexe masculin. Cette fonction possde un attribut test auquel il convient de renseigner la condition. Cette condition peut-tre la comparaison d'une chane de caractres ou de nombres. Code : XML <xsl:if test="test de comparaison" />
Les tests
En XSLT, il existe plusieurs types de tests disponibles. Le tableau suivant les rsume et les explique : Condition a=b Explication Cette condition vrifie que la valeur de l'lment a est gale la valeur de l'lment b.
not(a = b) Cette condition vrifie que la valeur de l'lment a n'est pas gale la valeur de l'lment b. a=b a < b a <= b a > b a >= b Cette condition vrifie que la valeur de l'lment a est gale la valeur de l'lment b. Le symbole < (lower than) traduit en ralit le symbole <. La condition est donc en ralit la suivante : a < b. Cette condition vrifie que la valeur de l'lment a est strictement infrieure la valeur de l'lment b. Le symbole < (lower than) traduit en ralit le symbole <. La condition est donc en ralit la suivante : a <= b. Cette condition vrifie que la valeur de l'lment a est infrieure ou gale la valeur de l'lment b. Le symbole > (greater than) traduit en ralit le symbole >. La condition est donc en ralit la suivante : a > b. Cette condition vrifie que la valeur de l'lment a est strictement suprieure la valeur de l'lment b. Le symbole > (greater than) traduit en ralit le symbole >. La condition est donc en ralit la suivante : a > b. Cette condition vrifie que la valeur de l'lment a est suprieure ou gale la valeur de l'lment b.
Il est est galement possible d'effectuer plusieurs tests la fois. Ainsi, nous pouvons : Vrifier qu'un premier test est vrai ET qu'un second l'est galement. Vrifier qu'un premier test est vrai OU qu'un second l'est. Dans un test, pour traduire la notion de ET, on utilise le mot anglais and, tandis que pour traduire la notion de OU, on utilise sa
www.openclassrooms.com
168/209
V oyons quelques exemples afin d'illustrer toutes ces notions. Par exemple, si l'on souhaite vrifier que la valeur d'un lment a est strictement suprieure un lment b ET un lment c, on crira : Code : XML <xsl:if test="a > b and a > c"> <!-- contenu de la condition --> </xsl:if>
V oyons la condition crire si l'on souhaite vrifier que la valeur d'un lment a est gale la valeur d'un lment b OU gale la valeur d'un lment c : Code : XML <xsl:if test="a = b or a = c"> <!-- contenu de la condition --> </xsl:if>
Exemple
Pour illustrer l'utilisation de la fonction <xsl:if />, je vous propose d'crire un template qui va afficher le nom et le prnom des personnes de sexe masculin contenues dans notre document XML : Code : XML <xsl:template match="/"> <html> <head> <title>Test de la fonction if</title> </head> <body> <xsl:for-each select="repertoire/personne"> <xsl:if test="@sexe = 'masculin'"> <p><xsl:value-of select="nom" /> <xsl:value-of select="prenom" /></p> </xsl:if> </xsl:for-each> </body> </html> </xsl:template>
Notre template parcourt donc l'ensemble des personnes contenues dans notre document XML grce la fonction <xsl:foreach/>. Grce la fonction <xsl:if/>, il est possible d'appliquer la suite de la transformation uniquement aux personnes de sexe masculin. Le document HTML produit est le suivant : Code : HTML <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
www.openclassrooms.com
169/209
La fonction choose
Syntaxe et explications
La fonction <xsl:choose />, tout comme la fonction <xsl:id />, permet de conditionner des transformations. En ralit, la fonction <xsl:choose /> ne s'utilise pas toute seule. En effet, elle permet plusieurs conditions. Ainsi, dans le cas o la premire condition n'est pas remplie, la seconde va tre teste, puis la troisime, etc. Dans le cas o aucune condition n'est remplie, un cas par dfaut peut-tre prvu. Les conditions inclues dans la fonction <xsl:choose /> s'expriment grce la fonction <xsl:when />. Le cas par dfaut s'exprime quant lui grce la fonction <xsl:otherwise />. La fonction <xsl:when /> possde un attribut test auquel il convient de renseigner une condition. Code : XML <xsl:choose> <xsl:when test="test <!-- suite de la </xsl:when> <xsl:when test="test <!-- suite de la </xsl:when> <xsl:otherwise> <!-- suite de la </xsl:otherwise> </xsl:choose>
Le nombre de fonction <xsl:when /> varie en fonction du nombre de conditions que vous souhaitez tester.
Exemple
Pour illustrer l'utilisation de la fonction <xsl:choose />, je vous propose d'crire un template qui suivant le nom des personnes contenues dans le document XML, affichera une phrase personnalise. Ainsi, pour John DOE, la phrase afficher sera " Bonjour John !", pour Marie POPPINS, la phrase afficher sera " Quel beau sac !". Dans tous les autres cas, la phrase afficher sera " Qui tes-vous ? ". Code : XML <xsl:template match="/"> <html> <head> <title>Test de la fonction sort</title> </head> <body> <xsl:for-each select="repertoire/personne"> <xsl:choose> <xsl:when test="nom = 'DOE'"> <p>Bonjour John !</p> </xsl:when> <xsl:when test="nom = 'POPPINS'"> <p>Quel beau sac !</p>
www.openclassrooms.com
170/209
Puisque les personnes de notre document XML seront traites dans leur ordre d'apparition de notre document XML, les phrases seront affiches dans cet ordre dans le document HTML produit : Bonjour John ! Quel beau sac ! Qui tes-vous ? C'est effectivement le cas lorsqu'on regarde le document HTML produit : Code : HTML <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Test de la fonction sort</title> </head> <body> <p>Bonjour John !</p> <p>Quel beau sac !</p> <p>Qui êtes-vous ?</p> </body> </html>
La fonction apply-templates
Syntaxe et explications
La fonction <xsl:apply-templates />, permet de continuer la transformation des lments enfants d'un template. Dans le cadre de ce tutoriel, nous allons uniquement considrer l'attribut select de la fonction <xsl:apply-templates /> qu'il convient de renseigner l'aide d'une expression XPath. Code : XML <xsl:apply-templates select="expression XPath" />
Exemple
Pour illustrer l'utilisation de la fonction <xsl:apply-templates />, je vous propose de dcortiquer ensemble le template. Tout d'abord, considrons un document XML un peu plus simple que celui que nous utilisions jusqu' maintenant :
www.openclassrooms.com
171/209
Considrons alors les templates suivants : Code : XML <xsl:template match="/"> <html> <head> <title>Test de la fonction apply-templates</title> </head> <body> <xsl:apply-templates select="repertoire/personne[nom='POPPINS']" /> </body> </html> </xsl:template> <xsl:template match="nom"> <p><xsl:value-of select="."/></p> </xsl:template> <xsl:template match="prenom"> <p><xsl:value-of select="."/></p> </xsl:template>
A l'excution de la transformation XSLT, le premier template tre appel est le template dont l'expression XPath capture la racine de notre document XML. Dans ce template, la ligne <xsl:apply-templates select="repertoire/personne[nom='POPPINS']" /> permet d'indiquer que l'on souhaite continuer la transformation uniquement avec l'lment <personne /> correspondant Marie POPPINS ainsi que ses fils savoir les lments <nom /> et <prenom />. L'lment <nom /> va donc tre transform grce au second template crit dans notre document XSLT puisque son expression XPath le capture. Finalement, en suivant la mme logique, l'lment <prenom /> va, quant lui, tre transform grce au dernier template de notre document XSLT. Le document HTML produit est alors le suivant : Code : HTML <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
www.openclassrooms.com
172/209
Afin de bien comprendre le mcanisme, je vous propose maintenant de jeter un coup dil aux templates suivant : Code : XML <xsl:template match="/"> <html> <head> <title>Test de la fonction apply-templates</title> </head> <body> <xsl:apply-templates select="repertoire/personne[nom='POPPINS']/nom" /> </body> </html> </xsl:template> <xsl:template match="nom"> <p><xsl:value-of select="."/></p> </xsl:template> <xsl:template match="prenom"> <p><xsl:value-of select="."/></p> </xsl:template>
Comme pour notre premier exemple, l'excution de la transformation XSLT, le premier template tre appel est le template dont l'expression XPath capture la racine de notre document XML. Dans ce template, la ligne <xsl:apply-templates select="repertoire/personne[nom='POPPINS']/nom" /> permet d'indiquer que l'on souhaite continuer la transformation uniquement avec llment <nom /> de la <personne /> correspondant Marie POPPINS . L'lment <nom /> va donc tre transform grce au second template de notre document XSLT. Le dernier template ne sera quant lui jamais appel. Le document HTML produit est alors le suivant : Code : HTML <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Test de la fonction sort</title> </head> <body> <p>POPPINS</p> </body>
www.openclassrooms.com
173/209
Les templates possdent systmatiquement l'un des 2 attributs : match ou name. Les templates se construisent l'aide de nombreuses fonctions.
www.openclassrooms.com
174/209
Les variables
Dfinition
En XSLT, comme dans de nombreuses technologies informatiques et plus prcisment dans les langages de programmation, il existe une notion importante que l'on appelle les variables . Une variable est une information que l'on stocke dans la mmoire de l'ordinateur afin de pouvoir la rutiliser. Elle possde un identifiant unique qui est son nom. Ainsi, plusieurs variables ne peuvent pas avoir le mme nom. L'information stocke par une variable est sa valeur. Dans nos documents XSLT, les variables doivent tre dclares au sein d'un template et ont une porte dite locale, c'est--dire qu'une variable ne peut tre utilise que dans le template dans lequel elle est dclare. Par exemple, si une variable portant le nom " maVariable" est dclare dans un premier template, les autres templates du document XSLT ne la connaissent pas.
Dclaration et utilisation
Afin de dclarer une variable, il convient d'utiliser la fonction <xsl:variable />. Cette fonction accepte deux attributs : Name : c'est le nom que l'on souhaite donner notre variable, ce nom va nous permettre de l'identifier de manire unique. Select : cet attribut optionnel accepte soit une expression XPath qui permet de slectionner la valeur que l'on souhaite stocker dans notre variable, soit une chane de caractres. La syntaxe pour dclarer une variable est donc la suivante : Code : XML <xsl:variable name="nom_de_la_variable" select="expression XPath|chane de caractres" />
Pour pouvoir utiliser une variable et rcuprer la valeur qu'elle contient, il convient de faire prcder son nom par le symbole " $ ".
Exemple
Afin d'illustrer ce que nous venons d'apprendre sur les variables, je vous propose de voir ensemble quelques exemples. Dans notre premier exemple, nous allons crer une variable qui contiendra une chane de caractres et nous l'afficherons dans une balise paragraphe d'une document HTML : Code : XML <xsl:template match="/"> <xsl:variable name="couleur" select="'rouge'" /> <html> <head>
www.openclassrooms.com
175/209
Comme vous pouvez le constater, dans ce template, nous dclarons une variable qui s'appelle " couleur" et qui contient la chane de caractres " rouge" : Code : XML <xsl:variable name="couleur" select="'rouge'" />
Puisque la valeur " rouge" est une chane de caractres, il est impratif de la mettre entre ' (guillemets simples) afin de ne pas la confondre avec une expression XPath. Pour pouvoir afficher la valeur contenue dans la variable dans notre document HTML, il suffit simplement de faire prcder son nom par le symbole $ : Code : XML <xsl:value-of select="$couleur" />
Le document HTML produit par notre transformation est le suivant : Code : HTML <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Test de la fonction sort</title> </head> <body> <p>rouge</p> </body> </html>
A noter : il existe une autre faon de dfinir la valeur d'une variable lorsque celle-ci ne provient pas d'une expression XPath : Code : XML <xsl:variable name="nom">chane de caractres</xsl:variable>
Ainsi, pour le mme document HTML final, nous aurions pu crire le template suivant : Code : XML
www.openclassrooms.com
176/209
Pour notre second exemple, nous allons construire un template dans la valeur des variables sera alimentes par une expression XPath. Pour illustrer notre exemple, nous allons exploiter le document XML suivant : Code : XML <?xml version="1.0" encoding="UTF-8" ?> <?xml-stylesheet type="text/xsl" href="transformation.xsl" ?> <repertoire> <!-- John DOE --> <personne sexe="masculin"> <nom>DOE</nom> <prenom>John</prenom> </personne> <!-- Marie POPPINS --> <personne sexe="feminin"> <nom>POPPINS</nom> <prenom>Marie</prenom> </personne> <!-- Batte MAN --> <personne sexe="masculin"> <nom>MAN</nom> <prenom>Batte</prenom> </personne> </repertoire>
Dans cette exemple, nous allons dclarer 3 variables : La variable sexe qui contiendra le sexe d'une personne. La variable nom qui contiendra le nom d'une personne. La variable prenom qui contiendra le prnom d'une personne. Le but de notre template est alors d'afficher le sexe, le prnom et le nom de chaque personne contenue dans le document XML : Code : XML <xsl:template match="/"> <html> <head> <title>Test des variables</title> </head> <body> <xsl:for-each select="repertoire/personne"> <xsl:variable name="sexe" select="@sexe" /> <xsl:variable name="nom" select="nom" /> <xsl:variable name="prenom" select="prenom" />
www.openclassrooms.com
177/209
Dans ce template, nous parcourons l'ensemble des personnes contenues dans le document XML l'aide de la fonction <xsl:for-each />, puis nous dclarons 3 variables dont les valeurs sont renseignes l'aide d'expressions XPath. Grce la fonction <xsl:value-of />, il est ensuite trs simple d'afficher le contenu de la variable.
La fonction call-template
Maintenant que vous maitrisez les variables, il est grand temps de mettre en pratique vos connaissances ! En effet, dans les exemples que nous avons vu jusqu' maintenant, l'utilisation des variables n'tait pas pertinente, et nous pouvons facilement arriver au mme rsultat sans les utiliser. La fonction que nous allons voir maintenant va nous permettre d'utiliser les variables dans des cas utiles.
Pour l'appeler, il convient donc d'utiliser la fonction <xsl:call-template /> et de renseigner le nom du template appeler : Code : XML <xsl:template select="/"> <xsl:call-template name="nom_du_template" /> </xsl:template>
Afin d'illustrer ce premier aperu de la fonction <xsl:call-template />, je vous propose un premier exemple. Dans celuici, nous allons crire un premier template qui capture la racine d'un document XML et qui crit la structure d'un document HTML. Ce mme template appellera un second template grce la fonction que nous venons de voir afin que celui-ci peuple le contenu de l'lment <body /> de notre document HTML produire. V oici les templates crire : Code : XML <xsl:template match="/"> <html>
www.openclassrooms.com
178/209
Comme vous pouvez le constater, notre premier template appelle un second template identifi par le nom " body " grce la fonction <xsl:call-template /> que nous venons de voir. Le document HTML produit est bien conforme nos attentes : Code : HTML <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Test des variables</title> </head> <body> <p>Contenu de la page HTML</p> </body> </html>
Si l'intrt de l'exercice est ici limit, ce genre de mthode nous permet surtout de bien hirarchiser nos documents XSLT en crant un template associ un rle bien prcis. Dans notre cas, nous avons un premier template dont le rle est de crer la structure de la page HTML tandis que le second template permet d'en crire le contenu. La relecture et la modification du document XSLT sont ainsi facilites.
A l'appel d'un template, il est possible de lui faire passer des paramtres que nous utiliserons comme des variables dans le template appel. Ces paramtres sont tout simplement des informations que l'on souhaite transmettre au template appel. Ainsi, il sera par exemple possible de lui faire passer le nom d'une personne afin de l'afficher. Les paramtres s'utilisent exactement comme les variables ceci prs qu'ils se dclarent grce la fonction <xsl:with-param />. Tout comme la fonction <xsl:variable /> accepte deux attributs : Name : c'est le nom que l'on souhaite donner l'attribut, ce nom va nous permettre de l'identifier de manire unique. Select : cet attribut optionnel accepte soit une expression XPath qui permet de slectionner la valeur que l'on souhaite stocker dans notre variable, soit une chane de caractres. Code : XML <xsl:with-param name="nom_du_parametre" select="expression XPath|chane de caractres" />
www.openclassrooms.com
179/209
V oyons alors comment faire passer les paramtres un template appel : Code : XML <xsl:call-template name="nom_du_template"> <xsl:with-param name="parametre_un">valeur 1</xsl:with-param> <xsl:with-param name="parametre_deux">valeur 1</xsl:with-param> </xsl:call-template>
Comme vous pouvez le constater, il convient simplement d'encapsuler les fonctions <xsl:with-param /> dans la fonction <xsl:call-template />. Nous devons encapsuler autant de fonctions <xsl:with-param /> que nous voulons de paramtres. Ce n'est pas tout ! Nous devons galement dclarer les paramtres au niveau du template appel. La dclaration des paramtres attendus par un template ne se fait plus avec la fonction <xsl:with-param />, mais la fonction <xsl:param /> qui accepte deux attributs : Name : c'est le nom du paramtre que l'on attend. Select : cet attribut optionnel accepte soit une expression XPath, soit une chane de caractres et permet de dfinir une valeur par dfaut au paramtre. Code : XML <xsl:param name="nom_du_parametre" select="expression XPath|chane de caractres" />
Ainsi, si j'appelle un template de la manire suivante : Code : XML <xsl:call-template name="nom_du_template"> <xsl:with-param name="parametre_un">valeur 1</xsl:with-param> <xsl:with-param name="parametre_deux">valeur 1</xsl:with-param> </xsl:call-template>
le template appel bien contenir les 2 paramtres attendus : Code : XML <xsl:template name="nom_du_template"> <xsl:param name="parametre_un" /> <xsl:param name="parametre_deux" /> </xsl:call-template>
Comme pour les variables, pour pouvoir utiliser un paramtre et rcuprer la valeur qu'il contient, il convient de prcder son nom par le symbole " $ ". Je vous propose de terminer ce chapitre par un exemple. Pour cet exemple, nous allons exploiter le document XML suivant : Code : XML
www.openclassrooms.com
180/209
Nous allons crire un document XSLT contenant deux templates : Le premier template capturera la racine du document XML et construira la structure du document HTML produire. Il bouclera galement sur chaque personne du document XML et appellera un second template en lui donnant paramtre le nom de chaque personne. Le second template accueillera 2 paramtres. Le premier sera le nom de la personne tandis que le deuxime aura pour valeur par dfaut la chane de caractres "nom de la personne". Le but de ce second template sera d'afficher le nom de la personne. V oici quoi ressemble notre document XSLT : Code : XML <xsl:template match="/"> <html> <head> <title>Test de la fonction call-template</title> </head> <body> <xsl:for-each select="repertoire/personne"> <xsl:call-template name="afficherNom"> <xsl:with-param name="nomFamille" select="nom" /> </xsl:call-template> </xsl:for-each> </body> </html> </xsl:template> <xsl:template name="afficherNom"> <xsl:param name="nomFamille" /> <xsl:param name="constante">nom de la personne</xsl:param> <p><xsl:value-of select="$constante"/>:<xsl:value-of select="$nomFamille"/></p> </xsl:template>
www.openclassrooms.com
181/209
La syntaxe de la fonction <xsl:element /> est donc la suivante : Code : XML <xsl:element name="nom" namespace="espace_de_nom" />
A noter : pour dfinir une valeur l'lment, il convient tout simplement de la placer entre la balise ouvrante et fermante de la fonction : Code : XML <xsl:element name="nom" namespace="espace_de_nom">valeur de l'lment </xsl:element>
Exemple
Afin d'illustrer l'utilisation de cette nouvelle fonction, je vous propose de voir immdiatement un exemple. Nous allons donc crire un template dont le rle est de crer un lment XML ayant pour nom " couleur" et pour valeur " rouge". Dans cet exemple, je ne vais dtailler ici que le template, mais dans le document XSLT complet, il convient de dcrire le document produire comme un document XML.
Code : XML
www.openclassrooms.com
182/209
Le document XML produit est alors le suivant : Code : XML <?xml version="1.0" encoding="utf-8"?> <couleur>rouge</couleur>
La fonction attribute
Dfinition
La fonction <xsl:attribute /> est une fonction grce laquelle il est possible de crer des attributs des lments XML ou HTML. Dans le cadre de ce tutoriel, nous allons nous intresser au seul attribut obligatoire pour cette fonction. Il s'agit de l'attribut " name" qui permet de dfinir le nom de l'attribut que l'on souhaite crer. La syntaxe de la fonction <xsl:attribute /> est donc la suivante : Code : XML <xsl: attribute name="nom" />
Comme pour la fonction <xsl:element />, pour dfinir la valeur, il convient de la placer entre la balise ouvrante et fermante de la fonction : Code : XML <xsl:attribute name="nom">valeur de l'lment </xsl:element>
Exemple
Pour illustrer la fonction <xsl:attribute />, je vous propose de complter notre exemple prcdent. Ainsi, nous allons toujours produire un document XML qui grce une transformation XSLT contiendra un lment ayant pour nom " couleur" et pour valeur " rouge". La nouveaut est que notre template devra galement ajouter l'attribut " primaire" l'lment " couleur" afin de prciser s'il s'agit d'une couleur primaire ou non. Code : XML <xsl:template match="/"> <xsl:element name="couleur"> <xsl:attribute name="primaire">oui</xsl:attribute> rouge </xsl:element> </xsl:template>
www.openclassrooms.com
183/209
La fonction comment
Dfinition
La fonction <xsl:comment /> est une fonction qui permet de crer des commentaires dans les documents XML ou HTML produire. Cette fonction ne prend aucun attribut. Pour dfinir sa valeur, il suffit simplement de la placer entre la balise ouvrante et fermante de la fonction : Code : XML <xsl:comment>mon commentaire</xsl:comment>
Exemple
Cette fonction est relativement simple d'utilisation par rapport d'autres fonctions que nous avons vu tout au long de ce tutoriel. Cependant, je vous propose tout de mme d'illustrer l'utilisation de cette fonction <xsl:comment /> par un exemple trs simple. Nous allons donc complter le template cr prcdemment afin d'y ajouter un commentaire ayant pour valeur " ma couleur" : Code : XML <xsl:template match="/"> <xsl:comment>ma couleur</xsl:comment> <xsl:element name="couleur"> <xsl:attribute name="primaire">oui</xsl:attribute> rouge </xsl:element> </xsl:template>
Le document XML produit est alors le suivant : Code : XML <?xml version="1.0" encoding="utf-8"?> <!--ma couleur--> <couleur primaire="oui">rouge</couleur>
La fonction processing-instruction
Dfinition
La fonction <xsl:processing-instruction />, malgr son nom barbare, permet de crer ce qu'on appelle une instruction de traitement dans le document que l'on souhaite produire. Une instruction de traitement est une de ces fameuses balises XML qui dbut par le caractre " ? ". C'est notamment ce qu'on utilise dans les documents XML pour rfrencer un fichier CSS ou une transformation XSLT :
www.openclassrooms.com
184/209
Cette fonction accepte un seul attribut qui est l'attribut " name" et qui permet de dfinir le nom de l'instruction. Le reste des lments contenus dans l'instruction comme par exemple " type" et " href " doivent tre placs entre la balise ouvrante et fermante de la fonction : Code : XML <xsl:processing-instruction name="nom_instruction">reste de l'instruction</xsl:processing-instruction>
Exemple
Afin d'illustrer l'utilisation de cette fonction, je vous propose de continuer travailler avec le document XML que nous produisons depuis le dbut de ce chapitre. Ainsi, dans ce document XML, nous allons ajouter une nouvelle rfrence, un document XSLT fictif portant le nom " transformation.xsl " : Code : XML <xsl:template match="/"> <xsl:processing-instruction name="xmlstylesheet">type="text/xsl" href="transformation.xsl"</xsl:processing-instruction> <xsl:comment>ma couleur</xsl:comment> <xsl:element name="couleur"> <xsl:attribute name="primaire">oui</xsl:attribute> rouge </xsl:element> </xsl:template>
Le document XML produit est alors le suivant : Code : XML <?xml version="1.0" encoding="utf-8"?> <?xml-stylesheet type="text/xsl" href="transformation.xsl"?> <!--ma couleur--> <couleur primaire="oui">rouge</couleur>
La fonction copy-of
Dfinition
La fonction <xsl:copy-of />, permet de copier tel quel un nud et ses enfants dans le document que l'on souhaite produire. Cette fonction accepte uniquement l'attribut " select" qui permet de slectionner ne le nud copier en passant par une expression XPath : Code : XML <xsl:copy-of select= "expression XPath" />
www.openclassrooms.com
185/209
Exemple
Afin d'illustrer l'utilisation de cette fonction, nous allons transformer le document XML suivant : Code : XML <?xml version="1.0" encoding="UTF-8"?> <repertoire> <personne sexe="masculin"> <nom>DOE</nom> <prenom>John</prenom> </personne> <personne sexe="feminin"> <nom>POPPINS</nom> <prenom>Marie</prenom> </personne> <personne sexe="masculin"> <nom>BATTE</nom> <prenom>Man</prenom> </personne> </repertoire>
Dans la transformation suivante, l'objectif sera de produire un document XML qui ne contient que les personnes de sexe fminin. V oici le template utiliser : Code : XML <xsl:template match="/"> <xsl:element name="repertoire"> <xsl:for-each select="repertoire/personne"> <xsl:if test="@sexe = 'feminin'"> <xsl:copy-of select="."/> </xsl:if> </xsl:for-each> </xsl:element> </xsl:template>
Le document XML produit est alors le suivant : Code : XML <?xml version="1.0" encoding="utf-8"?> <repertoire> <personne sexe="feminin"> <nom>POPPINS</nom> <prenom>Marie</prenom> </personne> </repertoire>
186/209
Cration d'un document XSLT V otre document XSLT n'est normalement pas vierge. V oici ce que vous devriez avoir : Code : XML <?xml version="1.0" encoding="UTF-8"?> <!-- New document created with EditiX at Tue Nov 05 22:29:40 CET 2013 --> <xsl:stylesheet version="1.0"
www.openclassrooms.com
187/209
Remplacez le contenu par notre vritable transformation : Code : XML <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:output method="html" encoding="UTF-8" doctype-public="-//W3C//DTD HTML 4.01//EN" doctype-system="http://www.w3.org/TR/html4/strict.dtd" indent="yes" /> <xsl:template match="/"> <html> <head> <title>Mon rpertoire tlphonique</title> <link type="text/css" rel="stylesheet" href="style.css"/> </head> <body> <xsl:for-each select="repertoire/personne"> <p><xsl:value-of select="nom"/></p> </xsl:for-each> </body> </html> </xsl:template> </xsl:stylesheet>
Enregistrez ensuite votre document avec le nom transformation.xsl au mme endroit que votre document XML.
www.openclassrooms.com
188/209
Fentre d'excution d'une transformation XSLT Lorsque tout est correctement paramtr, cliquez sur le bouton " Ok " pour appliquer la transformation. Une fois celle-ci termine et en cas de succs, le message suivant doit normalement apparatre l'cran :
www.openclassrooms.com
189/209
Message indiquant que la transformation XSLT a t appliqu V ous pouvez maintenant vrifier que le document HTML produit contient bien le rsultat attendu. A noter : un aperu du rsultat de la transformation est disponible dans le module " XSLT Preview Result" situ en bas de votre cran lorsque votre document XSLT est ouvert :
Rsultat de la transformation XSLT Il est possible de dclarer des variables dans un document XSLT grce la balise <xsl:variable />. Pour utiliser une variable, il suffit de prcder son nom par le symbole " $ ". Il est possible de faire passer des informations d'un template un autre sous la forme de paramtres .
www.openclassrooms.com
190/209
Le sujet L'nonc
Dans ce TP, le travail demand consiste transformer un document XML comportant un rpertoire tlphonique en un document HTML dont le rendu final doit tre le suivant :
Comme vous pouvez le constater sur la capture d'cran ci-dessus, il vous faudra galement styliser le document HTML l'aide d'un peu de CSS en respectant les rgles suivantes : Le nom et le prnom d'une personne sont des titres de catgories 1. L'adresse d'une personne doit tre crite en italique. Les enttes des listes des numros de tlphone et des adresses e-mails sont des titres de catgories 2. Les listes sont des vraies listes HTML. La couleur de fond est bleue pour un homme et rose pour une femme. Les numros de tlphone et les adresses e-mails apparaissent uniquement si la personne en possde.
www.openclassrooms.com
191/209
Le document XML
Le document XML transformer est le suivant : Code : XML <?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <repertoire> <!-- John DOE --> <personne sexe="masculin"> <nom>DOE</nom> <prenom>John</prenom> <adresse> <numero>7</numero> <voie type="impasse">impasse du chemin</voie> <codePostal>75015</codePostal> <ville>PARIS</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="fixe">01 02 03 04 05</telephone> <telephone type="portable">06 07 08 09 10</telephone> </telephones> <emails> <email type="personnel">john.doe@wanadoo.fr</email> <email type="professionnel">john.doe@societe.com</email> </emails> </personne> <!-- Marie POPPINS --> <personne sexe="feminin"> <nom>POPPINS</nom> <prenom>Marie</prenom> <adresse> <numero>28</numero> <voie type="avenue">avenue de la rpublique</voie> <codePostal>13005</codePostal> <ville>MARSEILLE</ville> <pays>FRANCE</pays> </adresse> <telephones> <telephone type="professionnel">04 05 06 07 08</telephone> </telephones> <emails> <email type="professionnel">contact@poppins.fr</email> </emails> </personne> <!-- Batte MAN --> <personne sexe="masculin"> <nom>MAN</nom> <prenom>Batte</prenom> <adresse> <numero>24</numero> <voie type="avenue">impasse des hros</voie> <codePostal>11004</codePostal> <ville>GOTHAM CITY</ville> <pays>USA</pays> </adresse> <telephones> <telephone type="professionnel">01 03 05 07 09</telephone> </telephones> </personne> </repertoire>
Une solution
www.openclassrooms.com
192/209
La transformation XSLT
Code : XML <?xml version="1.0" encoding="UTF-8" ?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:output method="html" encoding="UTF-8" doctype-public="-//W3C//DTD HTML 4.01//EN" doctype-system="http://www.w3.org/TR/html4/strict.dtd" indent="yes" /> <xsl:template match="/"> <html> <head> <title>Mon rpertoire tlphonique</title> <link type="text/css" rel="stylesheet" href="style.css"/> </head> <body> <table> <xsl:for-each select="repertoire/personne"> <xsl:choose> <xsl:when test="@sexe = 'masculin'"> <xsl:call-template name="homme"> <xsl:with-param name="personne" select="." /> </xsl:call-template> </xsl:when> <xsl:otherwise> <xsl:call-template name="femme"> <xsl:with-param name="personne" select="." /> </xsl:call-template> </xsl:otherwise> </xsl:choose> </xsl:for-each> </table> </body> </html> </xsl:template> <xsl:template name="homme"> <xsl:param name="personne" /> <tr> <td class="homme"> <xsl:call-template name="afficherPersonne"> <xsl:with-param name="personne" select="$personne" /> </xsl:call-template> </td> </tr> </xsl:template> <xsl:template name="femme"> <xsl:param name="personne" /> <tr> <td class="femme"> <xsl:call-template name="afficherPersonne"> <xsl:with-param name="personne" select="$personne" /> </xsl:call-template> </td>
www.openclassrooms.com
193/209
www.openclassrooms.com
194/209
Comme vous pouvez le constater, la transformation que j'ai choisie est base sur la capture de l'lment racine du document XML puis sur l'appel de diffrents templates par la fonction <xsl:call-template /> auxquels je fais passer les paramtres ncessaires au rendu HTML. Il ne s'agit bien videmment pas de LA solution unique et un rsultat identique peut tre atteint en choisissant d'utiliser la fonction <xsl:apply-templates />.
Le document HTML
Le document HTML produit est le suivant : Code : HTML <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Mon répertoire téléphonique</title> <link type="text/css" rel="stylesheet" href="style.css"> </head> <body> <table> <tr> <td class="homme"> <h1>DOE John</h1> <p class="adresse"> 7 impasse du chemin<br> 75015 PARIS<br> FRANCE </p> <h2>Numéros de téléphones :</h2> <ul> <li>fixe : 01 02 03 04 05</li> <li>portable : 06 07 08 09 10</li> </ul> <h2>Adresses Emails :</h2> <ul> <li>personnel : john.doe@wanadoo.fr</li> <li>professionnel : john.doe@societe.com</li> </ul> </td> </tr> <tr> <td class="femme"> <h1>POPPINS Marie</h1>
www.openclassrooms.com
195/209
Le document CSS
V oyons maintenant le document CSS associ. Comme vous pouvez le constater, il est trs basique : Code : CSS table { width: 100%; } td { } padding: 10px;
www.openclassrooms.com
Partie 5 : Annexes
196/209
Partie 5 : Annexes
www.openclassrooms.com
Partie 5 : Annexes
xmlns="mon_uri"
197/209
Illustrons alors la dclaration et l'utilisation d'un espace de noms par dfaut travers l'exemple d'un document xHTLM : Code : XML <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>Titre du document</title> </head> <body> <p> <img src="mon_image.png" alt="ma super image" /> <br/> <a href="mon_lien">Mon super lien !</a> </p> </body> </html>
Tous les lments utiliss dans ce document XML comme <head />, <title />, <body />, etc., font partie du vocabulaire d'une page xHTML. C'est grce la dclaration de l'espace de noms dans l'lment <html /> que nous pouvons utiliser les diffrents lments du vocabulaire tout en respectant les rgles qui rgissent leurs imbrications les uns par rapport aux autres.
Tout comme pour un espace de noms par dfaut, la dclaration d'un espace de noms avec prfixe se fait dans le premier lment qui utilise le vocabulaire, grce au mot clef xmlns:prefixe. Code : XML xmlns:prefixe="mon_uri"
Lorsqu'un espace de noms est dclar avec un prfixe, tous les lments qui appartiennent au vocabulaire, et donc l'espace de noms, doivent tre prcds par ce prfixe : Code : XML <prefixe:element />
Afin d'illustrer cette nouvelle notion, reprenons la page xHTML que nous avons avons crit plus haut et utilisons cette fois-ci un prfixe : Code : XML <http:html xmlns:http="http://www.w3.org/1999/xhtml">
www.openclassrooms.com
Partie 5 : Annexes
<http:head> <http:title>Titre du document</http:title> </http:head> <http:body> <http:p> <http:img src="mon_image.png" alt="ma super image" /> <http:br/> <http:a href="mon_lien">Mon super lien !</http:a> </http:p> </http:body> </http:html>
198/209
DocBook
DocBook permet de dcrire des documents techniques comme des livres, des articles, etc.
www.openclassrooms.com
Partie 5 : Annexes
Cet espace de noms est identifi par l'URI http://docbook.org/ns/docbook
199/209
MathML
MathML est une spcification du W3C qui permet d'afficher lments mathmatiques divers et varis comme des additions, des soustractions, des matrices, etc. Cet espace de noms est identifi par l'URI http://www.w3.org/1998/Math/MathML
Schma XML
Il s'agit d'une spcification du W3C qui permet de dcrire des Schmas XML. Cet espace de noms est identifi par l'URI http://www.w3.org/2001/XMLSchema
SVG
SVG pour Scalable Vector Graphics est une spcification du W3C qui permet de dcrire des images vectorielles. Cet espace de noms est identifi par l'URI http://www.w3.org/2000/svg
XLink
Il s'agit d'une spcification du W3C permettant de crer des liens entre plusieurs fichiers XML. Cet espace de noms est identifi par l'URI http://www.w3.org/1999/xlink
XSLT
XSLT pour eXtensible Stylesheet Language Transformations est une spcification du W3C qui permet de dcrire des transformations appliquer un document XML. Cet espace de noms est identifi par l'URI http://www.w3.org/1999/XSL/Transform Un espace de noms est identifi de manire unique par une URI. Un espace de noms se dclare dans le premier lment qui utilise son vocabulaire. Un espace de noms se dclare grce l'attribut xmlns .
www.openclassrooms.com
Partie 5 : Annexes
200/209
Ou crire le CSS ?
V ous commencez le comprendre, en informatique, on aime bien sparer les diffrentes technologies dans diffrents fichiers. Le CSS ne fait pas exception la rgle. Ainsi, nos lignes de CSS seront crites dans un fichier portant l'extension de fichier .css .
Prenons par exemple le document XML suivant : Code : XML <?xml version = "1.0" encoding="UTF-8"> <?xml-stylesheet href="personne.css" type="text/css" ?> <personne> <nom>NORRIS</nom> <prenom>Chuck</prenom> </personne>
Dans cet exemple, l'affichage du document XML sera stylis grce au document CSS personne.css.
www.openclassrooms.com
Partie 5 : Annexes
201/209
Syntaxe du CSS
Comme tous les langages, le CSS dispose d'une syntaxe qui lui est propre. L'ide du langage est de slectionner un ou plusieurs lments d'un document afin d'y appliquer un certain nombre de proprits. Dans ce chapitre, je ne vais pas revenir sur l'ensemble des proprits qui existent en CSS. Cependant, je vous encourage lire le mmo crit par M@teo21 dans son tutoriel sur le HTML5 et le CSS3.
Illustrons cette premire rgle grce un exemple. Soit le document XML suivant reprsentant une liste de personnes : Code : XML <?xml version="1.0" encoding="UTF-8"?> <?xml-stylesheet href="personnes.css" type="text/css" ?> <personnes> <personne> <nom>NORRIS</nom> <prenom>Chuck</prenom> </personne> <personne> <nom>DUPONT</nom> <prenom>Marie</prenom> </personne> </personnes>
Si je souhaite par exemple afficher les prnoms des diffrentes personnes en rouge, gras et italique. crivons alors le contenu du fichier personnes.css : Code : CSS nom { color:red; font-weight:bold; font-style:italic; }
Si vous ouvrez votre document XML dans un navigateur web, vous devriez alors avoir l'affichage indiqu sur la figure suivante.
www.openclassrooms.com
Partie 5 : Annexes
202/209
Affichage du document XML stylis dans un navigateur web Comme on le souhaitait, les noms des personnes sont bien crits en rouge, gras et italique.
Comment faire si je souhaite, par exemple, afficher le nom des hommes en bleu et celui des femmes en roses ? Pour arriver ce rsultat, il convient de slectionner une personne en fonction de l'attribut sexe. Pour slectionner une balise particulire en fonction de la valeur d'un attribut en CSS, on utilise la syntaxe suivante : Code : CSS balise[attribut="valeur"] { proprit1 : valeur; proprit2: valeur; }
Tentons alors d'appliquer le style suivant notre document XML : Code : CSS personne[sexe="masculin"] { color:blue; } personne[sexe="feminin"] { color:pink; }
www.openclassrooms.com
Partie 5 : Annexes
203/209
Si l'on affiche le document XML dans un navigateur web, on obtient le rsultat affich en figure suivante.
Affichage du document XML stylis dans un navigateur web On s'approche du rsultat souhait, mais ce n'est pas encore tout fait a. En effet, actuellement, les noms et prnoms des personnes sont colores, or ce que l'on souhaite nous, c'est qu'uniquement des noms des personnes soient colors. Il nous suffit de lgrement modifier notre feuille de style : Code : CSS personne[sexe="masculin"] nom { color:blue; } personne[sexe="feminin"] nom { color:pink; }
Comme vous pouvez le constater, on a ajout l'lment nom au niveau de notre slection. En franais, on pourrait traduire ces lignes de CSS par les 2 phrases suivantes : Ecrit en bleu le nom des personnes de sexe masculin. Ecrit en rose le nom des personnes de sexe fminin.
Finalement, si vous affichez le document XML dans un navigateur web, vous devriez avoir le rsultat affich en figure suivante, correspondant bien nos attentes.
www.openclassrooms.com
Partie 5 : Annexes
204/209
Si vous essayez de lancer la vrification du document, vous devriez normalement avoir ce message (voir la figure suivante).
Partie 5 : Annexes
205/209
Pour crer un nouveau document, vous pouvez slectionner dans la barre de menu File puis New ou utiliser le raccourci clavier Ctrl + N. Dans la liste qui s'affiche, slectionnez CSS , comme indiqu sur la figure suivante.
Cration d'une feuille de style CSS V otre document CSS n'est normalement pas vierge. V oici ce que vous devriez avoir : Code : CSS /* Generated with EditiX at Sat May 11 19:46:07 CEST 2013 */
Replacez le contenu par notre vritable CSS : Code : CSS personne[sexe="masculin"] nom { color:blue; } personne[sexe="feminin"] nom { color:pink; }
Enregistrez ensuite votre document avec le nom personnes.css au mme endroit que votre document XML.
V ous devriez normalement avoir un message indiquant que votre CSS est correct, comme l'illustre la figure suivante.
www.openclassrooms.com
Partie 5 : Annexes
206/209
Message indiquant que le document CSS est correct Lorsque tout est correct, ouvrez votre fichier XML dans un navigateur web pour observer le rsultat.
Le document XML
V oici le document XML mettre en forme : Code : XML <?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <personnes> <personne sexe="masculin"> <identite> <nom>NORRIS</nom> <prenom>Chuck</prenom> </identite> <telephones> <telephone type="fixe">01 02 03 04 05</telephone> <telephone type="portable">06 07 08 09 10</telephone> </telephones> </personne> <personne sexe="feminin"> <identite> <nom>DUPONT</nom> <prenom>Marie</prenom> </identite> <telephones> <telephone type="bureau">04 05 06 07 08</telephone> </telephones> </personne> <personne sexe="masculin"> <identite> <nom>PAUL</nom> <prenom>Bernard</prenom> </identite> <telephones> <telephone type="portable">07 08 09 10 11</telephone> </telephones> </personne> </personnes>
La mise en forme
V oici en figure suivante une capture d'cran de la mise en forme que vous devez reproduire.
www.openclassrooms.com
Partie 5 : Annexes
207/209
Mise en page reproduire Comme vous pouvez le constater, l'identit d'une personne de sexe masculin est sur fond bleu tandis que celle d'une personne de sexe fminin est sur fond rose. Tous les numros de tlphone sont sur fond gris.
Une solution
Pour ne pas changer, voici un exemple de solution.
Le fichier XML
Tout d'abord, voyons le document XML avec le fichier de style CSS rfrenc : Code : XML <?xml version="1.0" encoding="UTF-8"?> <?xml-stylesheet href="personnes.css" type="text/css" ?> <personnes> <personne sexe="masculin"> <identite> <nom>NORRIS</nom> <prenom>Chuck</prenom> </identite> <telephones> <telephone type="fixe">01 02 03 04 05</telephone> <telephone type="portable">06 07 08 09 10</telephone> </telephones> </personne> <personne sexe="feminin"> <identite> <nom>DUPONT</nom> <prenom>Marie</prenom> </identite> <telephones> <telephone type="bureau">04 05 06 07 08</telephone> </telephones> </personne> <personne sexe="masculin"> <identite> <nom>PAUL</nom>
www.openclassrooms.com
Partie 5 : Annexes
<prenom>Bernard</prenom> </identite> <telephones> <telephone type="portable">07 08 09 10 11</telephone> </telephones> </personne> </personnes>
208/209
Le fichier CSS
Revenons maintenant sur le fichier CSS : Code : CSS personne { display:block; } identite { display:block; padding:10px; font-weight:bold; color:white; } personne[sexe="masculin"] identite { background-color:#008080; } personne[sexe="feminin"] identite { background-color:#FBA0FE; } telephones { display:block; background-color:#EEE; padding: 5px 10px; } telephone { display:block; }
Tout comme un document HTML, il est possible de styliser l'affichage d'un document XML dans un navigateur web. Une feuille de style CSS peut-tre directement applique un document XML.
www.openclassrooms.com