Vous êtes sur la page 1sur 208

Structurez vos donnes avec XML

Par Ludovic ROLAND (Wapiti89)

www.openclassrooms.com

Licence Creative Commons 4 2.0 Dernire mise jour le 15/01/2014

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

Les bons outils .................................................................................................................................................................. 9


L'diteur de texte ....................................................................................................................................................................................................... 10 Sous Windows .......................................................................................................................................................................................................... 10 Sous GNU/Linux ........................................................................................................................................................................................................ 11 Sous MAC OS X ........................................................................................................................................................................................................ 12 EditiX ......................................................................................................................................................................................................................... 13 La version payante .................................................................................................................................................................................................... 13 La version gratuite ..................................................................................................................................................................................................... 13 La mise en place sous GNU/Linux ............................................................................................................................................................................ 14 <oXygen/> XML Editor .............................................................................................................................................................................................. 15

Les lments de base ..................................................................................................................................................... 17


Les balises ................................................................................................................................................................................................................ Les balises par paires ............................................................................................................................................................................................... Les balises uniques ................................................................................................................................................................................................... Les rgles de nommage des balises ......................................................................................................................................................................... Les attributs ............................................................................................................................................................................................................... Dfinition ................................................................................................................................................................................................................... Quelques rgles ........................................................................................................................................................................................................ Les commentaires ..................................................................................................................................................................................................... 17 17 18 18 18 19 19 19

Votre premier document XML .......................................................................................................................................... 20


Structure d'un document XML ................................................................................................................................................................................... 21 Le prologue ............................................................................................................................................................................................................... 21 Le corps ..................................................................................................................................................................................................................... 22 Un document complet ............................................................................................................................................................................................... 22 Un document bien form ........................................................................................................................................................................................... 22 Utilisation d'EditiX ...................................................................................................................................................................................................... 23 Crer un nouveau document ..................................................................................................................................................................................... 23 Vrification du document ........................................................................................................................................................................................... 24 L'indentation .............................................................................................................................................................................................................. 25 L'arborescence du document .................................................................................................................................................................................... 25 Enregistrer votre document ....................................................................................................................................................................................... 25

TP : structuration d'un rpertoire ..................................................................................................................................... 26


L'nonc .................................................................................................................................................................................................................... 26 Exemple de solution .................................................................................................................................................................................................. 26 Quelques explications ............................................................................................................................................................................................... 27

Partie 2 : Crez des dfinitions pour vos documents XML ................................................................ 28


Introduction aux dfinitions et aux DTD .......................................................................................................................... 28
Qu'est-ce que la dfinition d'un document XML ? ..................................................................................................................................................... 28 Quelques dfinitions .................................................................................................................................................................................................. 28 Pourquoi crire des dfinitions ? ............................................................................................................................................................................... 28 Dfinition d'une DTD ................................................................................................................................................................................................. 28 Une dfinition rapide ................................................................................................................................................................................................. 28 O crire les DTD ? ................................................................................................................................................................................................... 29 Les lments ............................................................................................................................................................................................................. 29 La syntaxe ................................................................................................................................................................................................................. 29 Retour sur la balise ................................................................................................................................................................................................... 29 Retour sur le contenu ................................................................................................................................................................................................ 29 Structurer le contenu des balises .............................................................................................................................................................................. 32 La squence .............................................................................................................................................................................................................. 32 La liste de choix ........................................................................................................................................................................................................ 33 La balise optionnelle ................................................................................................................................................................................................. 34 La balise rpte optionnelle .................................................................................................................................................................................... 34 La balise rpte ....................................................................................................................................................................................................... 35

DTD : les attributs et les entits ...................................................................................................................................... 36


Les attributs ............................................................................................................................................................................................................... La syntaxe ................................................................................................................................................................................................................. Retour sur la balise et l'attribut .................................................................................................................................................................................. Retour sur le type ...................................................................................................................................................................................................... Retour sur le mode .................................................................................................................................................................................................... Les entits ................................................................................................................................................................................................................. Dfinition ................................................................................................................................................................................................................... Les entits gnrales ................................................................................................................................................................................................ Les entits paramtres .............................................................................................................................................................................................. 37 37 37 37 40 42 42 42 43

www.openclassrooms.com

Sommaire

3/209

Les entits externes .................................................................................................................................................................................................. 44

DTD : o les crire ? ....................................................................................................................................................... 46


Les DTD internes ...................................................................................................................................................................................................... 46 Dfinition ................................................................................................................................................................................................................... 46 La syntaxe ................................................................................................................................................................................................................. 46 Illustrons avec un exemple ........................................................................................................................................................................................ 46 Les DTD externes ..................................................................................................................................................................................................... 47 Dfinition ................................................................................................................................................................................................................... 47 La syntaxe ................................................................................................................................................................................................................. 48 Retour sur le prologue ............................................................................................................................................................................................... 50 Un exemple avec EditiX ............................................................................................................................................................................................ 50 Cration du document XML ....................................................................................................................................................................................... 50 Cration du document DTD ....................................................................................................................................................................................... 51 Vrification de la DTD ............................................................................................................................................................................................... 52 Vrification du document XML .................................................................................................................................................................................. 52

TP : dfinition DTD d'un rpertoire .................................................................................................................................. 54


L'nonc .................................................................................................................................................................................................................... 54 Une solution .............................................................................................................................................................................................................. 55 Un bref commentaire ................................................................................................................................................................................................. 56

Schma XML : introduction ............................................................................................................................................. 56


Les dfauts des DTD ................................................................................................................................................................................................. 57 Un nouveau format .................................................................................................................................................................................................... 57 Le typage de donnes ............................................................................................................................................................................................... 57 Les apports des schmas XML ................................................................................................................................................................................. 57 Le typage des donnes ............................................................................................................................................................................................. 57 Les contraintes .......................................................................................................................................................................................................... 57 Des dfinitions XML .................................................................................................................................................................................................. 57 Structure d'un schma XML ...................................................................................................................................................................................... 57 L'extension du fichier ................................................................................................................................................................................................. 57 Le prologue ............................................................................................................................................................................................................... 58 Le corps ..................................................................................................................................................................................................................... 58 Rfrencer un schma XML ...................................................................................................................................................................................... 58 L'espace de noms ..................................................................................................................................................................................................... 58 La location ................................................................................................................................................................................................................. 58 Pour rsumer ............................................................................................................................................................................................................. 59

Schma XML : les lments simples .............................................................................................................................. 59


Les lments simples ................................................................................................................................................................................................ Dfinition ................................................................................................................................................................................................................... Quelques exemples .................................................................................................................................................................................................. Dclarer une balise comme un lment simple ........................................................................................................................................................ Valeur par dfaut et valeur inchangeable .................................................................................................................................................................. Les attributs ............................................................................................................................................................................................................... Dclarer un attribut .................................................................................................................................................................................................... Valeur par dfaut, obligatoire et inchangeable .......................................................................................................................................................... 60 60 60 60 61 62 62 63

Schma XML : les types simples .................................................................................................................................... 63


Les types chanes de caractres ............................................................................................................................................................................... 64 Le tableau rcapitulatif .............................................................................................................................................................................................. 64 Plus en dtails ........................................................................................................................................................................................................... 64 Les types dates ......................................................................................................................................................................................................... 68 Le tableau rcapitulatif .............................................................................................................................................................................................. 68 Plus en dtails ........................................................................................................................................................................................................... 68 Les types numriques ............................................................................................................................................................................................... 71 Le tableau rcapitulatif .............................................................................................................................................................................................. 71 Plus en dtails ........................................................................................................................................................................................................... 72 Les autres types ........................................................................................................................................................................................................ 75 Le tableau rcapitulatif .............................................................................................................................................................................................. 75 Plus en dtails ........................................................................................................................................................................................................... 75

Schma XML : les types complexes ............................................................................................................................... 77


Dfinition ................................................................................................................................................................................................................... 78 Bref rappel ................................................................................................................................................................................................................. 78 Les lments complexes ........................................................................................................................................................................................... 78 Dclarer un lment complexe ................................................................................................................................................................................. 78 Les contenus des types complexes .......................................................................................................................................................................... 79 Les contenus simples ................................................................................................................................................................................................ 79 Dfinition ................................................................................................................................................................................................................... 79 Quelques exemples .................................................................................................................................................................................................. 79 Du ct du Schma XML .......................................................................................................................................................................................... 79 Les contenus "standards" .......................................................................................................................................................................................... 81 Dfinition ................................................................................................................................................................................................................... 81 Quelques exemples .................................................................................................................................................................................................. 81 Balise contenant un ou plusieurs attributs ................................................................................................................................................................ 81 Balise contenant d'autres lments .......................................................................................................................................................................... 82 Cas d'un type complexe encapsulant un type complexe .......................................................................................................................................... 85 Les contenus mixtes ................................................................................................................................................................................................. 85 Dfinition ................................................................................................................................................................................................................... 85 Un exemple ............................................................................................................................................................................................................... 86 Du ct du Schma XML .......................................................................................................................................................................................... 86

Schma XML : aller plus loin ........................................................................................................................................... 87


Le nombre d'occurrences .......................................................................................................................................................................................... 88 Le cas par dfaut ....................................................................................................................................................................................................... 88 Le nombre minimum d'occurrences .......................................................................................................................................................................... 88 Le nombre maximum d'occurrences ......................................................................................................................................................................... 88

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

TP : Schma XML d'un rpertoire ................................................................................................................................. 110


L'nonc .................................................................................................................................................................................................................. 111 Une solution ............................................................................................................................................................................................................. 112 Un bref commentaire ............................................................................................................................................................................................... 114

Partie 3 : Traitez vos donnes XML ................................................................................................. 114


DOM : Introduction l'API ............................................................................................................................................. 115
Qu'est-ce que L'API DOM ? ..................................................................................................................................................................................... 115 La petite histoire de DOM ........................................................................................................................................................................................ 115 L'arbre XML ............................................................................................................................................................................................................. 115 Le vocabulaire et les principaux lments .............................................................................................................................................................. 116 Document ................................................................................................................................................................................................................ 117 Node ........................................................................................................................................................................................................................ 117 Element ................................................................................................................................................................................................................... 118 Attr ........................................................................................................................................................................................................................... 118 Text .......................................................................................................................................................................................................................... 119 Les autres lments ................................................................................................................................................................................................ 119

DOM : Exemple d'utilisation en Java ............................................................................................................................. 119


Lire un document XML ............................................................................................................................................................................................ Le document XML ................................................................................................................................................................................................... Mise en place du code ............................................................................................................................................................................................ Le code complet ...................................................................................................................................................................................................... Ecrire un document XML ......................................................................................................................................................................................... Le document XML ................................................................................................................................................................................................... Mise en place du code ............................................................................................................................................................................................ Le code complet ...................................................................................................................................................................................................... Qu'est-ce que l'API XPath ? .................................................................................................................................................................................... La petite histoire de XPath ...................................................................................................................................................................................... Un peu de vocabulaire ............................................................................................................................................................................................ Chemin relatif et chemin absolu .............................................................................................................................................................................. Les chemins absolus ............................................................................................................................................................................................... Les chemins relatifs ................................................................................................................................................................................................ Dissection d'une tape ............................................................................................................................................................................................ Les axes .................................................................................................................................................................................................................. Le tableau rcapitulatif ............................................................................................................................................................................................ Quelques abrviations ............................................................................................................................................................................................ Les tests de nuds ................................................................................................................................................................................................. Le tableau rcapitulatif ............................................................................................................................................................................................ Quelques exemples ................................................................................................................................................................................................ Quelques abrviations ............................................................................................................................................................................................ Les prdicats ........................................................................................................................................................................................................... Le tableau rcapitulatif ............................................................................................................................................................................................ Quelques exemples ................................................................................................................................................................................................ Quelques abrviations ............................................................................................................................................................................................ Un exemple avec EditiX .......................................................................................................................................................................................... Le document XML ................................................................................................................................................................................................... La vue XPath ........................................................................................................................................................................................................... Excuter une requte .............................................................................................................................................................................................. L'nonc .................................................................................................................................................................................................................. Le document XML ................................................................................................................................................................................................... Les expressions crire ......................................................................................................................................................................................... Une solution ............................................................................................................................................................................................................ Expression n1 ........................................................................................................................................................................................................ Expression n2 ........................................................................................................................................................................................................ Expression n3 ........................................................................................................................................................................................................ Expression n4 ........................................................................................................................................................................................................ Expression n5 ........................................................................................................................................................................................................ 120 120 120 126 128 128 128 134 137 137 137 139 140 141 142 142 142 143 143 143 143 145 146 146 146 148 149 149 150 150 152 152 153 153 153 153 153 154 154

XPath : Introduction l'API ........................................................................................................................................... 136

XPath : Localiser les donnes ....................................................................................................................................... 141

TP : des expressions XPath dans un rpertoire ........................................................................................................... 151

Partie 4 : Transformez vos documents XML ................................................................................... 154


Introduction XSLT ....................................................................................................................................................... 155
Qu'est-ce que XSLT ? ............................................................................................................................................................................................. 155 La petite histoire du XSLT ....................................................................................................................................................................................... 155 Comment a marche ? ............................................................................................................................................................................................ 155 Structure d'un document XSLT ................................................................................................................................................................................ 156

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

Les templates ................................................................................................................................................................ 159


Introduction aux templates ...................................................................................................................................................................................... 160 Structure d'un template ........................................................................................................................................................................................... 160 Aller plus loin ........................................................................................................................................................................................................... 160 Contenu d'un template ............................................................................................................................................................................................ 160 Introduction au contenu d'un template .................................................................................................................................................................... 160 Notre premier template ........................................................................................................................................................................................... 160 Les fonctions ........................................................................................................................................................................................................... 162 La fonction value-of ................................................................................................................................................................................................. 163 La fonction for-each ................................................................................................................................................................................................. 164 La fonction sort ........................................................................................................................................................................................................ 165 La fonction if ............................................................................................................................................................................................................ 167 La fonction choose .................................................................................................................................................................................................. 169 La fonction apply-templates .................................................................................................................................................................................... 170

Les templates : aller plus loin ........................................................................................................................................ 174


Les variables et la fonction call-template ................................................................................................................................................................ Les variables ........................................................................................................................................................................................................... La fonction call-template ......................................................................................................................................................................................... D'autres fonctions .................................................................................................................................................................................................... La fonction element ................................................................................................................................................................................................. La fonction attribute ................................................................................................................................................................................................. La fonction comment ............................................................................................................................................................................................... La fonction processing-instruction ........................................................................................................................................................................... La fonction copy-of .................................................................................................................................................................................................. Un exemple avec EditiX .......................................................................................................................................................................................... Cration du document XML ..................................................................................................................................................................................... Cration du document XSLT ................................................................................................................................................................................... Vrification du document XSLT ............................................................................................................................................................................... Appliquer une transformation .................................................................................................................................................................................. Le sujet .................................................................................................................................................................................................................... L'nonc .................................................................................................................................................................................................................. Le document XML ................................................................................................................................................................................................... Une solution ............................................................................................................................................................................................................ La transformation XSLT ........................................................................................................................................................................................... Le document HTML ................................................................................................................................................................................................. Le document CSS ................................................................................................................................................................................................... 174 174 177 181 181 182 183 183 184 185 185 186 187 188 190 190 191 191 192 194 195

TP : des transformations XSLT d'un rpertoire ............................................................................................................. 190

Partie 5 : Annexes ........................................................................................................................... 195


Les espaces de noms ................................................................................................................................................... 196
Dfinition ................................................................................................................................................................................................................. 196 Dfinition d'un espace de noms .............................................................................................................................................................................. 196 Identifier un espace de noms .................................................................................................................................................................................. 196 Utilisation d'un espace de noms .............................................................................................................................................................................. 196 Les espaces de noms par dfaut ............................................................................................................................................................................ 196 Les espaces de noms avec prfixe ......................................................................................................................................................................... 197 La porte d'un espace de noms .............................................................................................................................................................................. 198 Quelques espaces de noms utiliss rgulirement ................................................................................................................................................. 198 DocBook .................................................................................................................................................................................................................. 198 MathML .................................................................................................................................................................................................................... 199 Schma XML ........................................................................................................................................................................................................... 199 SVG ......................................................................................................................................................................................................................... 199 XLink ....................................................................................................................................................................................................................... 199 XSLT ........................................................................................................................................................................................................................ 199

Mettez en forme vos documents XML avec CSS .......................................................................................................... 200


Ecrire un document CSS ......................................................................................................................................................................................... Qu'est-ce que le CSS ? ........................................................................................................................................................................................... Ou crire le CSS ? .................................................................................................................................................................................................. Rfrencer le fichier CSS ........................................................................................................................................................................................ Syntaxe du CSS ...................................................................................................................................................................................................... Un exemple avec EditiX .......................................................................................................................................................................................... Cration du document XML ..................................................................................................................................................................................... Cration du document CSS .................................................................................................................................................................................... Vrification de fichier de style ................................................................................................................................................................................. TP : mise en forme d'un rpertoire .......................................................................................................................................................................... Le document XML ................................................................................................................................................................................................... La mise en forme .................................................................................................................................................................................................... Une solution ............................................................................................................................................................................................................ 200 200 200 200 200 204 204 204 205 206 206 206 207

www.openclassrooms.com

Partager

6/209

Structurez vos donnes avec XML

Par

Ludovic ROLAND (Wapiti89)

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.

Comment lire ce tutoriel ?

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

Structurez vos donnes avec XML

7/209

www.openclassrooms.com

Structurez vos donnes avec XML

8/209

Partie 1 : Les bases du XML

Qu'est-ce que le XML ?


V oici donc le tout premier chapitre de la longue srie que va comporter ce tutoriel. Je vous propose de tout d'abord faire connaissance avec cette technologie maintenant ge de plus de 10 ans. Ce premier chapitre sera donc l'occasion de dcouvrir ce qu'est le XML, son origine et les besoins auxquels cette technologie devait rpondre au moment de son laboration.

Qu'est ce que le XML ? Premire dfinition


Citation Le XML ou eX tensible Markup Language est un langage informatique de balisage gnrique.

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.

Un langage de balisage gnrique


Un langage de balisage est un langage qui s'crit grce des balises . Ces balises permettent de structurer de manire hirarchise et organise les donnes d'un document. Si vous ne savez pas ce qu'est une balise, ne vous inquitez pas, nous reviendrons sur ce terme un peu plus loin dans le cours.

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.

Une nouvelle dfinition


www.openclassrooms.com

Partie 1 : Les bases du XML

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.

Origine et objectif du XML La petite histoire du XML


V ous vous doutez bien que le langage XML n'a pas t cr dans le simple but de s'amuser. Sa cration avait pour objectif de rpondre un besoin trs prcis : l'change de donnes . Aux dbuts d'Internet, les ordinateurs et les programmes changeaient des donnes en utilisant des fichiers. Malheureusement, ces fichiers avaient bien souvent des rgles de formatage qui leur taient propres. Par exemple, les donnes taient spares par des points, des virgules, des espaces, des tirets, etc. Le problme avec ce systme est qu'il fallait sans cesse adapter les programmes au format du fichier ce qui reprsentait une charge de travail importante. Il a donc fallu rgler ce problme rapidement. Le langage SGML ou S tandard Generalized Markup Language est alors n. C'est un langage puissant, extensible et standard qui permet de dcrire l'aide de balises un ensemble de donnes. Mais ce langage, trs complexe, n'tait pas forcment compatible pour effectuer des changes sur le web. Un groupe d'informaticiens ayant de l'exprience dans le SGML et le web a alors dcid de se pencher sur le sujet. Le langage XML est donc n. Le XML 1.0 est devenu une recommandation du W3C (le " World Wild Web Consortium ") le 10 fvrier 1998. Depuis, les spcifications du langage ont volu, et la version 1.1 a t publie le 4 fvrier 2004. C'est pourtant la version 1.0 du langage XML qui est encore la plus utilise aujourd'hui et c'est cette version que nous allons tudier dans ce tutoriel.

Les objectifs du XML


Comme nous l'avons vu, l'objectif du XML est de faciliter les changes de donnes entre les machines. A cela s'ajoute un autre objectif important : dcrire les donnes de manire aussi bien comprhensible par les hommes qui crivent les documents XML que par les machines qui les exploitent. Le XML se veut galement compatible avec le web afin que les changes de donnes puissent se faire facilement travers le rseau Internet. Le XML se veut donc standardis, simple, mais surtout extensible et configurable afin que n'importe quel type de donnes puisse tre dcrit. Le XML a t cr pour faciliter les changes de donnes entre les machines et les logiciels. Le XML est un langage qui s'crit l'aide de balises . Le XML est une recommandation du W3C, il s'agit donc d'une technologie avec des rgles strictes respecter. Le XML se veut comprhensible par tous : les hommes comme les machines. Le XML nous permet de crer notre propre vocabulaire grce un ensemble de rgles et de balises personnalisables.

www.openclassrooms.com

Partie 1 : Les bases du XML

10/209

Les bons outils


Aprs ce premier chapitre, peu technique, destin vous introduire le XML, j'espre que l'utilit de ce dernier est plus claire dans vos esprits. Dans ce second chapitre, nous allons passer en revue les outils et tenter de comprendre les logiciels qui nous seront utiles pour manipuler les diffrentes technologies que nous verrons tout au long de ce cours. L'utilisation d'outils spcialiss va nous faciliter la vie et nous permettre d'tre beaucoup plus productifs. En effet, tous proposent des fonctions clefs destines nous aider comme par exemple la coloration syntaxique ou encore la validation de documents . Je vous encourage essayer vous-mmes les diffrents logiciels qui seront prsents dans ce chapitre et d'adopter celui qui vous correspond le plus.

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

Partie 1 : Les bases du XML

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

Partie 1 : Les bases du XML

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

Partie 1 : Les bases du XML

13/209

jEdit - photo issue du site officiel du projet

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.

Tlcharger EditiX 2013


La version gratuite
Heureusement, pour les pauvres Zros fauchs que nous sommes, une version gratuite existe ! Il s'agit d'une version allge d'Editix 2008 . Notez bien que cette version est rserve un usage non-commercial.

Tlcharger EditiX 2008, Lite Version


Puisque c'est cette version que je vais en partie utiliser dans la suite du tutoriel, je vous propose de dtailler la procdure de mise en place du logiciel sous GNU/Linux. Je ne dtaille pas la procdure d'installation sous Windows et MAC OS X puisqu'elle est des plus classique.

www.openclassrooms.com

Partie 1 : Les bases du XML

14/209

La mise en place sous GNU/Linux


Tlchargement et installation
Enregistrez larchive sur votre bureau puis lancez votre plus beau terminal afin de dbuter la procdure. Commencez par dplacer l'archive editix-free-2008.tar.gz frachement tlcharge dans le rpertoire /opt/ par la commande : Code : Console sudo mv ~/Bureau/editix-free-2008.tar.gz /opt/

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

Pour plus de confort, je vous propose plutt de crer un launcher.

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

Partie 1 : Les bases du XML


Une fentre devrait alors s'afficher :

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 :

Page de dmarrage de EditiX 2008 Lite Version

<oXygen/> XML Editor


www.openclassrooms.com

Partie 1 : Les bases du XML

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.

Tlcharger <oXygen/> XML Editor

<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

Partie 1 : Les bases du XML

17/209

Les lments de base


Avec les 2 prcdents chapitres, nous ne sommes pas encore rellement entrs dans le vif du sujet, ils taient simplement destins prparer le terrain. Maintenant, les choses srieuses commencent, nous allons entrer dans la partie pratique. Dans ce chapitre, nous allons dcouvrir ensemble les bases du XML. Aprs l'avoir lu, les mots clefs " balise" et " attribut" n'auront plus de secrets pour vous !

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 .

Les balises par paires


Dfinition
Les balises par paires sont composes en ralit de 2 balises que l'on appelle ouvrantes et fermantes . La balise ouvrante commence par < et se termine par > tandis que la balise fermante commence par </ et se termine par >. Par exemple : Code : XML <balise></balise>

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

Partie 1 : Les bases du XML


Code : XML <balise1> <balise2>10</balise2> </balise1>

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 !

Code : XML <balise1><balise2>Ceci est une chane de caractres</balise1></balise2>

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>

Les balises uniques


Une balise unique est en ralit une balise par paires qui n'a pas de contenu. V ous le savez, les informaticiens sont des fainants ! Ainsi, plutt que de perdre du temps ouvrir et fermer des balises sans rien crire entre, une syntaxe un peu spciale a t mise au point : Code : XML <balise />

Les rgles de nommage des balises


Ce qui rend le XML gnrique, c'est la possibilit de crer votre propre langage balis. Ce langage balis, comme son nom l'indique, est un langage compos de balises sauf qu'en XML, c'est vous qui choisissez leurs noms. L'exemple le plus connu des langages baliss de type XML est trs certainement le xHTML qui est utilis dans la cration de sites Internet. Il y a cependant quelques rgles de nommage respecter pour les balises de votre langage balis : Les noms peuvent contenir des lettres, des chiffres ou des caractres spciaux. Les noms ne peuvent pas dbuter par un nombre ou un caractre de ponctuation. Les noms ne peuvent pas commencer par les lettres XML (quelle que soit la casse). Les noms ne peuvent pas contenir d'espaces. On vitera les caractres - , ; . < et > qui peuvent tre mal interprts dans vos programmes.

www.openclassrooms.com

Partie 1 : Les bases du XML

19/209

Les attributs Dfinition


Il est possible d'ajouter nos balises ce qu'on appelle des attributs . Tout comme pour les balises, c'est vous qui en choisissez le nom. Un attribut peut se dcrire comme une option ou une donne cache. Ce n'est pas l'information principale que souhaite transmettre la balise, mais il donne des renseignements supplmentaires sur son contenu. Pour que ce soit un peu plus parlant, voici tout de suite un exemple : Code : XML <prix devise="euro">25.3</prix>

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

Partie 1 : Les bases du XML


Deux types de balises existent : les balises par paires et les balises uniques . Les balises peuvent contenir des attributs . Un document XML peut contenir des commentaires .

20/209

www.openclassrooms.com

Partie 1 : Les bases du XML

21/209

Votre premier document XML


Dans le chapitre prcdent, nous avons dcouvert les lments de base du XML, mais vous ignorez encore comment crire un document XML. Ne vous inquitez pas, ce chapitre a pour objectif de corriger ce manque. Dans ce chapitre, nous allons donc nous attaquer tout ce qui se rattache l'criture d'un document XML. Ce sera l'occasion de dcouvrir la structure gnrale d'un document ainsi que nouvelles notions clefs. Nous finirons par nous lancer dans la pratique, seulement un petit peu, rassurez-vous, travers l'utilisation du logiciel EditiX afin d'crire notre premier document XML en bonne et due forme !

Structure d'un document XML


Un document XML peut tre dcoup en 2 parties : le prologue et le corps .

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

Partie 1 : Les bases du XML


acceptez le fait que nos documents sont tous autonomes.

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>

Un document bien form


Quand vous entendrez parler de XML, vous entendrez souvent parler de document XML bien form ou well-formed en anglais. Cette notion dcrit en ralit un document XML conforme aux rgles syntaxiques dcrites tout au long de cette premire partie du tutoriel. On peut rsumer un document XML bien form un document XML avec une syntaxe correcte, c'est--dire : S'il s'agit d'un document utilisant la version 1.1 du XML, le prologue est bien renseign. Le document XML ne possde qu'une seule balise racine. Le nom des balises et des attributs est conforme aux rgles de nommage. Toutes les balises en paires sont correctement fermes. Toutes les valeurs des attributs sont entre guillemets simples ou doubles. Les balises de votre document XML ne se chevauchent pas, il existe une arborescence dans votre document.

www.openclassrooms.com

Partie 1 : Les bases du XML

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>

Crer un nouveau document


Commencez par lancer EditiX. Pour crer un nouveau document, vous pouvez cliquer sur l'icne suivante : puis New ou encore utiliser le raccourci clavier Ctrl + N. Dans la liste qui s'affiche, slectionnez Standard XML document , comme indiqu sur la figure suivante : puis slectionner dans la barre de menu File

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

Partie 1 : Les bases du XML

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

Partie 1 : Les bases du XML

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.

Enregistrer votre document


Il est maintenant temps de clore ce chapitre en enregistrant votre document XML. Pour ce faire, vous pouvez cliquer sur l'icne suivante : ou bien slectionner dans la barre de menu File puis Save ou encore utiliser le raccourci clavier Ctrl + S.

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

Partie 1 : Les bases du XML

26/209

TP : structuration d'un rpertoire


V oici donc le premier TP de ce tutoriel ! L'objectif de ces chapitres TP, un peu particuliers, est de vous inviter vous lancer dans la pratique l'aide de tous les lments thoriques que vous avez lu au cours des chapitres prcdents. Cela me semble indispensable pour s'assurer que vous avez bien compris toutes les notions abordes jusqu' maintenant. Dans ce premier TP, l'objectif est de vous montrer une utilisation concrte de structuration de donnes via XML.

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

Partie 1 : Les bases du XML


</adresse> <telephones> <telephone type="professionnel">04 05 06 07 08</telephone> </telephones> <emails> <email type="professionnel">contact@poppins.fr</email> </emails> </personne> </repertoire>

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.

Numros de tlphone et adresses e-mails


Encore une fois, dans un soucis d'arborescence logique, j'ai dcid de crer les blocs <telephones /> et <emails /> qui contiennent respectivement l'ensemble des numros de tlphone et des adresses e-mail. Pour chacune des balises <telephone/> et <email/>, j'ai dcid d'y mettre un attribut type. Cet attribut permet de renseigner si l'adresse e-mail ou le numro de tlphone est par exemple professionnel ou personnel. Bien qu'indispensable aussi bien aux tres humains qu'aux machines, cette information est place dans un attribut car ce n'est pas l'information principale que l'on souhaite transmettre. Ici, l'information principale reste le numro de tlphone ou l'adresse email et non son type.

www.openclassrooms.com

Partie 1 : Les bases du XML

28/209

Partie 2 : Crez des dfinitions pour vos documents XML

Introduction aux dfinitions et aux DTD


Dans la premire partie, nous avons dcouvert ce qu'tait le XML. Pour ne rien vous cacher, le XML est trs peu utilis seul et on prfre souvent l'utiliser en parallle d'autres technologies permettant d'tendre les possibilits de la technologie. L'tude de ces autres technologies dbute donc maintenant ! Nous allons aborder les technologies qui permettent de dfinir une structure stricte aux documents XML : les fichiers de dfinition. Il existe plusieurs technologies qui permettent d'crire des fichiers de configuration, nous en verrons 2 dans cette seconde partie. Dbutons tout de suite avec les DTD.

Qu'est-ce que la dfinition d'un document XML ?


Avant de foncer tte baisse dans la seconde partie de ce cours, il est indispensable de revenir sur quelques termes qui seront importants pour la suite de ce tutoriel.

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.

Pourquoi crire des dfinitions ?


V ous vous demandez certainement quoi servent ces dfinitions et pourquoi on les utilise, n'est-ce pas ? Associer une dfinition un document oblige une certaine rigueur dans l'criture de vos donnes XML. C'est d'autant plus important lorsque plusieurs personnes travaillent sur un mme document. La dfinition impose ainsi une criture uniforme que tout le monde doit respecter. On vite ainsi que l'criture d'un document soit anarchique et, par consquent, difficilement exploitable.

Exploitable oui ! Mais par qui ?

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.

Dfinition d'une DTD Une dfinition rapide


www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


Une Document Type Definition ou en franais une Dfinition de Type de Document, souvent abrg DTD, est la premire technologie que nous allons tudier pour crire les dfinitions de nos documents 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.

O crire les DTD ?


Tout comme les fichiers XML, les DTD s'crivent dans des fichiers. Nous reviendrons sur ce point un peu plus tard, mais sachez ds prsent qu'il existe 2 types de DTD : les DTD externes et les DTD internes . Les rgles des DTD internes s'crivent directement dans le fichier XML qu'elles dfinissent tandis que les rgles des DTD externes sont crites dans un fichier spar portant lextension .dtd . Maintenant que vous en savez un peu plus, je vous propose de rentrer dans le vif du sujet.

Les lments La syntaxe


Pour dfinir les rgles portant sur les balises , on utilise le mot clef ELEMENT. Code : XML <!ELEMENT balise (contenu)>

Une rgle peut donc se dcouper en 3 mots clefs : ELEMENT, balise et contenu.

Retour sur la balise


Le mot-clef balise est remplacer par le nom de la balise laquelle vous souhaitez appliquer la rgle. Pour exemple, reprenons une balise du TP de la partie 1 : Code : XML <nom>DOE</nom>

On crira alors : Code : XML <!ELEMENT nom (contenu)>

Retour sur le contenu


www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


Cet emplacement a pour vocation de dcrire ce que doit contenir la balise : est-ce une autre balise ou est-ce une valeur ?

30/209

Cas d'une balise en contenant une autre


Par exemple, regardons la rgle suivante : Code : XML <!ELEMENT personne (nom)> <!-- suite de la DTD -->

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.

Cas d'une balise contenant une valeur


Dans le cas o notre balise contient une valeur simple, on utilisera la mot clef #PCDATA Une valeur simple dsigne par exemple une chane de caractres, un entier, un nombre dcimal, un caractre, etc. En se basant sur l'exemple exemple prcdent : Code : XML <personne> <nom>John DOE</nom> </personne>

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

Partie 2 : Crez des dfinitions pour vos documents XML


<!ELEMENT nom (#PCDATA)>

31/209

Au final, la DTD de notre document XML est donc la suivante : Code : XML <!ELEMENT personne (nom)> <!ELEMENT nom (#PCDATA)>

Cas d'une balise vide


Il est galement possible d'indiquer qu'une balise ne contient rien grce au mot-clef EMPTY. Prenons les rgles suivantes : Code : XML <!ELEMENT personne (nom)> <!ELEMENT nom EMPTY>

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 !

Cas d'une balise pouvant tout contenir


Il nous reste un cas voir : celui d'une balise qui peut tout contenir, c'est dire, une autre balise, une valeur simple ou tout simplement tre vide. Dans ce cas, on utilise le mot-clef ANY. Prenons la rgle suivante : Code : XML <!ELEMENT personne (nom)> <!ELEMENT nom ANY>

Les documents XML suivants sont bien valides : Code : XML <!-- valeur simple --> <personne> <nom>John DOE</nom> </personne>

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


<!-- vide --> <personne> <nom /> </personne>

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!

Structurer le contenu des balises


Nous allons voir maintenant des syntaxes permettant d'apporter un peu de gnricit aux dfinitions DTD. Par exemple, un rpertoire contient gnralement un nombre variable de personnes, il faut donc permettre au document XML d'tre valide quel que soit le nombre de personnes qu'il contient.

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

Partie 2 : Crez des dfinitions pour vos documents XML


<!-- invalide --> <!-- il manque une balise --> <personne> <prenom>John</prenom> <age>24</age> </personne> <!-- invalide --> <!-- il y a une balise en trop qui plus est n'est pas dclare --> <personne> <nom>DOE</nom> <prenom>John</prenom> <age>24</age> <date>12/12/2012</date> </personne>

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

Partie 2 : Crez des dfinitions pour vos documents XML


<!-- invalide --> <!-- il manque une balise --> <personne />

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>

La balise rpte optionnelle


Une balise peut tre rpte plusieurs fois mme si elle est optionnelle. Pour indiquer une telle balise, on fait suivre son nom par une toile. Code : XML <!ELEMENT balise (balise2, balise3*, balise4)>

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML

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

Partie 2 : Crez des dfinitions pour vos documents XML

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

Partie 2 : Crez des dfinitions pour vos documents XML

37/209

DTD : les attributs et les entits


Dans le chapitre prcdent, nous avons vu comment dcrire les balises de nos documents XML, mais ce n'est pas suffisant pour pouvoir dcrire l'intgralit d'un document XML. En effet, rappelez vous qu'une balise peut contenir ce qu'on appelle des attributs . Il convient donc de dcrire les rgles relatives ces attributs. C'est ce que nous allons voir au cours de ce chapitre. Ce chapitre sera galement l'occasion de dcouvrir une nouvelle notion dont je n'ai pas encore parl : les entits . Je ne vous en dis pas plus pour le moment, je prfre garder un peu de suspens autour de la dfinition de cette notion et son utilisation.

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.

Retour sur la balise et l'attribut


Il n'est pas ncessaire de s'attarder trop longtemps sur le sujet, il suffit simplement d'crire le nom de la balise et de l'attribut concern par la rgle. Par exemple, reprenons une balise du TP de la partie 1 : Code : XML <personne sexe="masculin" />

On crira alors : Code : XML <!ATTLIST personne sexe type mode>

Retour sur le type


Cet emplacement a pour vocation de dcrire le type de l'attribut. Est-ce une valeur bien prcise ? Est-ce du texte ? Un identifiant ?

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

Partie 2 : Crez des dfinitions pour vos documents XML


<!ATTLIST balise attribut (valeur 1 | valeur 2 | valeur 3 | etc.) mode>

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" />

Cas d'un attribut ayant pour type du texte non "pars"


Derrire le terme " texte non "pars"" se cache en fait la possibilit de mettre ce que l'on veut comme valeur : un nombre, une lettre, une chane de caractres, etc. Il s'agit de donnes qui ne seront pas analyses par le "parseur" au moment de la validation et/ou l'exploitation de votre document XML. Dans le cas o notre attribut contient du texte non "pars", on utilise la mot clef CDATA. Code : XML <!ATTLIST balise attribut CDATA mode>

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

Partie 2 : Crez des dfinitions pour vos documents XML


<!-- valide --> <personne sexe="autre" /> <!-- valide --> <personne sexe="12" />

39/209

Cas d'un attribut ayant pour type un identifiant unique


Il est tout fait possible de vouloir qu'une balise possde un attribut permettant de l'identifier de manire unique. Prenons par exemple l'exemple d'une course pied. Dans le classement de la course, il y aura un unique vainqueur, un unique second et un unique troisime. Pour indiquer que la valeur de l'attribut est unique, on utilise le mot clef ID comme IDentifiant. Code : XML <!ATTLIST balise attribut ID mode>

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

Partie 2 : Crez des dfinitions pour vos documents XML


<!ATTLIST father id ID mode > <!ATTLIST child id ID mode father IDREF mode >

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.

Retour sur le mode


Cet emplacement permet de donner une information supplmentaire sur l'attribut comme par exemple une indication sur son obligation ou sa valeur.

Cas d'un attribut obligatoire


Lorsqu'on souhaite qu'un attribut soit obligatoirement renseign, on utilise le mot clef #REQUIRED. Par exemple, si l'on souhaite que le sexe d'une personne soit renseign, on utilisera la rgle suivante : Code : XML <!ATTLIST personne sexe (masculin|fminin) #REQUIRED>

V oici alors quelques exemple de documents XML possibles : Code : XML <!-- valide --> <personne sexe="masculin" /> <!-- valide --> <personne sexe="fminin" /> <!-- invalide --> <personne />

Cas d'un attribut optionnel

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


Si au contraire on souhaite indiquer qu'un attribut n'est pas obligatoire, on utilise le mot clef #IMPLIED.

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 />

Cas d'une valeur par dfaut


Il est galement possible d'indiquer une valeur par dfaut pour un attribut. Il suffit tout simplement d'crire cette valeur "en dur" dans la rgle. Par exemple, il est possible d'indiquer qu'une personne dont l'attribut sexe n'est pas renseign est un homme par dfaut grce la rgle suivante : Code : XML <!ATTLIST personne sexe CDATA "masculin">

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 />

Cas d'une constante


Enfin, il est possible de rendre obligatoire un attribut et de fixer sa valeur grce au mot clef #FIXED suivi de ladite valeur.

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML

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 .

Les entits gnrales


Dfinition
Les entits gnrales sont les entits les plus simples. Elles permettent d'associer un alias une information afin de l'utiliser dans le document XML.

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

Partie 2 : Crez des dfinitions pour vos documents XML


&nom;

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>

Les entits paramtres


Dfinition
Contrairement aux entits gnrales qui apparaissent dans les documents XML, les entits paramtres n'apparaissent que dans les dfinitions DTD. Elles permettent d'associer un alias une partie de la dclaration de la DTD.

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

Partie 2 : Crez des dfinitions pour vos documents XML

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.

Les entits externes


Dfinition
Il existe en ralit 2 types d'entits externes : les analyses et les non analyses . Dans le cadre de ce cours, nous nous limiterons aux entits externes analyses . Les entits externes analyses ont sensiblement le mme rle que les entits gnrales, c'est dire qu'elles permettent d'associer un alias une information afin de l'utiliser dans le document XML. Mais, dans le cas des entits externes analyses, les informations sont stockes dans un fichier spar.

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

Partie 2 : Crez des dfinitions pour vos documents XML

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

Partie 2 : Crez des dfinitions pour vos documents XML

46/209

DTD : o les crire ?


Au cours des derniers chapitres, nous avons tudi tout ce qu'il faut savoir ou presque sur les DTD. Il vous reste cependant encore une chose apprendre avant que vous puissiez tre indpendant et passer la pratique : o crire les DTD ? Ce dernier chapitre avant un TP sera galement l'occasion de vous rvler qu'il existe en ralit plusieurs sortes de DTD.

Les DTD internes


Comme je vous l'ai dj prcis dans le premier chapitre de cette seconde partie, on distingue 2 types de DTD : les internes et les externes . Commenons par tudier les DTD internes .

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.

Illustrons avec un exemple


Afin que tout cela vous paraisse moins abstrait, je vous propose de voir un exemple. Prenons l'nonc suivant : Citation : Enonc Une boutique possde plusieurs tlphones. Chaque tlphone est d'une certaine marque et d'un certain modle reprsent par une chane de caractre.

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

Partie 2 : Crez des dfinitions pour vos documents XML


<modele>iPhone 4</modele> </telephone> <telephone> <marque>Nokia</marque> <modele>Lumia 800</modele> </telephone> </boutique>

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 !

Les DTD externes Dfinition


Une DTD externe est une DTD qui est crite dans un autre document que le document XML. Si elle est crite dans un autre document, c'est que souvent, elle est commune plusieurs documents XML qui l'exploitent. De manire gnrale, afin de bien sparer le contenu XML de sa dfinition DTD, on prendra l'habitude de crer plusieurs fichiers afin de les sparer.

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


Un fichier contenant uniquement une DTD porte l'extension .dtd.

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.

Les DTD externes PUBLIC


Les DTD externes PUBLIC sont gnralement utilises lorsque la DTD est une norme. C'est par exemple cas dans les documents xHTML 1.0. La syntaxe est la suivante : Code : XML <!DOCTYPE racine PUBLIC "identifiant" "url">

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.

Les DTD externes SYSTEM


Une DTD externe SYSTEM permet d'indiquer au document XML l'adresse du document DTD. Cette adresse peut-tre relative ou absolue. V oyons plus prcisment la syntaxe : Code : XML <!DOCTYPE racine SYSTEM "URI">

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

Partie 2 : Crez des dfinitions pour vos documents XML


Pour rappel, voici le fichier XML : 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> <modele>iPhone 4</modele> </telephone> <telephone> <marque>Nokia</marque> <modele>Lumia 800</modele> </telephone> </boutique>

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

Partie 2 : Crez des dfinitions pour vos documents XML

50/209

Retour sur le prologue


Dans la partie prcdente de ce tutoriel, voici ce que je vous avais dit propos du fait que nos documents XML soient autonomes ou non : Citation : Wapiti89 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, acceptez le fait que nos documents sont tous autonomes.

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>

Un exemple avec EditiX


Pour clore ce chapitre, je vous propose de voir ensemble comment crire une DTD externe SYSTEM avec EditiX . Pour faire simple, je vous propose de garder l'exemple prcdent de la boutique de tlphone.

Cration du document XML


La cration du document XML n'a rien de bien compliqu puisque nous l'avons dj vu ensemble dans la partie prcdente. Pour ceux qui ne s'en souviennent pas, vous pouvez y jeter un coup dil ici. V oici le document que vous devez crire : Code : XML <?xml version = "1.0" encoding="UTF-8" standalone="no" ?>

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


<!DOCTYPE boutique SYSTEM "boutique.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>

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 du document DTD


Pour crer un nouveau document, vous pouvez cliquer sur l'icne encore utiliser le raccourci clavier Ctrl + N. Dans la liste qui s'affiche, slectionnez DTD (voir la figure suivante). , slectionner dans la barre de menu Filepuis Newou

Cration d'un document DTD V otre document DTD n'est normalement pas vierge. V oici ce que vous devriez avoir :

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


Code : XML <!-- DTD created at Wed Sep 12 14:49:47 CEST 2012 with EditiX. Please insert an encoding attribute header for converting any DTD -> <!ELEMENT tag (#PCDATA)> <!ATTLIST tag attribute CDATA #REQUIRED>

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 :

Message indiquant que le document DTD est correcte

Vrification du document XML


Il est maintenant temps de vrifier que le document XML est valide ! Pour ce faire, slectionnez dans la barre de menu XML puis Check this document ou encore en utilisant le raccourci clavier Ctrl + K. Le message suivant doit normalement s'afficher :

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


Message indiquant que le document XML est valide Les DTD internes s'crivent dans le document XML. Les DTD externes s'crivent dans un fichier diffrent de celui du document XML dont l'extension est .dtd. EditiX permet en quelque cliques de vrifier qu'un document DTD est correct et qu'un document XML est valide.

53/209

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML

54/209

TP : dfinition DTD d'un rpertoire


V otre apprentissage des DTD arrive donc son terme et rien ne vaut un TP pour le conclure ! Je vous propose donc de raliser la dfinition DTD d'un rpertoire. L'objectif est de mettre en pratique toutes les notions vues dans les parties prcdentes sur les DTD.

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

Partie 2 : Crez des dfinitions pour vos documents XML

55/209

Une dernire consigne : la DTD doit tre une DTD externe !

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

Partie 2 : Crez des dfinitions pour vos documents XML


<!ELEMENT personne (nom, prenom, adresse, telephones, emails)> <!ATTLIST personne sexe (masculin | feminin) #REQUIRED> <!-- Nom et prnom --> <!ELEMENT nom (#PCDATA)> <!ELEMENT prenom (#PCDATA)> <!-- Bloc adresse --> <!ELEMENT adresse (numero, voie, codePostal, ville, pays)> <!ELEMENT numero (#PCDATA)> <!ELEMENT voie (#PCDATA)> <!ATTLIST voie type CDATA #REQUIRED> <!ELEMENT codePostal (#PCDATA)> <!ELEMENT ville (#PCDATA)> <!ELEMENT pays (#PCDATA)> <!-- Bloc <!ELEMENT <!ELEMENT <!ATTLIST <!-- Bloc <!ELEMENT <!ELEMENT <!ATTLIST tlphone --> telephones (telephone+)> telephone (#PCDATA)> telephone type CDATA #REQUIRED> email --> emails (email+)> email (#PCDATA)> email type CDATA #REQUIRED>

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

Partie 2 : Crez des dfinitions pour vos documents XML

57/209

Schma XML : introduction


Dans les chapitres prcdents, nous avons tudi l'une des technologies permettant d'crire les dfinitions de documents XML : les DTD. Mais, comme je vous le disais dans le tout premier chapitre, une autre technologie permet elle aussi d'crire des dfinitions : les Schmas XML. Cette seconde technologie offre davantage de possibilits que les DTD, il va donc falloir vous accrocher !

Les dfauts des DTD


Peut-tre l'avez vous remarqu dans les prcdents chapitres, mais les DTD ont quelques dfauts.

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 apports des schmas XML


C'est pour pallier les dfauts des DTD que les Schmas XML ont t crs. S'ils proposent au minimum les mmes fonctionnalits que les DTD, ils en apportent galement de nouvelles. En voici quelques unes ple-mle.

Le typage des donnes


Les Schmas XML permettent tout d'abord de typer les donnes. Nous verrons galement dans la suite de ce tutoriel, qu'il est possible d'aller plus loin en crant nos propres types de donnes.

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.

Des dfinitions XML


Un des principaux avantages des Schmas XML est qu'ils s'crivent grce au XML. Ainsi, pour exploiter un document XML et le Schma qui lui est associ, vous n'avez en thorie plus besoin de plusieurs outils. Dornavant un seul suffit !

Structure d'un schma XML


Maintenant que vous en savez un peu plus sur les Schmas XML, je vous propose de voir les bases qui permettent de dfinir un Schma 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

Partie 2 : Crez des dfinitions pour vos documents XML

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:.

Rfrencer un schma XML


Le rfrencement d'un schma XML se fait au niveau de l'lment racine du fichier XML grce l'utilisation de 2 attributs.

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

Partie 2 : Crez des dfinitions pour vos documents XML


de noms.

59/209

Schma XML dcrivant un espace de noms


Code : XML xsi:schemaLocation="chemin_vers_fichier.xsd">

Schma XML ne dcrivant pas un espace de noms


Dans les prochains chapitre, c'est ce type de Schma XML que nous allons utiliser. On utilisera alors la syntaxe suivante : Code : XML xsi:noNamespaceSchemaLocation="chemin_vers_fichier.xsd">

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

Partie 2 : Crez des dfinitions pour vos documents XML

60/209

Schma XML : les lments simples


Dans le chapitre prcdent, nous avons vu que les Schmas XML permettent de pallier les faiblesses des DTD. Aprs avoir galement vu la structure d'un Schma XML, je vous propose d'aborder l'criture d'un Schma XML proprement parler. La premire notion que nous allons aborder ce que l'on appelle les lments simples .

Les lments simples Dfinition


Un lment simple est un lment qui ne contient qu'une valeur dont le type est dit simple. Il ne contient pas d'autres lments. Un lment simple peut donc tre une balise qui ne contient aucun attribut et dans laquelle aucune autre balise n'est imbrique. Un attribut d'une balise peut galement tre considr comme un lment simple. En effet, la valeur d'un attribut est un type simple. Nous verrons la liste complte des types simples un peu plus loin dans ce tutoriel, mais je peux dj vous citer quelques exemple afin de tenter d'claircir les choses. Un type simple, c'est par exemple un chiffre, une date ou encore une chane de caractres.

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.

Dclarer une balise comme un lment simple


Si vous souhaitez dclarer une balise en tant qu'lment simple, c'est le mot clef element qu'il faut utiliser. N'oubliez pas de prcder son utilisation par xsd: Cette balise prend 2 attributs : un nom et un type. Code : XML <xsd:element name="mon_nom" type="xsd:mon_type" />

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


V oyons tout de suite un exemple. Soit les lments simples suivants : Code : XML <nom>DUPONT</nom> <prenom>Robert</prenom> <age>38</age>

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" />

Que sont ces int et ces strings ?

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.

Valeur par dfaut et valeur inchangeable


Avant que l'on regarde ensemble la liste des types, j'aimerais revenir sur 2 concepts qui sont les valeurs par dfaut et les valeurs inchangeables .

Valeur par dfaut


Comme c'tait dj le cas dans les DTD, il est tout fait possible d'indiquer dans les Schmas XML qu'un lment a une valeur par dfaut. Pour rappel, la valeur par dfaut est la valeur que va prendre automatiquement un lment si aucune valeur n'est indique au niveau du fichier XML. Pour indiquer une valeur par dfaut, c'est l'attribut default qui est utilis au niveau de la balise <element /> du Schma XML. Par exemple, si je souhaite indiquer qu' dfaut d'tre renseign, le prnom d'une personne est Robert, je vais crire la rgle suivante : Code : XML <xsd:element name="prenom" type="xsd:string" default="Robert" />

V oici alors quelques exemple de documents XML possibles : Code : XML <!-- valide --> <prenom>Jean</prenom> <!-- valide --> <prenom>Marie</prenom>

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


<!-- valide --> <!-- la balise prenom vaut "Robert" --> <prenom />

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

Partie 2 : Crez des dfinitions pour vos documents XML

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 par dfaut, obligatoire et inchangeable


Valeur par dfaut
Comme c'tait dj le cas dans les DTD, il est tout fait possible d'indiquer dans les Schmas XML qu'un attribut a une valeur par dfaut. Pour rappel, la valeur par dfaut est la valeur prise automatiquement par un attribut si aucune valeur n'est indique au niveau du fichier XML. Pour indiquer une valeur par dfaut, c'est l'attribut default qui est utilis au niveau de la balise <attribut /> du Schma XML. Par exemple, si je souhaite indiquer qu' dfaut d'tre renseign, le prnom d'une personne est Robert, je vais crire la rgle suivante : Code : XML <xsd:attribut name="prenom" type="xsd:string" default="Robert" />

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

Partie 2 : Crez des dfinitions pour vos documents XML

64/209

Schma XML : les types simples


Dans le chapitre prcdent, nous avons vu comment dcrire les lments simples et les attributs . Nous avons galement appris que les valeurs possibles sont des valeurs dites de types simples comme par exemple un nombre entier ou une chane de caractres. Dans ce chapitre, nous allons voir en dtails les 4 grandes catgories des types simples, savoir les les chanes de caractres , les dates et les nombres . Ils manque une catgorie, me direz-vous. V ous avez raison ! Une quatrime catgorie intitule "divers", regroupe les autres types simples qu'il est possible d'utiliser.

Les types chanes de caractres Le tableau rcapitulatif


Type string Description reprsente une chane de caractres Commentaire attention aux caractres spciaux bas sur le type string bas sur le type normalizedString bas sur le type token bas sur le type token applicable uniquement aux attributs applicable uniquement aux attributs bas sur le type token bas sur le type Name bas sur le type NCName applicable uniquement aux attributs bas sur le type NCName applicable uniquement aux attributs applicable uniquement aux attributs bas sur le type NCName applicable uniquement aux attributs applicable uniquement aux attributs

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"

NMTOKENS Name NCName ID

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

rfrence une liste d'identifiants

ENTITY

reprsente une entit d'un document DTD

ENTITIES

reprsente une liste d'entits

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

Partie 2 : Crez des dfinitions pour vos documents XML


Code : XML <xsd:element name="string" type="xsd:string" />

65/209

Les diffrentes lignes XML ci-dessous sont alors valides : Code : XML <string>France</string> <string>Site du zro !</string> <string>&amp;</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

Partie 2 : Crez des dfinitions pour vos documents XML


<langue>en-US</langue>

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

Partie 2 : Crez des dfinitions pour vos documents XML

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" />

Code : XML <personne num="P1">Paul</personne> <personne num="P2">Marie</personne> <personne enfants="P1 P2">Jeanne</personne

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" />

Code : XML <!ENTITY samsung "Samsung"> <!ENTITY apple "Apple">

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


<telephone marque="apple">iPhone</personne> <telephone marque="samsung">Galaxy SII</personne>

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.

Les types dates Le tableau rcapitulatif


Type duration date time dateTime gYear Description reprsente une dure reprsente une date reprsente une heure reprsente une date et un temps reprsente une anne

gYearMonth reprsente une anne et un mois gMonth reprsente un mois

gMonthDay reprsente un mois et un jour gDay reprsente un jour

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

Partie 2 : Crez des dfinitions pour vos documents XML

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

Partie 2 : Crez des dfinitions pour vos documents XML

70/209

V oici quelques exemples : Code : XML <xsd:element name="monheure" type="xsd:time" />

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" />

Code : XML <!-- mars --> <mois>--03</mois>

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


<!-- dcembre --> <mois>--12</mois>

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>

Les types numriques Le tableau rcapitulatif


Type float double decimal integer long int short byte nonPositiveInteger negativeInteger Description reprsente un nombre flottant sur 32 bits conforme la norme IEEE 754 reprsente un nombre flottant sur 64 bits conforme la norme IEEE 754 reprsente une nombre dcimal reprsente un nombre entier reprsente un nombre entier reprsente un nombre entier reprsente un nombre entier reprsente un nombre entier reprsente un nombre entier non positif reprsente un nombre entier ngatif bas sur le type decimal bas sur le type integer bas sur le type long bas sur le type int bas sur le type short bas sur le type integer bas sur le type nonPositiveInteger bas sur le type integer Commentaire

nonNegativeInteger reprsente un nombre entier non ngatif

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


positiveInteger unsignedLong unsignedInt unsignedShort unsignedByte reprsente un nombre entier positif reprsente un nombre entier positif reprsente un nombre entier positif reprsente un nombre entier positif reprsente un nombre entier positif bas sur le type nonNegativeInteger bas sur le type nonNegativeInteger

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" />

Code : XML <nombre>42</nombre> <nombre>-42.25</nombre> <nombre>3E4</nombre> <nombre>10e-5</nombre>

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

Partie 2 : Crez des dfinitions pour vos documents XML


Comme pour le type float, les 3 valeurs suivantes peuvent tre ajoutes la liste : -INF pour moins l'infini. +INF pour plus l'infini. NaN pour Not a Number, c'est--dire pour dsigner une valeur non numrique.

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" />

Code : XML <nombre>42</nombre> <nombre>-42.25</nombre> <nombre>+.42</nombre> <nombre>00042.420000</nombre>

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

Partie 2 : Crez des dfinitions pour vos documents XML

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" />

Code : XML <nombre>-42</nombre> <nombre>0</nombre> <nombre>-00042</nombre>

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" />

Code : XML <nombre>42</nombre> <nombre>0</nombre> <nombre>+00042</nombre>

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

Partie 2 : Crez des dfinitions pour vos documents XML


073 709 551 615.

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.

Les autres types Le tableau rcapitulatif


Type boolean QName NOTATION anyURI Description reprsente l'tat vrai ou faux reprsente un nom qualifi reprsente une notation reprsente une URI

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

Partie 2 : Crez des dfinitions pour vos documents XML


<!-- Zozor est bien un animal --> <personne animal="true">Zozor</personne>

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

Partie 2 : Crez des dfinitions pour vos documents XML

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

Partie 2 : Crez des dfinitions pour vos documents XML

78/209

Schma XML : les types complexes


Dans les chapitres prcdents, nous avons vu les lments simples et les diffrentes familles de types simples. Malheureusement, toutes ces connaissances ne sont pas suffisantes si l'on souhaite pouvoir dcrire toutes les structures que les documents XML offrent. Pour pallier ce manque, nous allons maintenant aborder la suite du cours via l'tude d'un nouveau type d'lment : les lments complexes .

Dfinition Bref rappel


Au cours des chapitres prcdents, nous avons vu ensemble ce qu'est un lment simple, savoir un lment qui ne contient qu'une valeur dont le type est dit simple. Un lment simple ne contient pas d'autres lments ni aucun attribut. Nous avons galement vu comment dclarer un lment simple ainsi qu'un attribut. Cependant nous n'avons pas vu comment dclarer un attribut dans un lment. En effet, un lment qui possde un attribut n'est plus un lment simple. On parle alors d'lment complexe.

Les lments complexes


Un lment complexe est un lment qui contient d'autres lments ou des attributs. Bien videmment les lments contenus dans un lments peuvent galement contenir des lments ou des attributs. J'espre que vous suivez toujours ! Je vous propose de voir quelques exemples d'lments XML qui dans un Schma XML sont considrs comme complexes : Code : XML <!-- la balise personne contient d'autres balises => lment complexe --> <personne> <!-- la balise nom est un lment simple --> <nom>ROBERT</nom> <!-- la balise prenom est un lment simple --> <prenom>Axel</prenom> </personne> <!-- la balise personne possde un attribut => lment complexe --> <personne sexe="feminin">Axel ROBERT</personne>

Abordons maintenant diffrents exemples qui vont nous permettre de voir et de comprendre comment dclarer des lments complexes dans un Schma XML.

Dclarer un lment complexe


Si vous souhaitez dclarer une balise en tant qu'lment complexe, c'est le mot clef complexType qu'il faut utiliser associ celui que nous connaissons dj : element. N'oubliez pas de prcder son utilisation par xsd: Code : XML <xsd:element name="mon_nom"> <xsd:complexType> <!-- contenu ici --> <xsd:complexType> </xsd:element>

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


Nous reviendrons juste aprs sur la notion de contenu, ne vous inquitez pas. Reprenons l'un des lments de type complexe que nous avons vu un peu plus haut : Code : XML <personne> <nom>ROBERT</nom> <prenom>Axel</prenom> </personne>

79/209

V oici comment le dclarer : Code : XML <xsd:element name="personne"> <xsd:complexType> <!-- contenu ici --> </xsd:complexType> </xsd:element>

Les contenus des types complexes


Concernant les types complexes, il est important de noter qu'il existe 3 types de contenus possibles : Les contenus simples . Les contenus "standards". Les contenus mixtes .

Les contenus simples Dfinition


Le premier type de contenu possible pour un lment complexe est le contenu simple. On appelle contenu simple, le contenu d'un lment complexe qui n'est compos que d'attributs et d'un texte de type simple.

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

Partie 2 : Crez des dfinitions pour vos documents XML


<xsd:element name="mon_nom"> <xsd:complexType> <xsd:simpleContent> <xsd:extension base="mon_type"> <xsd:attribute name="mon_nom" type="mon_type" /> </xsd:extension> </xsd:simpleContent> </xsd:complexType> </xsd:element>

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

Partie 2 : Crez des dfinitions pour vos documents XML

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.

Les contenus "standards" Dfinition


Aprs les contenus simples, nous allons monter la barre d'un cran et nous attaquer aux contenus "standards". Il est important de noter que cette appellation n'est nullement officielle. C'est une appellation maison car il s'agit du cas de figure qui tendance revenir le plus souvent.

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" />

Balise contenant un ou plusieurs attributs


Je vous propose de dbuter par le cas de figure le plus simple, savoir celui d'un lment complexe qui ne contient que des attributs. Reprenons l'exemple de notre voiture du dessus : Code : XML <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

Partie 2 : Crez des dfinitions pour vos documents XML


par exemple le cas d'une balise contenant plusieurs attributs : Code : XML <voiture marque="Renault" modele="Clio" />

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.

Balise contenant d'autres lments


Il est maintenant temps de passer la suite et de jeter un coup dil aux balises qui contiennent d'autres lments.

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

Partie 2 : Crez des dfinitions pour vos documents XML

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

Partie 2 : Crez des dfinitions pour vos documents XML


Code : XML <!-- valide --> <personne sexe="masculin"> <nom>DUPONT</nom> <prenom>Robert</prenom> </prenom> <!-- valide --> <personne sexe="masculin"> <prenom>Robert</prenom> <nom>DUPONT</nom> </prenom>

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

Partie 2 : Crez des dfinitions pour vos documents XML


<prenom>Robert</prenom> </prenom> <!-- invalide => les 2 balises prenom et nom ne peuvent pas apparatre en mme temps --> <personne sexe="masculin"> <prenom>Robert</prenom> <nom>DUPONT</nom> </prenom>

85/209

Cas d'un type complexe encapsulant un type complexe


Avant de terminer cette partie, il nous reste un cas voir : celui d'un type complexe encapsulant galement un type complexe. Prenons par exemple le document XML suivant : Code : XML <?xml version="1.0" encoding="UTF-8"?> <personne> <identite> <nom>NORRIS</nom> <prenom>Chuck</prenom> </identite> </personne>

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 .

Les contenus mixtes Dfinition


Il est temps de conclure ce chapitre avec le dernier type de contenu possible : les contenus mixtes . Un contenu mixte est le contenu d'un lment complexe qui est compos d'attributs, d'lments et de texte.

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML

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>

La nouveaut est donc l'utilisation du mot clef mixed.

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

Partie 2 : Crez des dfinitions pour vos documents XML

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

Partie 2 : Crez des dfinitions pour vos documents XML

88/209

Schma XML : aller plus loin


Le prochain chapitre est l'occasion de terminer notre apprentissage des Schmas XML. Ce chapitre regroupe de nombreuses notions qui vous seront utiles pour dcrire tous les documents XML possibles et imaginables. Ce chapitre s'annonce trs dense, accrochez-vous, le rsultat en vaut la peine ! Au programme : la gestion du nombre d'occurrences d'un lment, la rutilisation des lments , l'hritage, les identifiants et pour terminer EditiX !

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.

Le cas par dfaut


Le cas par dfaut est celui que nous avons vu jusqu' maintenant. Lorsque le nombre d'occurrences n'est pas prcis, la balise doit apparatre une et une seule fois.

Le nombre minimum d'occurrences


Pour indiquer le nombre minimum d'occurrences d'un lment, on utilise l'attribut minOccurs. Comme nous l'avons dj vu plus haut, sa valeur par dfaut est 1. A noter : dans le cas o il est utilis, sa valeur doit obligatoirement tre suprieure zro.

Le nombre maximum d'occurrences


Pour indiquer le nombre maximum d'occurrences d'un lment, on utilise l'attribut maxOccurs. Comme pour le nombre minimum d'occurrences, la valeur par dfaut est 1. Une nouvelle fois, dans le cas o il est utilis, sa valeur doit obligatoirement tre suprieure zro. A noter : il galement possible de ne pas spcifier un nombre maximal d'occurrences grce au mot clef unbounded.

Exemple
Je vous propose de terminer ce chapitre en l'illustrant par un exemple. Code : XML <xsd:complexType name="personne">

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


<xsd:sequence> <xsd:element name="nom" type="xsd:string" /> <xsd:element name="prenom" type="xsd:string" minOccurs="2" maxOccurs="unbounded" /> </xsd:sequence> </xsd:complexType>

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>

La rutilisation des lements


Avant d'attaquer la notion d'hritage, nous allons voir comment rutiliser des types complexes afin d'en crire le moins possible. C'est bien connu, les informaticiens sont des fainants !

Pourquoi ne pas tout crire d'un seul bloc ?


Puisqu'un exemple est souvent bien plus parlant que de longues explications, je vous propose d'tudier le document XML suivant : Code : XML <?xml version="1.0" encoding="UTF-8"?> <banque> <!-- 1er client de la banque --> <client> <!-- identit du client --> <identite> <nom>NORRIS</nom> <prenom>Chuck</prenom> </identite> <!-- liste des comptes bancaires du client --> <comptes> <livretA> <montant>2500</montant> </livretA> <courant> <montant>4000</montant> </courant> </comptes> </client> </banque>

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML

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.

Diviser un Schma XML


Quelques explications

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML

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.

Mise jour de notre banque et ses clients


Mettons alors jour notre Schma XML afin de le dcouper le plus possible :

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents 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="nom" type="xsd:string" /> <xsd:element name="prenom" type="xsd:string" /> <xsd:element name="montant" type="xsd:double" /> <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 ref="nom" /> <xsd:element ref="prenom" /> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="comptes"> <xsd:complexType> <xsd:sequence> <xsd:element name="livretA"> <xsd:complexType> <xsd:sequence> <xsd:element ref="montant" /> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="courant"> <xsd:complexType> <xsd:sequence> <xsd:element ref="montant" /> </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>

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

Partie 2 : Crez des dfinitions pour vos documents XML


<!-- 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:element name="livretA"> <xsd:complexType> <xsd:sequence> <xsd:element ref="montant" /> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="courant"> <xsd:complexType> <xsd:sequence> <xsd:element ref="montant" /> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="comptes"> <xsd:complexType> <xsd:sequence> <xsd:element ref="livretA" /> <xsd:element ref="courant" /> </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>

93/209

C'est tout de mme plus lisible, non ?

Crer ses propres types


Grce aux rfrences , nous sommes arrivs un rsultat satisfaisant, mais si l'on regarde en dtail, on se rend vite compte que notre Schma XML n'est pas optimis. En effet, les diffrents comptes de notre client, savoir le livret A et le compte courant, ont des structures identiques et pourtant, nous les dclarons 2 fois. Dans cette partie, nous allons donc apprendre crer nos propres types pour encore et toujours en crire le moins possible !

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML

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" />

Mise jour de notre banque et ses clients


Je vous propose de mettre jour notre Schma XML en crant un type " compte" que l'on pourra utiliser pour le livret A et le compte courant des clients de notre banque. V oici alors ce que a donne : 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" />

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


</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>

95/209

Notre Schma XML est bien plus lisible maintenant !

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.

L'hritage par restriction


La premire forme d'hritage que nous allons voir est celle par restriction.

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

Partie 2 : Crez des dfinitions pour vos documents XML


Code : XML <xsd:element name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base"> <!-- dtail de la restriction --> </xsd:restriction> </xsd:simpleType> </xsd:element>

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

Partie 2 : Crez des dfinitions pour vos documents XML

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

Partie 2 : Crez des dfinitions pour vos documents XML


<xsd:minInclusive value="ma_valeur" /> </xsd:restriction> </xsd:simpleType> </xsd:element>

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

Partie 2 : Crez des dfinitions pour vos documents XML

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

Partie 2 : Crez des dfinitions pour vos documents XML


<xsd:restriction base="type_de_base"> <xsd:length value="ma_valeur" /> </xsd:restriction> </xsd:simpleType> </xsd:element>

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

Partie 2 : Crez des dfinitions pour vos documents XML


<xsd:element name="mon_nom"> <xsd:simpleType> <xsd:restriction base="type_de_base"> <xsd:maxLength value="ma_valeur" /> </xsd:restriction> </xsd:simpleType> </xsd:element>

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

Partie 2 : Crez des dfinitions pour vos documents XML


<personne sexe="feminin"> <nom>DUPONT</nom> <prenom>Robert</prenom> </personne> <!-- invalide --> <personne sexe="pomme"> <nom>DUPONT</nom> <prenom>Robert</prenom> </personne>

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

Partie 2 : Crez des dfinitions pour vos documents XML

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>

L'hritage par extension


Dans cette seconde partie, nous allons voir le second type d'hritage : l'hritage par extension.

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

Partie 2 : Crez des dfinitions pour vos documents XML

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

Partie 2 : Crez des dfinitions pour vos documents XML


<!-- compte sans intrts --> <xsd:complexType name="compte"> <xsd:sequence> <xsd:element ref="montant" /> </xsd:sequence> </xsd:complexType> <!-- compte avec intrts grce l'hritage par extension --> <xsd:complexType name="compteInteret"> <xsd:complexContent> <xsd:extension base="compte"> <xsd:attribute name="interet" type="xsd:float" /> </xsd:extension> </xsd:complexContent> </xsd:complexType>

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.

Ce qui nous donne :

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


Code : XML <xsd:keyref name="nom" refer="nom_identifiant"> <selector xpath="expression_XPath" /> <!-- liste d'lments field --> <field xpath="expression_XPath" /> </xsd:keyref>

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

Partie 2 : Crez des dfinitions pour vos documents XML


</xsd:complexType> </xsd:element>

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>

Un exemple avec EditiX


Pour conclure ce chapitre, je vous propose de voir ensemble comment crire un Schma XML avec EditiX . Pour faire simple, reprenons l'exemple de notre banque vu dans le chapitre sur la rutilisation des types.

Cration du document XML


La cration du document XML n'a rien de bien compliqu, nous l'avons dj vu ensemble dans la partie prcdente. Pour ceux qui ne s'en souviennent pas, vous pouvez y jeter un coup dil ici. V oici le document que vous devez crire : Code : XML <?xml version="1.0" encoding="UTF-8"?> <banque xsi:noNamespaceSchemaLocation="banque.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <!-- 1er client de la banque --> <client> <!-- identit du client --> <identite> <nom>NORRIS</nom> <prenom>Chuck</prenom> </identite>

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


<!-- liste des comptes bancaires du client --> <comptes> <livretA> <montant>2500</montant> </livretA> <courant> <montant>4000</montant> </courant> </comptes> </client> </banque>

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 du document XSD


Pour crer un nouveau document, vous pouvez slectionner dans la barre de menu File puis New ou encore utiliser le raccourci clavier Ctrl + N. Dans la liste qui s'affiche, slectionnez W3C XML Schema , ainsi qu'indiqu sur la figure suivante.

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

Partie 2 : Crez des dfinitions pour vos documents XML


</xs:schema>

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.

Vrification du Schma XML


V ous pouvez vrifier que votre Schma XML n'a pas d'erreur de syntaxe en cliquant sur l'icne barre de menu XML puis Check this document ou encore en utilisant le raccourci clavier Ctrl + K. ou en slectionnant dans la

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


V ous devriez normalement avoir le message suivant (voir la figure qui suit).

110/209

Message indiquant que le Schma XML ne contient aucune erreur de syntaxe

Vrification du document XML


Il est maintenant temps de vrifier que le document XML est valide ! Pour ce faire, cliquez sur l'icne raccourci clavier Ctrl + K. Le message suivant doit normalement s'afficher (voir la figure suivante). ou slectionnez dans la barre de menu XML puis Check this document ou utilisez le

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

Partie 2 : Crez des dfinitions pour vos documents XML

111/209

TP : Schma XML d'un rpertoire


Souvenez vous, lorsque nous avons tudi les DTD, nous avions mis en pratique notre apprentissage travers la dfinition DTD d'un rpertoire. Pour ce nouveau TP, le sujet ne change pas, il convient toujours d'crire la dfinition d'un rpertoire. Ce qui change c'est la technologie utiliser. Cette fois-ci, c'est un Schma XML que je vous demande d'crire !

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

Partie 2 : Crez des dfinitions pour vos documents XML


</personne> </repertoire>

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

Partie 2 : Crez des dfinitions pour vos documents XML


<!-- balises d'une adresse --> <xsd:element name="numero" type="xsd:string"/> <xsd:element name="voie"> <xsd:complexType> <xsd:simpleContent> <xsd:extension base="xsd:string"> <xsd:attribute name="type"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:enumeration value="impasse"/> <xsd:enumeration value="avenue"/> <xsd:enumeration value="rue"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:extension> </xsd:simpleContent> </xsd:complexType> </xsd:element> <xsd:element name="codePostal"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:pattern value="[0-9]{5}"/> </xsd:restriction> </xsd:simpleType> </xsd:element> <xsd:element name="ville" type="xsd:string"/> <xsd:element name="pays" type="xsd:string"/> <!-- balise adresse --> <xsd:element name="adresse"> <xsd:complexType> <xsd:sequence> <xsd:element ref="numero"/> <xsd:element ref="voie"/> <xsd:element ref="codePostal"/> <xsd:element ref="ville"/> <xsd:element ref="pays"/> </xsd:sequence> </xsd:complexType> </xsd:element> <!-- balise telephone --> <xsd:element name="telephone"> <xsd:complexType> <xsd:simpleContent> <xsd:extension base="xsd:string"> <xsd:attribute name="type"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:enumeration value="fixe"/> <xsd:enumeration value="portable"/> <xsd:enumeration value="bureau"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:extension> </xsd:simpleContent> </xsd:complexType> </xsd:element> <!-- balise telephones --> <xsd:element name="telephones"> <xsd:complexType> <xsd:sequence> <xsd:element ref="telephone" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element>

113/209

www.openclassrooms.com

Partie 2 : Crez des dfinitions pour vos documents XML


<!-- balise email --> <xsd:element name="email"> <xsd:complexType> <xsd:simpleContent> <xsd:extension base="xsd:string"> <xsd:attribute name="type"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:enumeration value="personnel"/> <xsd:enumeration value="professionnel"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:extension> </xsd:simpleContent> </xsd:complexType> </xsd:element> <!-- balise emails --> <xsd:element name="emails"> <xsd:complexType> <xsd:sequence> <xsd:element ref="email" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> <!--balise personne --> <xsd:element name="personne"> <xsd:complexType> <xsd:sequence> <xsd:element ref="nom"/> <xsd:element ref="prenom"/> <xsd:element ref="adresse"/> <xsd:element ref="telephones"/> <xsd:element ref="emails"/> </xsd:sequence> <!-- attribut sexe --> <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> </xsd:element> <!-- Schma XML --> <xsd:element name="repertoire"> <xsd:complexType> <xsd:sequence> <xsd:element ref="personne" maxOccurs="unbounded" /> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:schema>

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

Partie 3 : Traitez vos donnes XML

115/209

Partie 3 : Traitez vos donnes XML

DOM : Introduction l'API


Dans la seconde partie, nous avons eu l'occasion d'tudier 2 technologies permettant d'crire la dfinition d'un document XML. Cette troisime partie est galement l'occasion de dcouvrir 2 nouvelles technologies qu'il est possible d'utiliser en parallle d'un document XML : l'API DOM et XPath. Ces 2 technologies vont nous permettre d'extraire et exploiter les informations contenu dans un document XML. Dbutons immdiatement la premire des deux : l'API DOM.

Qu'est-ce que L'API DOM ? La petite histoire de DOM


DOM ou Document Object Model , son nom complet, est ce qu'on appelle un parseur XML, c'est--dire, une technologie grce laquelle il est possible de lire un document XML et d'en extraire diffrentes informations (lments, attributs, commentaires, etc...) afin de les exploiter. Comme pour la plupart des technologies abordes dans ce tutoriel, DOM est un standard du W3C et ce, depuis sa premire version en 1998. Au moment o j'cris ces lignes, la technologie en est sa troisime version. Il est trs important de noter que DOM est une recommandation compltement indpendante de toute plate-forme et langage de programmation. Au travers de DOM, le W3C fournit une recommandation, c'est--dire une manire d'exploiter les documents XML. Aujourd'hui, la plupart des langages de programmation propose leur implmentation de DOM : C. C ++. Java. C#. Perl. PHP. etc. Dans les chapitres suivants, les exemples seront illustrs l'aide du langage Java.

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

Partie 3 : Traitez vos donnes XML

116/209

V oici la figure suivante ce quoi ressemble l'arbre une fois modlis.

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.

Le vocabulaire et les principaux lments


Dans ce chapitre, nous allons dcouvrir ensemble le vocabulaire utilis par le parseur DOM. Nous allons galement en profiter pour faire le tour des principaux lments en terme de programmation.

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML

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

Partie 3 : Traitez vos donnes XML

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

Partie 3 : Traitez vos donnes XML

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.

Les autres lments


Il est presque impossible de prsenter tous les lments du DOM vu la densit de la technologie. Sachez cependant que nous avons vu les principaux et qu'un exemple d'utilisation de l'implmentation Java est prvu dans le chapitre suivant. Concernant les lments non dcrits, il existe par exemple la classe Comment permettant de grer les commentaires ou encore la classe CDATASection permettant de d'exploiter les sections CDATA d'un document XML. Finalement, sachez que grce DOM, il est galement possible de vrifier la validit d'un document XML une dfinition DTD ou un Schma XML. DOM est une recommandation compltement indpendante de toute plate-forme et langage de programmation ; DOM exploite l'arbre XML d'un document XML.

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML

120/209

DOM : Exemple d'utilisation en Java


Dans le chapitre prcdent, nous venons donc de faire connaissance avec l'API DOM. Dans ce nouveau chapitre, nous allons manipuler l'implmentation Java de cette technologie en dcouvrant ensemble, tape par tape, comment lire et crer un document XML. Pour ceux d'entre vous qui n'utilisent pas Java ou qui sont plus l'aise avec un autre langage de programmation, n'hsitez pas aller faire une petite visite sur le forum du site du Zro pour trouver des rponses toutes vos questions !

Lire un document XML Le document XML


Avant de plonger dans le code, voici le document XML que nous allons tenter d'exploiter : 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>

Mise en place du code


tape 1 : rcupration d'une instance de la classe "DocumentBuilderFactory"
Avant mme de pouvoir prtendre crer un parseur DOM, nous devons rcuprer une instance de la classe DocumentBuilderFactory. C'est partir de cette instance que dans l'tape suivante nous pourrons crer notre parseur. Pour rcuprer une instance de la classe "DocumentBuilderFactory" une ligne de code suffit : Code : Java final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

Cette ligne de code s'accompagne de l'importation du package : Code : Java import javax.xml.parsers.DocumentBuilderFactory;

tape 2 : cration d'un parseur


La seconde tape consiste crer un parseur partir de notre variable factory cre dans l'tape 1. Une nouvelle fois, une seule ligne de code est suffisante : Code : Java

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML


final DocumentBuilder builder = factory.newDocumentBuilder();

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;

tape 3 : cration d'un Document


La troisime tape consiste crer un Document partir parseur de l'tape 2. Plusieurs possibilits s'offre alors vous : A partir d'un fichier. A partir d'un flux. Ce flux peut par exemple tre le rsultat de l'appel un web service. Dans notre exemple, c'est un fichier qui est utilis : Code : Java final Document document= builder.parse(new File("repertoire.xml"));

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

Partie 3 : Traitez vos donnes XML


ce que vous devriez avoir : Code : Java try { final DocumentBuilder builder = factory.newDocumentBuilder(); final Document document= builder.parse(new File("repertoire.xml")); } catch (final ParserConfigurationException e) { e.printStackTrace(); } catch (final SAXException e) { e.printStackTrace(); } catch (final IOException e) { e.printStackTrace(); }

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

Partie 3 : Traitez vos donnes XML

123/209

tape 4 : rcupration de l'Element racine


Dans cette quatrime tape, nous allons laisser de ct le prologue et tenter de nous attaquer au corps du document XML. Pour ce faire, nous allons extraire l'Element racine du Document. C'est partir de lui que nous pourrons ensuite naviguer dans le reste du document. Pour rcuprer l'lment racine, il suffit d'crire de faire appel la fonction getDocumentElement() de notre document : Code : Java final Element racine = document.getDocumentElement();

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

tape 5 : rcupration des personnes


C'est partir de cette tape que les choses srieuses commencent ! En effet, dans cette cinquime tape, nous allons rellement parcourir le corps de notre document XML. Il est possible de parcourir un document XML sans connatre sa structure. Il est donc possible de crer un code assez gnrique notamment grce la rcursivit. Cependant, ce n'est pas la mthode que j'ai choisi d'utiliser dans ce chapitre. Nous allons donc parcourir notre document en partant du principe que nous connaissons sa structure. Pour rcuprer tous les noeuds enfants de la racine, voici la ligne de code crire : Code : Java final NodeList racineNoeuds = racine.getChildNodes();

Il vous faudra galement importer le package suivant : Code : Java

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML


import org.w3c.dom.NodeList;

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

Partie 3 : Traitez vos donnes XML


for (int i = 0; i<nbRacineNoeuds; i++) { if(racineNoeuds.item(i).getNodeType() == Node.ELEMENT_NODE) { final Element personne = (Element) racineNoeuds.item(i); System.out.println(personne.getNodeName()); System.out.println("sexe : " + personne.getAttribute("sexe")); } }

125/209

A l'cran devrait alors s'afficher le rsultat suivant : Code : Console personne sexe : masculin

tape 6 : rcupration du nom et du prnom


Nous allons maintenant rcuprer le nom et le prnom des personnes prsentes dans notre document XML. Puisque nous savons exactement ce que l'on souhaite rcuprer, nous allons y accder directement via la mthode getElementsByTagName(name) de l'objet Element. Cette mthode nous renvoie tous lments contenus dans l'lment et portant le nom spcifi. Pour mieux comprendre, voyons un exemple : Code : Java final NodeList noms = personne.getElementsByTagName("nom");

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

Partie 3 : Traitez vos donnes XML


Pour extraire le prnom d'une personne, la logique est exactement la mme.

126/209

tape 7 : rcupration des numros de tlphone


La septime et dernire tape de la lecture de notre document XML consiste rcuprer les numros de tlphone d'une personne. La logique est sensiblement la mme que dans l'tape 1 si ce n'est que le rsultat de la mthode getElementsByTagName(name) nous renverra ventuellement plusieurs rsultats. Il suffit alors de boucler sur les rsultat pour afficher les valeurs et les attributs. V oici le code qui devrait tre crit : Code : Java 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); System.out.println(telephone.getAttribute("type") + " : " + telephone.getTextContent()); }

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

Partie 3 : Traitez vos donnes XML


try { /* * Etape 2 : cration d'un parseur */ final DocumentBuilder builder = factory.newDocumentBuilder(); /* * Etape 3 : cration d'un Document */ final Document document= builder.parse(new File("repertoire.xml")); //Affiche du prologue System.out.println("*************PROLOGUE************"); System.out.println("version : " + document.getXmlVersion()); System.out.println("encodage : " + document.getXmlEncoding()); System.out.println("standalone : " + document.getXmlStandalone()); /* * Etape 4 : rcupration de l'Element racine */ final Element racine = document.getDocumentElement(); //Affichage de l'lment racine System.out.println("\n*************RACINE************"); System.out.println(racine.getNodeName()); /* * Etape 5 : rcupration des personnes */ final NodeList racineNoeuds = racine.getChildNodes(); final int nbRacineNoeuds = racineNoeuds.getLength(); for (int i = 0; i<nbRacineNoeuds; i++) { if(racineNoeuds.item(i).getNodeType() == Node.ELEMENT_NODE)

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

Partie 3 : Traitez vos donnes XML


telephone.getTextContent()); } } } } catch (final ParserConfigurationException e) { e.printStackTrace(); } catch (final SAXException e) { e.printStackTrace(); } catch (final IOException e) { e.printStackTrace(); } } }

128/209

Ecrire un document XML Le document XML


Dans le chapitre prcdent, nous avons vu comment lire un document XML. Dans ce chapitre, je vous propose d'en crer un de toute pice. V oici le document que nous allons crer : 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>

Je suis sr que vous le connaissez.

Mise en place du code


tape 1 : rcupration d'une instance de la classe "DocumentBuilderFactory"
Comme pour la lecture d'un document XML, la premire tape consiste rcuprer une instance de la classe DocumentBuilderFactory. C'est partir de cette instance que notre parseur sera cr dans l'tape suivante : Code : Java final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

N'oubliez pas d'importer le package : Code : Java import javax.xml.parsers.DocumentBuilderFactory;

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML

129/209

tape 2 : cration d'un parseur


La seconde tape est galement commune la lecture d'un document XML. Ainsi, nous allons crer un parseur partir de notre variable factory cre dans l'tape prcdente : Code : Java final DocumentBuilder builder = factory.newDocumentBuilder();

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;

tape 3 : cration d'un Document


La trosime tape consiste crer un Document vierge. Ce document est cr partir de notre parseur : Code : Java final Document document= builder.newDocument();

Pour pouvoir utiliser la classe Document, n'oubliez pas d'importer le package suivant : Code : Java import org.w3c.dom.Document;

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML

130/209

tape 4 : cration de l'Element racine


Dans cette quatrime tape, nous allons crer l'lment racine de notre document XML, savoir la balise <repertoire />. La cration de l'lment racine se fait via notre parseur et plus particulirement la fonction createElement() qui prend en paramtre le nom que l'on souhaite donner la balise : Code : Java final Element racine = document.createElement("repertoire");

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);

tape 5 : cration d'une personne


Si l'on regarde le document XML que l'on doit crer, on s'aperoit qu'avant de crer la balise <personne/>, nous devons crer un commentaire. La cration d'un commentaire n'est pas plus complique que la cration d'une balise et se fait via la fonction createComment() du parseur qui prend comme paramtre le fameux commentaire : Code : Java final Comment commentaire = document.createComment("John DOE");

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

Partie 3 : Traitez vos donnes XML

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");

tape 6 : cration du nom et du prnom


En soit, la cration des balises <nom /> et <prenom /> n'a rien de compliqu. En effet, nous avons dj cr ensemble plusieurs lments. Code : Java final Element nom = document.createElement("nom"); final Element prenom = document.createElement("prenom"); personne.appendChild(nom); personne.appendChild(prenom);

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"));

tape 7 : cration des numros de tlphone


Je vais aller trs vite sur cette tape en vous fournissant directement le code source. En effet, cette septime tape ne contient rien de nouveau par rapport ce que nous avons vu jusqu'ici : Code : Java final Element telephones = document.createElement("telephones"); final Element fixe = document.createElement("telephone"); fixe.appendChild(document.createTextNode("01 02 03 04 05")); fixe.setAttribute("type", "fixe"); final Element portable = document.createElement("telephone");

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML


portable.appendChild(document.createTextNode("06 07 08 09 10")); portable.setAttribute("type", "portable"); telephones.appendChild(fixe); telephones.appendChild(portable); personne.appendChild(telephones);

132/209

tape 8 : affichage du rsultat


Il est maintenant temps de passer la dernire tape qui consiste afficher notre document XML frachement cr. Deux possibilits s'offrent nous : Dans un document XML. Dans la console de l'IDE.

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

Partie 3 : Traitez vos donnes XML


La source. La sortie.

133/209

Code : Java transformer.transform(source, sortie);

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

Partie 3 : Traitez vos donnes XML

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

Partie 3 : Traitez vos donnes XML


DocumentBuilderFactory.newInstance(); try { /* * Etape 2 : cration d'un parseur */ final DocumentBuilder builder = factory.newDocumentBuilder(); /* * Etape 3 : cration d'un Document */ final Document document= builder.newDocument(); /* * Etape 4 : cration de l'Element racine */ final Element racine = document.createElement("repertoire"); document.appendChild(racine); /* * Etape 5 : cration d'une personne */ final Comment commentaire = document.createComment("John DOE"); racine.appendChild(commentaire); final Element personne = document.createElement("personne"); personne.setAttribute("sexe", "masculin"); racine.appendChild(personne); /* * Etape 6 : cration du nom et du prnom */ final Element nom = document.createElement("nom"); nom.appendChild(document.createTextNode("DOE")); final Element prenom = document.createElement("prenom"); prenom.appendChild(document.createTextNode("John")); personne.appendChild(nom); personne.appendChild(prenom); /* * Etape 7 : rcupration des numros de tlphone */ final Element telephones = document.createElement("telephones"); final Element fixe = document.createElement("telephone"); fixe.appendChild(document.createTextNode("01 02 03 04 05")); fixe.setAttribute("type", "fixe"); final Element portable = document.createElement("telephone"); portable.appendChild(document.createTextNode("06 07 08 09 10")); portable.setAttribute("type", "portable"); telephones.appendChild(fixe); telephones.appendChild(portable); personne.appendChild(telephones); /* * Etape 8 : affichage */ final TransformerFactory transformerFactory = TransformerFactory.newInstance(); final Transformer transformer = transformerFactory.newTransformer(); final DOMSource source = new DOMSource(document); final StreamResult sortie = new StreamResult(new File("F:\\file.xml"));

135/209

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML


//final StreamResult result = new StreamResult(System.out); //prologue transformer.setOutputProperty(OutputKeys.VERSION, "1.0"); transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); transformer.setOutputProperty(OutputKeys.STANDALONE, "yes"); //formatage transformer.setOutputProperty(OutputKeys.INDENT, "yes"); transformer.setOutputProperty("{http://xml.apache.org/xslt}indentamount", "2"); //sortie transformer.transform(source, sortie);

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

Partie 3 : Traitez vos donnes XML

137/209

XPath : Introduction l'API


Dans les chapitres prcdents, nous avons tudi l'une des technologies permettant d'exploiter les informations prsentes dans un document XML : l'API DOM. Comme je vous le disais prcdemment, dans cette troisime partie du cours, 2 technologies seront abordes. Il nous en reste donc une voir : XPath. Cette technologie qui repose sur l'criture d'expressions va nous permettre d'extraire de manire trs prcise les informations contenues dans un document XML. Ce premier chapitre sera l'occasion de faire connaissance avec XPath en revenant principalement sur le vocabulaire connatre pour la manipuler.

Qu'est-ce que l'API XPath ? La petite histoire de XPath


XPath est une technologie qui permet d'extraire des informations (lments, attributs, commentaires, etc...) d'un document XML via l'criture d'expressions dont la syntaxe rappelle les expressions rationnelles utilises dans d'autres langages. Tout comme DOM, XPath est un standard du W3C et ce depuis sa premire version en 1999. Au moment o j'cris ces lignes, la technologie en est sa deuxime version. Si XPath n'est pas un langage de programmation en soit, cette technologie fournit tout un vocabulaire pour crire des expressions permettant d'accder directement aux informations souhaites sans avoir parcourir tout l'arbre XML.

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>

Reprenons galement une illustration de son arbre :

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML

138/209

Arbre XML d'un document XML Pour rappel, voici la lgende :

Lgende de l'arbre XML

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

Partie 3 : Traitez vos donnes XML

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 .

Chemin relatif et chemin absolu


V ous l'aurez compris avec le chapitre prcdent, XPath est une technologie qui permet d'extraire des informations d'un document XML via l'criture d'expressions. Concrtement, ces expressions consistent dcrire le chemin emprunt dans l'arbre XML pour atteindre les donnes qui nous intressent. Reprenons le schma utilis jusqu'ici pour illustrer le principe :

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML

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.

Les chemins absolus


Le chemin absolu est le type de chemin que nous avons utilis dans notre exemple. Le nud de dpart est toujours la racine de l'arbre XML.

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML


Une expression XPath utilisant un chemin absolu est facilement identifiable car elle commence par le caractre " / ".

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

Les chemins relatifs


Si un chemin absolu est un chemin dont le nud de dpart est toujours la racine de l'arbre XML, un chemin relatif accepte quant lui n'importe quel nud de l'arbre XML comme point de dpart. Une expression XPath utilisant un chemin relatif est facilement identifiable car elle ne commence pas par le caractre " / ". Comme pour les chemins absolus, je vous propose d'illustrer cette nouvelle dfinition par un exemple dans lequel nous allons rcuprer le prnom de la personne. Dans cet exemple, notre point de dpart sera le nud dcrivant le numro de tlphone portable de John DOE : Etape 1 : nud " telephone" dont l'attribut est " portable". Etape 2 : remonter au nud parent " telephones ". Etape 3 : aller nud frre " 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

Partie 3 : Traitez vos donnes XML

142/209

XPath : Localiser les donnes


Le chapitre prcdent, peu technique, a surtout t l'occasion de faire connaissance avec le vocabulaire utilis dans XPath. Je prfre vous prvenir, ce nouveau chapitre sera dense ! Nous allons aborder toutes les notions qui vous permettront d'utiliser XPath afin d'exploiter facilement vos documents XML. Au programme donc : la dissection dtaille d'une tape et un peu de pratique via EditiX .

Dissection d'une tape


Dans le chapitre prcdent, nous avons vu qu'une expression XPath est en ralit une succession d'tapes. Nous allons maintenant nous intresser de plus prs ce qu'est une tape. Une tape est dcrite par 3 lments : Un axe. Un nud ou un type de nud. Un ou plusieurs prdicats (facultatif). Avant de voir en dtail les valeurs possibles pour ces 3 lments, je vous propose de revenir trs rapidement sur leurs rles respectifs.

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

Partie 3 : Traitez vos donnes XML


child descendant oriente la recherche vers les enfants du nud courant oriente la recherche vers les descendants du nud courant

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.

Les tests de nuds


Nous venons donc de voir les diffrentes valeurs possibles pour slectionner un axe. Il est donc maintenant temps d'attaquer le second lment composant une tape : le nom d'un nud ou le type de nud.

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

Partie 3 : Traitez vos donnes XML


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> </repertoire>

144/209

Les chemins absolus


Nous allons dbuter par des exemples se basant sur l'criture d'une expression utilisant un chemin absolu. Dans notre premier exemple, le but va tre de rcuprer le pays de domiciliation de John DOE. Commenons par dcrire les tapes suivre en franais : Etape 1 : descendre au nud " repertoire" . Etape 2 : descendre au nud " personne". Etape 3 : descendre au nud " adresse". Etape 4 : descendre au nud " pays ". Traduisons maintenant ces tapes sous la forme d'expressions XPath : Etape 1 : child::repertoire. Etape 2 : child::personne. Etape 3 : child::adresse. Etape 4 : child::pays. Ce qui nous donne : Code : XPath /child::repertoire/child::personne/child::adresse/child::pays

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

Partie 3 : Traitez vos donnes XML

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()

Les chemins relatifs


Aprs avoir vu quelques exemples d'expressions XPath utilisant des chemins absolus, je vous propose de voir un exemple d'une expression utilisant un chemin relatif . Dans cet exemple, notre point de dpart sera le nud " telephones ". Une fois de plus, le but va tre de rcuprer le pays de domiciliation de John DOE. Commenons par dcrire les tapes suivre en franais : Etape 1 : remonter au nud frre " adresse". Etape 2 : descendre au nud " pays ". Traduisons maintenant ces tapes sous la forme d'expressions XPath : Etape 1 : preceding-sibling::adresse. Etape 2 : pays. Ce qui nous donne : Code : XPath preceding-sibling::adresse/pays

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

Partie 3 : Traitez vos donnes XML


peut tre simplifie par : Code : XML //pays

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()

peut tre simplifie par : Code : XML /repertoire/personne/.

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

Partie 3 : Traitez vos donnes XML


Pour les exemples, nous allons continuer de nous appuyer sur le mme document XML : 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> </repertoire>

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"]

Une autre mthode consiste utiliser la fonction not() :

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML


Code : XPath /repertoire/personne/telephones/telephone[not(attribute::type="fixe")]

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")]

Code : XPath /repertoire/personne/telephones/telephone[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

Partie 3 : Traitez vos donnes XML


Code : XPath /repertoire/personne/telephones/telephone[attribute::type="fixe"]

149/209

devient : Code : XPath /repertoire/personne/telephones/telephone[@type="fixe"]

Un exemple avec EditiX


Pour conclure ce chapitre, je vous propose de voir comment excuter une expression XPath avec EditiX .

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

Partie 3 : Traitez vos donnes XML


</repertoire>

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.

Excuter une requte


Dans cet ultime exemple, nous allons slectionner les nuds contenant des adresses e-mails professionnelles grce l'expression suivante : Code : XPath /repertoire/personne/emails/email[attribute::type="professionnel"]

En thorie, nous devrions avoir 2 noeuds slectionns. Vrifions tout de suite :

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML

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

Partie 3 : Traitez vos donnes XML

152/209

TP : des expressions XPath dans un rpertoire


Aprs l'apprentissage de l'API DOM sans une relle pratique, il est temps de corriger le tir ! Ce nouveau TP sera donc l'occasion d'crire plusieurs expressions XPath destines extraire les informations d'un rpertoire contenu dans un document XML. Bon courage !

L'nonc Le document XML


Une fois de plus, c'est avec un rpertoire tlphonique que nous allons travailler. V oici les informations que l'on connat 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.). Aucune ou plusieurs adresses e-mail (adresse personnelle, professionnelle, etc.). V oici maintenant le document XML qui va nous servir de support : 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>

www.openclassrooms.com

Partie 3 : Traitez vos donnes XML


</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>

153/209

Les expressions crire


V oici donc la liste des expressions XPath crire : Slectionner tous les nuds descendants du deuxime nud " personne". Slectionner le nud " personne" correspondant au individu ayant au moins 2 numros de tlphone. Slectionner tous les nuds " personne". Slectionner le deuxime nud " personne" dont le pays de domiciliation est la France . Slectionner tous les nuds " personne" de sexe masculin le pays de domiciliation est les Etats-Unis . C'est vous de jouer !

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

Partie 3 : Traitez vos donnes XML


Code : XPath /repertoire/personne

154/209

ou encore : Code : XPath //personne

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

Partie 4 : Transformez vos documents XML

155/209

Partie 4 : Transformez vos documents XML

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.

Qu'est-ce que XSLT ? La petite histoire du XSLT


XSLT ou eXtensible Stylesheet Language Transformations est une technologie qui permet de transformer les informations d'un document XML vers un autre type de document comme un autre document XML ou encore une page web. C'est d'ailleurs ce dernier cas que nous aborderons au cours de cette partie. Comme toutes les technologies que nous avons abord dans ce tutoriel, XSLT est un standard du W3C depuis 1999 pour sa premire version et 2007 pour sa seconde version. Comme d'autres technologies que nous avons vu jusqu'ici, les documents XSLT sont crits l'aide d'un langage de type XML. Si XLST permet de faire les transformations, la technologie sappuie sur une autre technologie (que nous avons dj vue ensemble) pour slectionner des informations transformer : XPath. Si aviez saut la partie du tutoriel traitant de XPath ou si vous avez besoin de vous rafrachir la mmoire, n'hsitez pas relire la partie 3 du cours !

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

Partie 4 : Transformez vos documents XML


Principe d'une transformation XSLT

156/209

Structure d'un document XSLT


Maintenant que vous en savez un peu plus sur cette nouvelle technologie, je vous propose de dbuter en douceur notre apprentissage du XSLT en dcouvrant ensemble la structure d'un document.

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

Partie 4 : Transformez vos documents XML

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.

Les autres attributs


2 autres attributs peuvent galement tre utiliss : doctype-public et doctype-system. Ces 2 attributs sont utiliss dans le cas o l'on souhaite associer un document DTD au document produit par la transformation XSLT. L'attribut doctype-public permet de renseigner le FPI (Formal Public Identifier), c'est--dire l'identifiant public de la DTD. L'attribut doctype-system, quant lui, permet de renseigner l'URL de la DTD. Maintenant que nous avons pass en revue tous les lments permettant de construire la balise <xsl:output />, je vous propose de voir quelques exemples. Notre premier exemple nous permet de prciser que l'on souhaite produire un document XML : Code : XML <xsl:output method="xml" encoding="UTF-8" indent="yes" />

V oyons maintenant un exemple nous permettant de produire un document HTML 4 : Code : XML

www.openclassrooms.com

Partie 4 : Transformez vos documents XML


<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" />

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>

Rfrencer un document XSLT


Avant de continuer tudier la cration d'un document XSLT, je vous propose de voir comment rfrencer une transformation XSLT dans un document XML.

O et comment rfrencer un document XSLT ?


Le rfrencement d'un document XSLT se fait au niveau du document XML dont les informations seront utilises au cours de la transformation. Ce rfrencement se fait via une petite ligne placer sous le prologue et avant l'lment racine du document XML : Code : XML <?xml-stylesheet type="text/xsl" href= "mon_document.xsl" ?>

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

Partie 4 : Transformez vos documents XML

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

Partie 4 : Transformez vos documents XML

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.

Introduction aux templates


Maintenant que vous savez qu'un document XSLT est compos d'un ensemble de templates , je vous propose de rentrer dans le vif du sujet et de dcouvrir ensemble comment crire les diffrents templates qui composeront nos futurs documents XSLT.

Structure d'un template


Un template est dfini par la balise <xsl:template /> laquelle plusieurs attributs peuvent tre associs. Dans le cadre de ce tutoriel, nous renseignerons systmatiquement l'un des 2 attributs suivants : L'attribut match permet de renseigner une expression XPath. Cette expression XPath permet alors de slectionner les informations du documents XML auxquelles le template s'applique. L'attribut name est le nom donn au template, permettant de l'identifier de manire unique. Cet attribut est important puisque nous verrons par la suite qu'il n'ai pas rare qu'un template en appelle un autre. Code : XML <xsl:template match="expression XPath" name="nom du template" > <!-- contenu du template --> </xsl:template>

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.

Aller plus loin


Pour aller plus loin, sachez qu'il existe d'autres attributs comme par exemple les attributs priority ou mode qui permettent respectivement de renseigner une priorit ou un mode de traitement. Dans le cadre de ce tutoriel, nous ne les exploiterons pas et nous nous contenterons d'utiliser les attributs match et name.

Contenu d'un template


Maintenant que nous avons vu la structure d'un template, il convient d'tudier le cur d'un template, c'est--dire son contenu.

Introduction au contenu d'un template


Le contenu d'un template permet de dfinir les transformations appliquer l'ensemble des donnes slectionnes par l'expression XPath qui lui est attache. Ce contenu peut-tre de diffrentes natures. Ainsi, il est par exemple possible de simplement remplacer les informations slectionnes par du texte, ou d'y appliquer des transformations plus complexes l'aide de nombreuses fonctions que nous tudierons dans ce tutoriel.

Notre premier template


Afin d'illustrer cette dfinition, je vous propose de voir ensemble un premier exemple dans lequel nous allons crer un document

www.openclassrooms.com

Partie 4 : Transformez vos documents XML


HTML partir d'un document XML.

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

Partie 4 : Transformez vos documents XML


Le document HTML produit par la transformation du document XML par le document XSLT est donc 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 premier document XSLT</title> </head> <body> <p>Bonjour !</p> </body> </html>

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

Partie 4 : Transformez vos documents XML


</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>

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

Partie 4 : Transformez vos documents XML

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

Partie 4 : Transformez vos documents XML

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

Partie 4 : Transformez vos documents XML

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" />&#160;<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 " &#160;" 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

Partie 4 : Transformez vos documents XML


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>DOE&nbsp;John</p> <p>MAN&nbsp;Batte</p> <p>POPPINS&nbsp;Marie</p> </body> </html>

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 &lt; b a &lt;= b a &gt; b a &gt;= b Cette condition vrifie que la valeur de l'lment a est gale la valeur de l'lment b. Le symbole &lt; (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 &lt; (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 &gt; (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 &gt; (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

Partie 4 : Transformez vos documents XML


traduction anglaise or.

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 &gt; b and a &gt; 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" />&#160;<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

Partie 4 : Transformez vos documents XML


<title>Test de la fonction if</title> </head> <body> <p>DOE&nbsp;John</p> <p>MAN&nbsp;Batte</p> </body> </html>

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>

de comparaison"> transformation --> de comparaison"> transformation --> transformation -->

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

Partie 4 : Transformez vos documents XML


</xsl:when> <xsl:otherwise> <p>Qui tes-vous ?</p> </xsl:otherwise> </xsl:choose> </xsl:for-each> </body> </html> </xsl:template>

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 &ecirc;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

Partie 4 : Transformez vos documents XML


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>

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

Partie 4 : Transformez vos documents XML


"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> <p>Marie</p> </body> </html>

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

Partie 4 : Transformez vos documents XML


</html>

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

Partie 4 : Transformez vos documents XML

174/209

Les templates : aller plus loin


Dans le chapitre prcdent, nous avons vu un grand nombre de fonctions utiliser dans nos templates . Ne nous arrtons pas en si bon chemin, il nous reste encore quelques fonctions voir ! Ces nouvelles fonctions seront galement l'occasion d'aborder de nouveaux concepts savoir, les variables et les paramtres . Ce nouveau chapitre sera galement l'occasion d'apprendre crer et excuter une transformation XSLT dans EditiX .

Les variables et la fonction call-template


Au cours de ce chapitre, je vous propose d'aborder une nouvelle notion bien connue en informatique et plus prcisment dans les langages de programmations : les variables . Ce chapitre sera galement l'occasion d'une mise en pratique de cette nouvelle notion travers l'apprhension d'une nouvelle fonction pour nos template : call-template.

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

Partie 4 : Transformez vos documents XML


<title>Test des variables</title> </head> <body> <p><xsl:value-of select="$couleur" /></p> </body> </html> </xsl:template>

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

Partie 4 : Transformez vos documents XML


<xsl:template match="/"> <xsl:variable name="couleur">rouge</xsl:variable> <html> <head> <title>Test des variables</title> </head> <body> <p><xsl:value-of select="$couleur" /></p> </body> </html> </xsl:template>

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

Partie 4 : Transformez vos documents XML


<p><xsl:value-of select="$nom"/>&#160;<xsl:value-of select="$prenom"/> : <xsl:value-of select="$sexe"/></p> </xsl:for-each> </body> </html> </xsl:template>

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.

Dfinition : premire partie


La fonction <xsl:call-template /> permet d'appeler un autre template au sein d'un template. Il est possible de l'appeler grce son nom. Cette fonction accepte donc un attribut " name" qui permet d'identifier le template appeler. Jusqu' maintenant, nous avions renseign l'attribut "select" de nos templates grce une expression XPath. Les templates appels grce la fonction <xsl:call-template /> doivent tre identifis par un nom. Il ne convient donc plus de renseigner l'attribut " select", mais l'attribut "name" qui permet d'identifier de manire unique le template. V oici alors la syntaxe d'un template appeler : Code : XML <xsl:template name="nom_du_template"> <!-- contenu --> </xsl:template>

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

Partie 4 : Transformez vos documents XML


<head> <title>Test de la fonction call-template</title> </head> <body> <xsl:call-template name="body" /> </body> </html> </xsl:template> <xsl:template name="body"> <p>Contenu de la page HTML</p> </xsl:template>

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.

Dfinition : deuxime partie


Je vous avais promis que l'tude de la fonction <xsl:call-template /> nous permettrait de mettre en application nos connaissances sur les variables, chose que nous n'avons pas encore faite. Il est donc temps de passer aux choses srieuses !

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

Partie 4 : Transformez vos documents XML

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

Partie 4 : Transformez vos documents 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>

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>

Le document HTML produit est alors le suivant : Code : HTML

www.openclassrooms.com

Partie 4 : Transformez vos documents XML


<!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 call-template</title> </head> <body> <p>nom de la personne:DOE</p> <p>nom de la personne:POPPINS</p> <p>nom de la personne:MAN</p> </body> </html>

181/209

D'autres fonctions La fonction element


Dfinition
La fonction <xsl:element /> est une fonction que nous utiliserons principalement pour transformer un document XML en un nouveau document XML. En effet, comme son nom le laisse deviner, cette fonction permet de crer un lment au sens XML, c'est--dire une balise XML. Cette fonction accepte plusieurs attributs. Dans le cadre de ce cours, deux nous intressent : L'attribut " name", obligatoire, permet de dfinir le nom de l'lment XML que l'on souhaite crer. Ce nom peut-tre une chane de caractres ou encore la valeur d'une variable. L'attribut " namespace", facultatif quant lui, permet de prfixer l'lment crer d'un espace de noms.

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

Partie 4 : Transformez vos documents XML


<xsl:template match="/"> <xsl:element name="couleur">rouge</xsl:element> </xsl:template>

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>

Le document XML produit est alors le suivant :

www.openclassrooms.com

Partie 4 : Transformez vos documents XML


Code : XML <?xml version="1.0" encoding="utf-8"?> <couleur primaire="oui">rouge</couleur>

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

Partie 4 : Transformez vos documents XML


Code : XML <?xml-stylesheet type="text/xsl" href="transformation.xsl"?>

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

Partie 4 : Transformez vos documents XML

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>

Un exemple avec EditiX


Pour conclure ce chapitre, je vous propose de voir comment effectuer une transformation XSLT avec EditiX .

Cration du document XML


www.openclassrooms.com

Partie 4 : Transformez vos documents XML


Commencez par crer dans EditiX un document XML contenant les informations suivantes : 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>

186/209

Cration du document XSLT


Pour crer un nouveau document, vous pouvez slectionner dans la barre de menu File puis New ou encore utiliser le raccourci clavier Ctrl + N. Dans la liste qui s'affiche, slectionnez XSL Transformations 1.0 for HTML output , comme indiqu sur la figure suivante :

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

Partie 4 : Transformez vos documents XML


xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:output method="html"/> <xsl:template match="/"> <html> <body> <xsl:apply-templates/> </body> </html> </xsl:template> </xsl:stylesheet>

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.

Vrification du document XSLT


V ous pouvez vrifier que votre transformation n'a pas d'erreur de syntaxe en slectionnant dans la barre de menu XML puis Check this document ou encore en utilisant le raccourci clavier Ctrl + K. V ous devriez normalement avoir le message suivant s'afficher :

www.openclassrooms.com

Partie 4 : Transformez vos documents XML

188/209

Message indiquant que le document XSLT est bien form

Appliquer une transformation


Nous allons maintenant voir comment appliquer la transformation que nous venons d'crire notre document XML. Pour ce faire, il convient de slectionner dans la barre de menu XSLT/Query puis Transform a document with this XSLT... ou encore en cliquant sur l'icne suivante : . Une fentre apparat alors, nous permettant de choisir : La transformation appliquer. Le document XML transformer. Le nom du document qui sera produit l'issu de la transformation. Le comportement souhait la fin de l'opration. Compltez alors les informations comme dans la capture d'cran ci-dessous :

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

Partie 4 : Transformez vos documents XML

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

Partie 4 : Transformez vos documents XML

190/209

TP : des transformations XSLT d'un rpertoire


Il est temps de rellement mettre en pratique vos connaissances sur les transformations XSLT dans un TP.

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

Partie 4 : Transformez vos documents XML

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

Partie 4 : Transformez vos documents XML


Comme chaque fois, je vous fais part de ma solution !

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

Partie 4 : Transformez vos documents XML


</tr> </xsl:template> <xsl:template name="afficherPersonne"> <xsl:param name="personne" /> <h1> <xsl:value-of select="$personne/nom" /> &#160; <xsl:value-of select="$personne/prenom" /> </h1> <xsl:call-template name="afficherAdresse"> <xsl:with-param name="adresse" select="$personne/adresse" /> </xsl:call-template> <xsl:if test="count($personne/telephones) != 0"> <xsl:call-template name="afficherTelephones"> <xsl:with-param name="telephones" select="$personne/telephones" /> </xsl:call-template> </xsl:if> <xsl:if test="count($personne/emails) != 0"> <xsl:call-template name="afficherEmails"> <xsl:with-param name="emails" select="$personne/emails" /> </xsl:call-template> </xsl:if> </xsl:template> <xsl:template name="afficherAdresse"> <xsl:param name="adresse" /> <p class="adresse" > <xsl:value-of select="$adresse/numero" /> &#160; <xsl:value-of select="$adresse/voie" /> <br/> <xsl:value-of select="$adresse/codePostal" /> &#160; <xsl:value-of select="$adresse/ville" /> <br/> <xsl:value-of select="$adresse/pays" /> </p> </xsl:template> <xsl:template name="afficherTelephones"> <xsl:param name="telephones" /> <h2>Numros de tlphones :</h2> <ul> <xsl:for-each select="$telephones/telephone"> <xsl:call-template name="afficherTelephone"> <xsl:with-param name="telephone" select="." /> </xsl:call-template> </xsl:for-each> </ul> </xsl:template> <xsl:template name="afficherTelephone"> <xsl:param name="telephone" /> <li> <xsl:value-of select="$telephone/@type" /> : <xsl:valueof select="$telephone" /> </li> </xsl:template> <xsl:template name="afficherEmails"> <xsl:param name="emails" /> <h2>Adresses Emails :</h2> <ul>

193/209

www.openclassrooms.com

Partie 4 : Transformez vos documents XML


<xsl:for-each select="$emails/email"> <xsl:call-template name="afficherEmail"> <xsl:with-param name="email" select="." /> </xsl:call-template> </xsl:for-each> </ul> </xsl:template> <xsl:template name="afficherEmail"> <xsl:param name="email" /> <li> <xsl:value-of select="$email/@type" /> : <xsl:value-of select="$email" /> </li> </xsl:template> </xsl:stylesheet>

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&eacute;pertoire t&eacute;l&eacute;phonique</title> <link type="text/css" rel="stylesheet" href="style.css"> </head> <body> <table> <tr> <td class="homme"> <h1>DOE&nbsp;John</h1> <p class="adresse"> 7&nbsp;impasse du chemin<br> 75015&nbsp;PARIS<br> FRANCE </p> <h2>Num&eacute;ros de t&eacute;l&eacute;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&nbsp;Marie</h1>

www.openclassrooms.com

Partie 4 : Transformez vos documents XML


<p class="adresse"> 28&nbsp;avenue de la r&eacute;publique<br> 13005&nbsp;MARSEILLE<br> FRANCE </p> <h2>Num&eacute;ros de t&eacute;l&eacute;phones :</h2> <ul> <li>professionnel : 04 05 06 07 08</li> </ul> <h2>Adresses Emails :</h2> <ul> <li>professionnel : contact@poppins.fr</li> </ul> </td> </tr> <tr> <td class="homme"> <h1>MAN&nbsp;Batte</h1> <p class="adresse"> 24&nbsp;impasse des h&eacute;ros<br> 11004&nbsp;GOTHAM CITY<br> USA </p> <h2>Num&eacute;ros de t&eacute;l&eacute;phones :</h2> <ul> <li>professionnel : 01 03 05 07 09</li> </ul> </td> </tr> </table> </body> </html>

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;

.homme { background-color: blue; } .femme { background-color: pink; } .adresse { font-style: italic; }

www.openclassrooms.com

Partie 5 : Annexes

196/209

Partie 5 : Annexes

Les espaces de noms


Comme vous le constatez, cette cinquime partie est une annexe. Son objectif est multiple, savoir revenir sur des notions qui reviennent rgulirement dans le cours et proposer quelques chapitres "bonus" pour aller toujours plus loin dans la manipulation de vos documents XML. Le premier chapitre de cette annexe revient sur la notion d'espace de noms , notion fortement utilis en XML et dans les diffrentes technologies abordes au cours de ce tutoriel comme par exemple les Schmas XML ou encore les transformations XSLT.

Dfinition Dfinition d'un espace de noms


Lorsque l'on crit un document XML, on utilise ce que l'on appelle un vocabulaire. Par exemple, dans les diffrents TP, nous avons travaill avec des rpertoires tlphoniques dans lesquels chaque personne possde : Une identit (un nom et un prnom). Une adresse. Des numros de tlphone. Des adresses e-mail. Etc. A travers cette description, nous avons avons dfini le vocabulaire d'une personne. Dans notre cas, ce vocabulaire n'est pas forcment rutilisable en l'tat. Pourtant, comme vous vous en tes certainement aperu, en informatique, on aime bien rutiliser ce que l'on a dj effectu et ne pas toujours repartir zro. Il existe plusieurs vocabulaires qui ont fait leurs preuves et qui ont t mis dispositions des dveloppeurs afin qu'ils puissent tre rutiliss. Nous y reviendrons un peu plus tard, mais nous pouvons dj en citer quelques uns. Le vocabulaire permettant de dcrire une page xHTML. Le vocabulaire permettant de dcrire un Schma XML. Le vocabulaire permettant de dcrire des documents techniques. Etc.

Identifier un espace de noms


Un espace de noms est identifi par une URI (Uniform Resource Identifier) qui permet de l'identifier de manire unique. Bien que l'on distingue 2 types d'URI, savoir les URL (Uniform Resource Locator) et les URN (Uniform Resource Name), dans la majorit des cas, c'est une URL qui est utilise. Pour rappel, une URL permet d'identifier de manire unique une ressource, dans notre cas, un vocabulaire, sur un rseau. V oyons quelques exemples d'URL permettant d'identifier des vocabulaires et donc des espaces de noms sur le rseau Internet : xhtml : http://www.w3.org/1999/xhtml Schma XML : http://www.w3.org/2001/XMLSchema DocBook : http://docbook.org/ns/docbook

Utilisation d'un espace de noms Les espaces de noms par dfaut


La dclaration d'un espace de noms par dfaut se fait dans le premier lment qui utilise le vocabulaire, grce au mot clef xmlns comme XML namespace . Code : XML

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.

Les espaces de noms avec prfixe


Utiliser un espace de noms par dfaut a certaines limites. En effet, il est par exemple impossible d'utiliser au sein d'un mme document 2 espaces de noms par dfaut qui auraient un mot de vocabulaire en commun. On obtiendrait alors une ambigut. Tout problme a bien videmment une solution espaces de noms. Ainsi, pour contourner cette limite, nous allons utiliser des prfixes avec nos

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

La porte d'un espace de noms


Pour clore ce chapitre, il me semble intressant de revenir sur la notion de porte d'un espace de noms . En effet, suivant la faon dont il est dclar, un espace de noms n'est pas accessible partout dans un document, il n'est donc pas possible d'utiliser tous les mots de vocabulaire partout dans un document XML. La rgle qui rgit la porte d'un espace de noms est assez simple : un espace de noms est utilisable tant que l'lment qui le dclare n'est pas referm. Une fois de plus, je vous propose d'illustrer cette notion par un exemple : Code : XML <!-- il est possible d'utiliser l'espace de noms http --> <http:html xmlns:http="http://www.w3.org/1999/xhtml"> <http:head> <http:title>Titre du document</http:title> </http:head> <http:body> <http:p> <!-- il est possible d'utiliser l'espace de noms ml --> <ml:math xmlns:ml="http://www.w3.org/1998/Math/MathML"> <ml:matrix> <ml:matrixrow> <ml:cn>0</ml:cn> <ml:cn>1</ml:cn> <ml:cn>0</ml:cn> </ml:matrixrow> <ml:matrixrow> <ml:cn>0</ml:cn> <ml:cn>0</ml:cn> <ml:cn>1</ml:cn> </ml:matrixrow> </ml:matrix> </ml:math> <!-- il n'est plus possible d'utiliser l'espace de noms ml --> </http:p> </http:body> </http:html> <!-- il n'est plus possible d'utiliser l'espace de noms http -->

Quelques espaces de noms utiliss rgulirement


En conclusion de ce chapitre, je vous propose de revenir sur quelques espaces de noms connus, rgulirement utiliss par les dveloppeurs. Bien videmment cette liste n'est pas exhaustive, il en existe un trs grand nombre !

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

Mettez en forme vos documents XML avec CSS


Ce chapitre a pour objectif de vous montrer qu'il est possible d'appliquer un style CSS directement aux informations d'un document XML afin de le mettre en forme lors de son affichage dans un navigateur internet. Finalement, puisque la pratique reste le meilleur moyen d'apprendre, un petit TP vous sera propos ! Si ce chapitre explique comment appliquer une feuille de style CSS un document XML, je ne reviendrai pas en dtail sur chaque proprit du CSS existante. En effet, ce langage ncessite lui seul l'criture d'un tutoriel dont la taille serait consquente. Le but est ici de dcouvrir ce qu'il est possible de faire avec du CSS et du XML.

Ecrire un document CSS Qu'est-ce que le CSS ?


Bien que je sois certain que la majorit d'entre vous connaissent dj peu prs ce qu'est le CSS , je vous propose de revenir rapidement sur ce langage. Le CSS ou Cascading Style Sheet de son nom complet, est un langage informatique part entire permettant de styliser les documents HTML et XML. Avec le HTML, il s'agit du langage qui permet de mettre en forme et styliser les sites Internet. Nous allons donc voir comment grce au CSS , il est possible de styliser un document XML. Par styliser, j'entends par exemple : Ecrire certains lments en gras. Souligner. Surligner. Ecrire certains lments en couleur. Etc.

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 .

Rfrencer le fichier CSS


Afin de pouvoir appliquer un style CSS nos documents XML, il convient de lier les diffrents fichiers entre eux. Cette liaison se fait dans le document XML entre le prologue et la racine, grce la balise suivante : Code : XML <?xml-stylesheet href="style.css" type="text/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.

Slectionner une balise


En CSS , pour slectionner un lment particulier d'un document XML, on utilise la syntaxe suivante : Code : CSS balise { proprit1 : valeur; proprit2: valeur; }

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.

Slectionner une balise particulire


Allons un petit peu plus loin et considrons le document XML suivant, reprsentant encore une liste de personnes : Code : XML <?xml version="1.0" encoding="UTF-8"?> <personnes> <personne sexe="masculin"> <nom>NORRIS</nom> <prenom>Chuck</prenom> </personne> <personne sexe="feminin"> <nom>DUPONT</nom> <prenom>Marie</prenom> </personne> </personnes>

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

Affichage du document XML stylis dans un navigateur web

Un exemple avec EditiX


Comme pour chaque technologie que nous voyons ensemble, je vous propose de voir comment procder grce au logiciel EditiX .

Cration du document XML


La cration du document XML n'a rien de bien compliqu puisque nous l'avons dj vu ensemble plusieurs reprise. Pour ceux qui ne s'en souviennent pas, vous pouvez y jeter un coup dil ici. Je vous propose de reprendre pour exemple notre liste de personnes : Code : XML <?xml version="1.0" encoding="UTF-8"?> <?xml-stylesheet href="personnes.css" type="text/css" ?> <personnes> <personne sexe="masculin"> <nom>NORRIS</nom> <prenom>Chuck</prenom> </personne> <personne sexe="feminin"> <nom>DUPONT</nom> <prenom>Marie</prenom> </personne> </personnes>

Si vous essayez de lancer la vrification du document, vous devriez normalement avoir ce message (voir la figure suivante).

Message indiquant que le document XML est bien form

Cration du document CSS


www.openclassrooms.com

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.

Vrification de fichier de style


V ous pouvez vrifier que votre fichier CSS n'a pas d'erreur de syntaxe en cliquant sur l'icne de menu XML puis Check this CSS ou encore en utilisant le raccourci clavier Ctrl + K. La possibilit de vrifier qu'un fichier CSS ne comporte aucune erreur de syntaxe n'est pas offerte dans la version gratuite d'Editix. Si vous souhaitez utiliser cette fonctionnalit, il vous faudra passer sur la version payante. , en slectionnant dans la barre

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.

TP : mise en forme d'un rpertoire


Le but de ce TP est de crer un fichier CSS afin de mettre en forme un rpertoire tlphonique se prsentant sous la forme d'un document XML.

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

Vous aimerez peut-être aussi