Cours XML Final

Cours XML
Brahim ER-RAHA
Je veux envoyer ma carte de visite par courrier électronique
Mr Brahim ER-RAHA
ENSA-Département Informatique
135 avenue des FAR
80 000 Agadir
Maroc
bureau 028-55-55-24
fax 061-55-55-55
On peut l'envoyer tel quel, dans le texte du courrier
Brahim ER-RAHA
Autre possibilité :
Mr ER-RAHA Brahim
ENSA-Département Informatique
135 avenue des FAR
80 000 Agadir
Maroc
bureau 028-55-55-24
fax 061-55-55-55
A la réception, le lecteur humain saura décoder les différents champs de l'adresse
Brahim ER-RAHA
Plus difficile par un logiciel!
• il faut l'extraire du reste du texte => identification

• il faut l'analyser FACILEMENT => moteur de recherche
• il faut le vérifier FACILEMENT => validation
• on doit pouvoir l'utiliser dans d'autres applications => portabilité
• on doit pouvoir la transformer pour d'autres applications => format du
numéro de téléphone.
Brahim ER-RAHA
<carte>

<nom préfixe="Mr">ER-RAHA</nom>
<prénom>Brahim</prénom>
<adresse>
<site>ENSA-Département Informatique</site>
<rue>135 avenue des FAR</rue>
<ville>Agadir</ville>
<code-postal>80 000</code-postal>
<pays>Maroc</pays>
</adresse>
<téléphone type="bureau">028-55-55-24</téléphone>
<téléphone type="fax">061-55-55-55</téléphone>
</carte>
Brahim ER-RAHA
Le principal langage du Web est HTML
HTML est un langage pour présenter des informations à l’écran.
1. il ne permet pas d’échanger des données

2. il ne permet pas un traitement des données autre que l’affichage
On ne sait pas interpréter des données fournies en HTM
Nouvelles utilisations du Web

Quelques applications :
Commerce électronique : les entreprises veulent échanger des informations

(pas pour les afficher !)
Moteur de recherche : si je sais interpréter les données transmises, je peux les

indexer efficacement
Services en ligne : je peux envoyer mes données à un serveur pour leur

appliquer un traitement donné (ex : publication)
Brahim ER-RAHA
Nouveaux besoins : échange et publication de données.
Le réseau est hétérogène : les données doivent être représentées

indépendamment d’une machine donnée.
Les applications sont variées : les données doivent être représentées

indépendamment d’une application.
Une application = un format de données : il faut pouvoir transformer

facilement les données d’un format à un autre.
Le langage XML est une réponse à ces besoins :
Un document XML est au format ASCII : il voyage (relativement) facilement

XML n’est pas lié à un mode d’utilisation : chacun peut se définir son propre
« langage », (SMIL, SVG, WML, etc)
Beaucoup d’outils de manipulation : DOM, SAX, XSLT, XPath, XQuery, etc
Brahim ER-RAHA
Brahim ER-RAHA
Origine de XML
Standard Generalized Markup Language
SGML
( Sépare les données la structure des données et la
mise en forme )
Hyper Text Markup Language

HTML ( Mélange les données et la mise en forme )
eXtensible Markup Language
XML ( Sépare les données la structure des données et la

mise en forme )
I- INTRODUCTION
I-1 Définition
XML (eXtensible Markup Language et traduisez Langage à balises étendu, ou

Langage à balises extensibles) est en quelque sorte un langage HTML amélioré
permettant de définir de nouvelles balises. Il s'agit effectivement d'un langage
permettant de mettre en forme des documents grâce à des balises (markup).
En réalité les balises XML décrivent le contenu plutôt que la présentation

(contrairement À HTML). Ainsi, XML permet de séparer le contenu de la
présentation ce qui permet par exemple d'afficher un même document sur des
applications ou des périphériques différents sans pour autant nécessiter de créer
autant de versions du document que l'on nécessite de représentations
XML a été mis au point par le XML Working Group sous l'égide du World Wide
Web Consortium (W3C) dès 1996. Depuis le 10 fevrier 1998, les spécifications
XML 1.0 ont été reconnues comme recommandations par le W3C, ce qui en fait
un langage reconnu. (Tous les documents liés à la norme XML sont
consultables et téléchargeables sur le site web du W3C,
http://www.w3c.org/XML/)
Brahim ER-RAHA
XML ?
XML est un langage d’échange de données structurés
entre applications de différents systèmes d’informations.
Les données d’un fichier XML sont organisée d’une
manière hiérarchique
Les données d’un fichier XML peuvent provenir des
bases de données relationnelles. (Documents XML
Dynamiques)
Les fichiers XML sont également utilisés en tant que
fichiers de configuration d’une application. ( Documents
XML Statiques )
Pour lire un fichier XML, une application doit utiliser un
parseur XML.
Un parseur XML est une API qui permet de parcourir un
fichier XML en vue d’en extraire des données précises.
XML est au cœur des systèmes
d’informations Fichiers XML dont le contenu est généré
Dynamiquement et povient d’une source
De donnée comme une BD relationnelle
Serveur d’application IIS Serveur d’application J2EE
Application .net Application JEE

XML
SGBD XML Parser XML Parser SGBD
SQL Server Oracle
Fichier.xml Fichier.xml
Fichier.xml
Client Leger Fichiers XML dont le contenu

Est créés manuellement
Ajax
Pour configurer l’application
Flash XML
Publication multi-supports
Middleware
XMLizer XML Application de
publication
(XSL)
Base de
Données
TV Numérique
Projet GIE Cartes Bancaires:
publication des spécifications de protocoles pour réseau Carte Bancaires
vers les fournisseurs et prestataires du GIE
Pourquoi XML ?
Échange de données: ETL
Extractor Mapper
JDBC JDBC
BD
relationnelle
Datawarehouse
Datamining
Projet MEN : Echange de données avec
les académies (remontée et descente)
Pourquoi XML ?
Gestion documents semi structurés
Amendemen Serveur d’Applications
t HTTP GET
Requêtes Requêtes
HTTP POST Mapping

XML-SQL
SGBDR
Feuille
Feuille
Feuille
HTML généré de
destyle
Processeur destyle
style
XSL XSL
XSL
XSL
Projet AMELI : Une application de Interface avec les applications

serveur XML pour la saisie et la bureautiques
consultation de documents semi-structurés
par internet/intranet
Pourquoi XML ?
Échange B2B XML EDI
XML EDI
XMLizer
Donneur d’ordre
Internet
(SOAP)
Fournisseur
Projet EDIXML : Expérimentation de la
chaîne pour un grand donneur d'ordres
Pourquoi XML ?
Forces et faiblesses de XML
 Une technologie  Une syntaxe bavarde
structurante  Un méta-langage, mais de
 Clarifie tous les échanges nombreux langages
 Des standards internes et  Coûteux en CPU
externes  Parsing
 Transversale à l'entreprise  Coûteux en mémoire
 Échanges de données
 Instanciation
 Bureautique  Format compressé à l’étude
 GED  XML Binaire
 Sites Web
 EDI
 Bases de données
 Intégration e-business
 …
Pourquoi XML ?
I-2 Avantages de XML
Voici les principaux atouts de XML :
 La lisibilité : aucune connaissance ne doit théoriquement être nécessaire pour

comprendre un contenu d'un document XML
 Autodescriptif et extensible
 Une structure arborescente : permettant de modéliser la majorité des problèmes

informatiques
 Universalité et portabilité : les différents jeux de caractères sont pris en compte
 Déployable : il peut être facilement distribué par n'importe quels protocoles à

de transporter du texte, comme HTTP
 Intégrabilité : un document XML est utilisable par toute application pourvue d'un
parser (c'est-à-dire un logiciel permettant d'analyser un code XML)
 Exensibilité : un document XML doit pouvoir être utilisable dans tous les domaines
Brahim ER-RAHA
XML est particulièrement adapté à l'échange de données et de documents.
L'intérêt de disposer d'un format commun d'échange d'information dépend du
contexte professionnel dans lequel les utilisateurs interviennent. C'est pourquoi,
de nombreux formats de données issus de XML apparaissent (il en existe plus
d'une centaine) :
AML Astronomical Markup Language langage décrivant les différents types de
données utilisées en astronomie.
MathML Mathematical Markup Language notation mathématique sur le web
CML Chemical Markup Language pour la publication Internet des formules

chimiques, de molécules, des équations
VML Vector Markup Language langage de balisage d’information graphique

vectorielle.
PGML Precision Graphics Markup Language décrit les structures de données

graphiques complexes avec les primitives du langage Postscript. Il permet la
conversion de documents aux formats ps et pdf en XML.
SMIL Synchronized Multimedia Integration Language pour la création

multimédia, il spécifie comment et quand des éléments multimédia peuvent
apparaître dans une page web.
Brahim ER-RAHA
CDF Channel Definition Format utilisé par Microsoft pour décrire le contenu
Active Channel. Une chaîne délivre des informations directement à l’utilisateur en
utilisant la technologie push d’un serveur (envoi de contenus web à des
utilisateurs sans que ceux-ci aient besoin d’accéder spécifiquement au site). Les
chaînes fournissent des informations récentes aux utilisateurs qui peuvent
sélectionner le contenu Web qu’ils souhaitent recevoir.
RDF les applications traitant les données RDF peuvent récupérer les informations
(auteur, URL, titre, description) et créer des bases de données permettant la
recherche d’information.
WML Wireless Markup Language le langage de balisage pour l’internet mobile
Brahim ER-RAHA
I-3 Mise en page de XML
XML est un format de description des données et non de leur représentation,

comme c'est le cas avec HTML. La mise en page des données est assurée par un
langage de mise en page tiers. A l'heure actuelle (fin de l'année 2000) il existe trois
solutions pour mettre en forme un document XML :
CSS (Cascading StyleSheet), la solution la plus utilisée actuellement, étant donné

qu'il s'agit d'un standard qui a déjà fait ses preuves avec HTML
XSL (eXtensible StyleSheet Language), un langage de feuilles de style extensible

développé spécialement pour XML. Toutefois, ce nouveau langage n'est pas
reconnu pour l'instant comme un standard officiel
XSLT (eXtensible StyleSheet Language Transformation). Il s'agit d'une

recommandation W3C du 16 novembre 1999, permettant de transformer un
document XML en document HTML accompagné de feuilles de style
Brahim ER-RAHA
I-4 Structure des documents XML
XML fournit un moyen de vérifier la syntaxe d'un document grâce aux DTD
(Document Type Definition). Il s'agit d'un fichier décrivant la structure des
documents y faisant référence grâce à un langage adapté. Ainsi un document
XML doit suivre scrupuleusement les conventions de notation XML et peut
éventuellement faire référence à une DTD décrivant l'imbrication des éléments
possibles.
Un document suivant les règles de XML est appelé document bien formé. Un
document XML possédant une DTD et étant conforme à celle-ci est appelé
document valide.
Brahim ER-RAHA
I-5 Décodage d'un document XML
XML permet donc de définir un format d'échange selon les besoins de

l'utilisateur et offre des mécanismes pour vérifier la validité du document
produit. Il est donc essentiel pour le receveur d'un document XML de pouvoir
extraire les données du document. Cette opération est possible à l'aide d'un
outil appelé analyseur (en anglais parser, parfois francisé en parseur).
Le parseur permet d'une part d'extraire les données d'un document XML (on
parle d'analyse du document ou de parsing) ainsi que de vérifier
éventuellement la validité du document.
Brahim ER-RAHA
Structure d’un document XML
Un document XML se compose de 3 fichiers :

Document XML
Fichier XML DTD Feuille de style

Qui contient Ou XSL
Les données Schémas XML Pour la présentation
Pour déclarer Des données du
La structure Fichier XML
Du fichier XML
Le fichier XML stocke les données du document sous forme d’un arbre
DTD ( Data Type Definition ) ou Schémas XML définit la structure du fichier XML
La feuille de style définit la mise en forme des données de la feuille xml
XML?
Le parseur XML permet de créer une structure
hiérarchique contenant les données contenues
dans le document XML.
Il existe deux types de parseurs XML:
◦ DOM (Document Object Model) : permet
d’accéder et d’agir d’une manière directe sur le
contenu et la structure de l’arbre XML.
◦ SAX (Simple API for XML) : permet de réagir sur le
contenu et la structure d’une document XML
pendant une lecture séquentielle.
II DOCUMENT XML
Tout document XML se compose :
 d’un prologue, dont la présence est facultative mais conseillée. Il contiendra un

certain nombre de déclarations. Le prologue peut contenir une déclaration XML,
des instructions de traitement et une déclaration de type de document.
Syntaxe : <?xml version="1.0" encoding="ISO-8859-1" standalone="yes" ?>

Elle indique au programme qui va traiter le document :
• la version du langage XML utilisée
• le codage de caractères utilisé dans le document ; par défaut ISO 10646 mais le
programme doit pouvoir traiter aussi l’UTF-8 et l’UTF-16.
• l’existence ou non de déclarations extérieures au document qui doivent être prise
en compte pour le traitement de celui-ci.
La déclaration est facultative mais fortement conseillée. Chacune des trois
informations est elle aussi facultative mais si elles apparaissent c’est
obligatoirement dans cet ordre.
 d’un arbre d’éléments. Il forme le contenu du document.
 de commentaires et d’instructions de traitement, dont la présence est facultative.

Ils pourront, moyennant certaines restrictions, apparaître aussi bien dans le
prologue que dans l’arbre d’éléments.
Brahim ER-RAHA
exemple :
Brahim ER-RAHA
Quelques outils de travail
Editeur Outil Support
Tibco Turbo XML DTD, XSL, XQuery

Schéma
Altova XMLSpy DTD, Schéma XSL,
XQuery
SyncRO Ltd. Oxygen DTD, Schéma XSL,
XQuery
Data Junction XML Junction Schéma
Insight Soft. XMLMate DTD, Schéma,

XSL, XPath
XML Mind XMLMind Editor DTD, Schéma,
XSL, XPath
IDE
Exemple de document XML
<?xml version="1.0" encoding="UTF-8"?>
<biblio>
<etudiant code="1" nom="A" prenom="B" age="23">
<livre id="534" titre="java" datePret="2006-11-12" rendu="oui"/>
<livre id="634" titre="XML" datePret="2006-11-13" rendu="non"/>
</etudiant>
<etudiant code="2" nom="C" prenom="D" age="22">
<livre id="33" titre="E-Commerce" datePret="2006-1-12"
rendu="non"/>
</biblio>
</etudiant>
biblio
Biblio
+ etudiant
@code
@nom Etudiant Etudiant Etudiant
@prenom
@age
+ livre
@id livre livre livre
@titre
@datePret
@rendu
Représentation graphique de l’arbre XML

II-1 Documents bien formés
Un document XML est bien formé (l’analyseur XML peut construire son arborescence) si
il suit les règles suivantes :
a- Choisir le nom de nos propre balise

Il y a quelques règles pour la composition des noms des balises :
- Les noms peuvent contenir des lettres, des chiffres ou d'autres caractères.
- Les noms ne peuvent débuter par un nombre ou un signe de ponctuation.
- Les noms ne peuvent commencer par les lettres xml (ou XML ou Xml...).
- Les noms ne peuvent contenir des espaces.
- La longueur des noms est libre.
- On évitera certains signes qui pourraient selon les logiciels, prêter à confusion comme
"-", ";", ".", "<", ">", etc.
On profitera de cette liberté dans les noms pour les rendre le plus descriptif possible
comme par exemple <gras_et_italique>.
b- Les balises sont sensibles au majuscules et minuscules

Ainsi, la balise <Message> est différente de la balise <message>. La balise
d'ouverture et la balise de fermeture doivent donc être identiques. Ainsi par
exemple ; <Message> ... </message> est incorrect et <message> ... </message>
est correct.
Une tendance se dégage pour n'écrire les balises qu'en minuscules, limitant ainsi
les erreurs possibles.
Brahim ER-RAHA
c- Toute balise ouverte doit impérativement être fermée
Fini les écritures bâclées du Html où l'on pouvait dans certains cas omettre la balise
de fin comme pour le paragraphe <p> ou l'élément de liste <li>.
Les éventuelles balises uniques ou appelées aussi balises vides, comme <br>,
<meta> ou <img> en Html, doivent également comporter un signe de fermeture soit
<balise/>. Ainsi une balise <meta/> est correcte en XML.
d- Les balises doivent être correctement imbriquées.
Le XML étant très préoccupé par la structure des données, des balises
mal imbriquées sont des fautes graves de sens. Ainsi l'écriture suivante est
incorrecte car les balises ne sont pas bien imbriquées :
<parent><enfant>Omar</parent></enfant>
L'écriture correcte avec une bonne imbrication des éléments est :
<parent><enfant>Omar</enfant></parent>
Brahim ER-RAHA
e- Tout document XML doit comporter une racine.
En fait, la première paire de balises d'un document XML sera considéré

comme la balise de racine [root]. Par exemple :
<racine>
suite du document XML ...
</racine>
Par exemple :
<parents>
<enfants>
<petits_enfants> ... </petits_enfants>
</enfants>
</parents>
f- Les attributs des éléments
Le XML peut avoir (comme le Html) des attributs avec des valeurs. En XML, les
valeurs des attributs doivent obligatoirement être entre des guillemets, au
contraire du Html où leur absence n'a plus beaucoup d'importance. Ainsi,
l'écriture suivante est incorrecte car il manque les guillemets.
<date anniversaire=071185> La bonne écriture est :

<date anniversaire="071185">
Brahim ER-RAHA
g- Attributs prédéfinis
Exemple1 :
<test>
<code xml:space="preserve">Ici les espaces ainsi
que les sauts de ligne sont préservés
</code>
<code xml:space="default"> les espaces ainsi que les sauts de ligne
sont traités suivant le mode par défaut de l'application XML.
</code>
</test>
Exemple2 :
<test>
<code xml:lang="fr">Ici, du français</code>
<code xml:lang="fr-FR">Ici, il n'y a pas une seule
bogue</code>
<code xml:lang="fr-CA">Ici, il n'y a pas un seul
bogue</code>
<code xml:lang="en-GB">Watercolour</code>
<code xml:lang="en-US">Watercolor</code>
</test>
Brahim ER-RAHA
h- Contenu d’un élément
Un élément peut contenir d’autres éléments, des données, des références à des
entités, des sections littérales et des instructions de traitement.
Un élément peut avoir un contenu récursif, c’est à dire qu’il peut contenir une
instance du même type d’élément que lui-même.
Les données des éléments peuvent contenir tous les caractères autorisés sauf le
et commercial & et le inférieur <. Mais on peut toujours utilisé la section CDATA,
Par exemple :
<test>
<code><![CDATA[Ici on peut mettre ce que l'on
veut, < ou &, sans
problèmes, sauf la chaîne ]]>, bien sûr
</code>
</test>
Brahim ER-RAHA
j- Référence à des caractères ou à des idéogrammes
Un auteur peut vouloir insérer un caractère non disponible sur sa plate-forme

ou son clavier. Il utilise pour cela le numéro du caractère dans les tables ISO
10646 ou Unicode.
Ce numéro sera précédé des caractères &# puis suivi d’un point virgule ;. Le
numéro peut être donné en décimal ou en hexadécimal (dans ce cas on le
préfixe par &#x).
Par exemple & ou ≧ correspond au caractère et commercial &
k- Référence à des entités prédéfinies
Il existe quelques entités prédéfinies afin de faciliter leur insertion dans un

document XML. Il s’agit notamment des caractères <, >, &, ‘ et «
< <
> >
& &
' ‘
" "
Brahim ER-RAHA
l- Les commentaires
Des commentaires peuvent être insérés dans les documents. Ils sont encadrés
pas les marques de début  de commentaire.
Syntaxe : 
Le corps du commentaire peut contenir n’importe quel caractère à l’exception de

la chaîne --. On ne peut donc pas inclure un commentaire dans un autre. Le
commentaire ne peut pas non plus être inclus à l’intérieur d’une balise.
Brahim ER-RAHA
II-2 Document XML validé
XML permet d'utiliser un fichier afin de vérifier qu'un document XML est conforme à
une syntaxe donnée. La norme XML définit ainsi une définition de document type
appelée DTD (Document Type Definition), c'est-à-dire une grammaire permettant
de vérifier la conformité du document XML. La norme XML n'impose pas l'utilisation
d'une DTD pour un document XML, mais elle impose par contre le respect exact
des règles de base de la norme XML.
Document Valide : pour un document XML bien formé, fait référence a une DTD
et il se conforme à elle.
Document Bien Formé : pour un document XML ne comportant pas de DTD mais
répondant aux règles de base du XML
Une DTD peut être définie de 2 façons:
sous forme interne : c'est-à-dire en incluant la grammaire au sein même du

document
sous forme externe : soit en appelant un fichier contenant la grammaire à partir
d'un fichier local ou bien en y accédant par son URL
Brahim ER-RAHA
II-3 Utilisation des DTD
a- DTD interne
Un document valide peut inclure directement sa DTD dans sa déclaration de type.

L'attribut standalone doit prendre la valeur yes, indiquant ainsi que le document
est complet et qu'aucune déclaration externe ne doit être recherchée.
Exemple :
<?xml version="1.0" standalone="yes" ?>
<!DOCTYPE carte [
<!ELEMENT carte (#PCDATA)>
]>
<carte>As de pique</carte>
b- DTD externe
Le document peut aussi faire référence à une DTD stockée dans une entité
externe. L'avantage est alors la réutilisation possible de la DTD.
Exemple : Fichier jeu.xml
<?xml version="1.0" standalone="no" ?>

<!DOCTYPE carte SYSTEM "carte.dtd"> Fichier carte.dtd
<carte>As de pique</carte>
Brahim ER-RAHA
1- Syntaxe d’utilisation d’une DTD
La déclaration de type de document indique, le cas échéant, la DTD à laquelle

se conforme le document. Elle permet aussi de spécifier certaines déclarations
propres au document. La syntaxe de déclarations est :
Syntaxe : <!DOCTYPE Racine [ déclarations ]>
Racin : est le nom de l’élément racine de document XML.
Déclarations : ils contient la définition de tous les éléments constituant le

document XML. Il s’agit de :
 les éléments types, i.e. elle donne les noms de tous les éléments et leur
modèle de contenu ;
 les attributs pour chaque élément (nom, type et valeur par défaut) ;
 les entités et les notations qui servent à identifier les types spécifiques de
données externes.
Brahim ER-RAHA
2 Déclaration des éléments
La syntaxe de déclaration d’un élément est la suivante :
<!ELEMENT nom_element modele_de_contenu>
Élément vide
Un élément vide ne contient aucun texte, aucun autre élément, comme les
éléments IMG, HR, BR de HTML.
<!ELEMENT nom_element EMPTY>
Par exemple, dans la DTD de XHTML 1.0 l’élément img est déclaré : <!
ELEMENT img EMPTY>
Élément non vide
Un élément non vide est formé d’une balise ouvrante, d’un contenu et d’une balise
fermante. Pour décrire ce contenu dans la DTD on utilise un modèle de contenu
dans la déclaration d’éléments
Brahim ER-RAHA
Données
Si l’élément contient uniquement des données (autrement dit, s’il n’y a aucun autre
élément inclus dans cet élément) on utilise le type #PCDATA qui signifie Parsed
Character DATA i.e. données caractères analysées :
<!ELEMENT nom_element (#PCDATA)>
Conteneur d’éléments
Si l’élément contient uniquement d’autres éléments, le modèle de contenu définit les

éléments pouvant être inclus dans un élément donné et spécifie également les
éléments devant apparaître obligatoirement, leur ordre et leur fréquence.
Les parenthèses dans la déclaration d’élément introduisent les éléments enfants de

l’élément défini. L’ordre dans lequel les éléments sont précisés est l’ordre dans lequel
ils doivent apparaître dans l’élément en cours de définition. Pour indiquer des choix, il
est possible d’utiliser le |.
Les indicateurs d’occurrences sont les suivants :

? = 0 ou 1 fois
* = 0 ou n fois
+ = au moins une fois
Brahim ER-RAHA
Opérateur Signification Exemple
+ L'élément doit être présent au minimum une fois A+
* L'élément peut être présent plusieurs fois (ou aucune) A*
? L'élément peut être optionnellement présent A?
| L'élément A ou B peuvent être présents (pas les deux) A|B
, L'élément A doit être présent et suivi de l'élément B A,B
Les parenthèses permettent de regrouper des éléments afin de leur appliquer les
() (A,B)+
autres opérateurs
Mixte
Si l’élément a un contenu mixte (données + éléments) il est possible d’utiliser

PCDATA et les éléments imbriqués. Dans le cas d'un modèle mixte (Données
textuelles et balises)
• #PCDATA est toujours en première position

• le modèle se termine par le caractère de répétition '*‘
<!ELEMENT mixedElement (#PCDATA | inlineElement1 | inlineElement2 )*>
Élément libre
Élément qui peut contenir tout élément déclaré dans la DTD et du texte.
<!ELEMENT nom_element ANY>
Brahim ER-RAHA
<bibliothèque>
<livre>
<titre>N ou M</titre>
<auteur>Agatha Christie</auteur>
<ref>Policier-C-15</ref>
</livre>
<livre>
<titre>Le chien des Baskerville</titre>
<auteur>Sir Arthur Conan Doyle</auteur>
<ref>Policier-D-3</ref>
</livre>
<livre>
<titre>Dune</titre>
<auteur>Franck Heckbert</auteur>
<ref>Fiction-H-1</ref>
</livre>
</bibliothèque>
Proposer une DTD qui valide ce document ?
Brahim ER-RAHA
3- Déclaration d’attribut
Le rôle de la déclaration d’attributs est de donner pour un élément cible :

 les noms d’attributs permis ;
 le type de chaque attribut ;
 la valeur par défaut de l’attribut.
<!ATTLIST element_cible nom_attribut type_attribut valeur_par_défaut>
Valeur par défaut
La valeur par défaut est la valeur prise par l’attribut si aucune valeur n’est
précisée dans l’élément. Cette valeur doit être du même type que celui donné à
l’attribut.
 "une simple chaîne de caractères"

 #REQUIRED = obligatoire, i.e. la valeur d’attribut doit être spécifiée lorsque
l’élément est utilisé dans le document
 #IMPLIED = facultatif, i.e. la valeur d’attribut peut rester non spécifiée
 #FIXED ‘val’ = fixée à ‘val’ i.e. la valeur de l’attribut est fixe et ne peut pas être
modifiée par l’utilisateur
Brahim ER-RAHA
Types de données
- chaînes de caractères CDATA

Le type d'attribut CDATA indique que la valeur de l'attribut sera une chaîne de
caractères prise littéralement, c'est à dire sans reconnaissance et traitement des
caractères spéciaux de la syntaxe XML.
<!ATTLIST element_cible nom_attribut CDATA valeur_par_défaut>
- Énumérations
<!ATTLIST element_cible nom_attribut (val1 | val2 | ... | valN) « valdefaut »>
Ce type d'attribut permet de spécifier la liste des valeurs qu'il peut prendre dans un
document. Il est également possible d'indiquer une valeur par défaut.
-Identificateurs
<!ATTLIST element_cible nom_attribut ID>

<!ATTLIST element_cible nom_attribut IDREF>
Un attribut de type ID représente un identificateur unique d’élément, i.e. un attribut

dont la valeur distingue l’élément de tous les autres dans le document XML courant
Notons que cet attribut prend généralement le nom id
Un attribut ID ne peut être que du type REQUIRED
Brahim ER-RAHA
Un opérateur Télécom fournit périodiquement, à l’opérateur de réglementation des
télécoms ANRT un fichier XML qui contient les clients de cet opérateur. Chaque
client possède plusieurs abonnements et chaque abonnement reçoit plusieurs
factures. Un exemple de fichier XML correspondant à ce problème est le suivant :


<operateur>
<client code="1" nom="hassouni">
<abonnement num="123" type="GSM" dateAb="2006-1-11">
<facture numFact="432" dateFact="2006-2-11" montant="350.44" reglee="oui"/>
<facture numFact="5342" dateFact="2006-3-11" montant="450" reglee="oui"/>
<facture numFact="5362" dateFact="2006-4-13" montant="800.54" reglee="non"/>
</abonnement>
<abonnement num="2345" type="FIXE" dateAb="2006-12-1">
<facture numFact="6432" dateFact="2007-2-12" montant="555" reglee="non"/>
</abonnement>
</client>
<client code="2" nom="abbassi">
<abonnement num="7543" dateAb="2006-12-1" type="GSM">
<facture numFact="7658" dateFact="2007-2-12" montant="350.44" reglee="oui"/>
</abonnement>
</client>
</operateur>
Brahim ER-RAHA
Travail demandé
1. Faire une représentation graphique de l’arbre XML.
2. Ecrire une DTD qui permet de valider ce document XML
3. Créer le fichier XML
4. Ecrire une feuille de style XSL qui permet de transformer le document
XML en une page HTML qui permet d’afficher pour chaque client la
liste de ses abonnement en affichant le montant total des factures de
chaque abonnement
Corrigé : DTD operateur
+client
@code
<!ELEMENT operateur (client+) >
<!ELEMENT client (abonnement+) > @nom
<!ELEMENT abonnement (facture+) >
<!ELEMENT facture EMPTY > +abonnement
<!ATTLIST client
code NMTOKEN #REQUIRED @num
nom CDATA #REQUIRED>
<!ATTLIST abonnement @type
num NMTOKEN #REQUIRED @dateAb
type (GSM|FIXE) 'FIXE'
dateAb CDATA #REQUIRED> +facture
<!ATTLIST facture
numFact NMTOKEN #REQUIRED @numFact
dateFact CDATA #REQUIRED
montant CDATA #REQUIRED @dateFact
reglee (oui|non) 'non'> @montant
@reglee
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:template match="/">
<html>
<head></head>
<body>
<xsl:for-each select="operateur/client">
<h3>
Nom Client : <xsl:value-of
select="@nom"/>
</h3>
<table border="1" width="80%">
<tr>
<th>Num</th><th>Type</th><th>Date</th><th>Total
Factures</th>
</tr>
<xsl:for-each select="abonnement">
<tr>
<td><xsl:value-of select="@num"/></td>
<td><xsl:value-of select="@type"/></td>
<td><xsl:value-of select="@dateAb"/></td>
<td><xsl:value-of
select="sum(facture/@montant)"/></td>
</tr>
</xsl:for-each>
</table>
</xsl:for-each>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
-Attribut ENTITY ou ENTITIES
Les types ENTITY et ENTITIES représentent un nom / une liste de noms d’entités
séparées par des blancs, non-XML précédemment déclarées dans la DTD.
C’est utilisé par exemple pour établir un lien avec une image.
Exemple :
<!ATTLIST image source ENTITY #REQUIRED>

<!ENTITY vacances SYSTEM " plage.gif">
qui sera utilisé dans le document XML : <image source="vacances"/>
-Attributs NMTOKEN ou NMTOKENS
Le type d'attribut NMTOKEN permet d'indiquer que l'attribut de l'élément peut prendre
comme valeur un nom symbolique composé uniquement de caractères
alphanumériques.
Exemple :
<-- Dans une DTD -->
<!ELEMENT livre EMPTY>
<!ATTLIST livre code_editeur NMTOKEN #REQUIRED>
<-- Dans le corps du document -->
<livre code_editeur="G09052" />
Brahim ER-RAHA
-Attribut NOTATION
NOTATION signifie que l’attribut attend une notation qui apparaît dans la DTD dans
une déclaration NOTATION Si une liste de valeurs est préfixée par le mot NOTATION
les notations listées comme des valeurs possibles doivent toutes avoir déjà été
déclarées :
Exemple :
<!ATTLIST image type NOTATION(GIF | JPEG | PNG) " GIF ">
4- Déclaration d’entité
Chaque entité XML est définie dans une DTD. Les entités spécifiques au document
sont présentes dans sa DTD interne (images, autres documents non XML,
caractères spécifiques).
Une entité est un alias associant un nom à un groupe de données. Ces données
peuvent prendre un ou plusieurs formats
Brahim ER-RAHA
- Entités paramètres
<!ENTITY % nom « chaîne_de_remplacement »>

Ces entités apparaissent uniquement dans les DTD. Ce sont des raccourcis vers des
parties de déclarations de la DTD.
Exemple :
<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE article [
<!ENTITY % fich-dtd-1 SYSTEM "fichier-1.dtd">

<!ENTITY % fich-dtd-2 SYSTEM "fichier-2.dtd">
%fich-dtd-1;
%fich-dtd-2;
<!ENTITY % texte "#PCDATA">

<!ELEMENT nom (%texte;)>
<!ELEMENT prénom (%texte;)>
..
]>
Brahim ER-RAHA
- Entités caractères
la syntaxe de déclaration est :<!ENTITY nom "&#code;">
Les entités caractères sont des caractères réservés du XML représentés sous forme
d'entités générales afin de pouvoir les insérer dans le document XML. Voici la liste
des entités caractères principales :
Entité caractère Représentation

& &
< <
> >
' '
" "
Il est également possible de définir des entités caractères pour n'importe quel
caractère en utilisant le code hexadécimal du caractère :
<! ENTITY nome "&#xCODEHEXA;">
Par exemple
<! ENTITY ccedille "ç">
<!ENTITY CopieRight "©">
<!ENTITY Delta "δ" >
Dans le document l’appel s’effectue avec &nom;
<code> le petit Delta est : Δ</code>
Brahim ER-RAHA
-Entités générales
Les entités générales permettent de définir des éléments pouvant être substitués
dans le corps du document XML (bien qu'ils soient définis au sein de la DTD et non
du document XML lui-même).
La syntaxe d'une entité générale est la suivante :

<! ENTITY nom_de_l_entite "Contenu de l'entite">
Il est par exemple possible de déclarer l'entité générale suivante dans la DTD :
<! ENTITY site "commentcamarche.net">
Les entités définies dans la DTD peuvent ainsi être utilisées dans le code XML en
les appelant avec la syntaxe suivante :
&nom_de_l_entite;
La déclaration précédente pourra donc donner un document XML du style:
<personne>
<nom>Pillou</nom>
<prenom>Jean-Francois</prenom>
<site>&site;</site>
<email>webmaster@&site;</email>
</personne>
Brahim ER-RAHA
Entités externes
Les entités générales peuvent aussi être contenues dans un fichier extérieur
(afin d'être utilisé par plusieurs DTD par exemple), on parle alors d'entité externe.
La syntaxe d'une entité externe est la suivante :
<! ENTITY nom_de_l_entite SYSTEM "nom_du_fichier">
Dans l'exemple suivant, le contenu du fichier ccm.txt (situé dans le même

répertoire que la DTD) sera inséré dans le fichier XML à chaque fois que l'entité
&ccm; sera rencontrée :
<! ENTITY ccm SYSTEM "ccm.txt">
Les entités externes représentent des données contenues dans des fichiers
séparés par rapport au document XML.
 Analysées
<!ENTITY nom SYSTEM « URL »>
Brahim ER-RAHA
Exemple :
<!DOCTYPE book SYSTEM « book.dtd »

[
<!ENTITY toc SYSTEM « toc.xml »>
<!ENTITY chap1 SYSTEM « chapters/c1.xml »>
<!ENTITY chap2 SYSTEM « chapters/c2.xml »>
<!ENTITY index SYSTEM « index.xml »>
]>
<book>
<head>&toc;</head>
<body>
&chap1;
&chap2;
&index;
</body>
</book>
Brahim ER-RAHA
Non analysées
La syntaxe de déclaration est :

<!ENTITY nom SYSTEM « URI » NDATA type_notation>
Les entités externes non analysées permettent de déclarer un contenu non XML
dans le document XML (fichiers binaires images, sons...). Ces entités requièrent
en particulier une notation. Une notation identifie le format, ou type, des
ressources auxquelles se réfère l’entité.
Voici un exemple :
<!ENTITY Image SYSTEM « Image02.Gif » NDATA GIF>
Cette déclaration d’entité signifie littéralement, l’entité Image est un fichier binaire
dans la notation GIF. Le mot clé NDATA (Notation DATA) précise le type d’entité
non analysée que le processeur XML doit traiter.
indique au processeur XML
< !NOTATION GIF SYSTEM « /utils/Gifview.exe »>
Brahim ER-RAHA
III MODELE SCHAMA XML
Dans le paragraphe précédent nous avons vu la syntaxe et la déclaration d'une DTD

au ceint d'un document XML. Néanmoins, les DTD présentent des inconvénients :
- Ce n'est pas une application XML: il utilise une syntaxe dédiée

- Les types de données sont limités
- Le contrôle du nombre d'occurrences est limité par les opérateurs ?,+,*
- Ils ne tiennent pas compte des espaces de noms (namespaces)
- La modularisation est limitée à la notion d'entité
En remplacement, le consortium W3 a défini la notion de schéma, qui utilise la

notation XML. (2 mai 2001).
Un schéma doit permettre de spécifier le même genre d'information qu'une DTD,

c'est-à-dire la syntaxe d'une classe de documents XML, en définissant les éléments et
attributs ainsi que les contraintes sur les valeurs de ceux-ci.
La validation d'un document XML au moyen d'un schéma englobe :
- La validité du modèle de contenu (structure)

- La validité des types de données
Brahim ER-RAHA
III-1 Syntaxe de Déclaration d'un Schema
1- Sans espace de nom
Les schémas peuvent être utilisés avec ou sans espace de nom. Sans espace de
nom associé, l'élément racine d'un schéma a la forme suivant :
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
</xs:schema>
l'assignation de ce type de document Schema dans un documnet XMLde racine

Root afin de le valider se fait comme suit :
<Root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="modele.xsd">
</Root>
où modele est le nom du fichier contenant le schéma.
Brahim ER-RAHA
2- Schéma avec espace de nom
Si un schéma définit un espace de nom, son élément racine définit les attributs
suivants :
-targetNamespace="URI", pour définir l'espace de nom dans lequel le schéma définit

ses éléments
-xmlns="URI", l'espace de nom par défaut (souvent identique à targetNamespace)
-elementFormDefault et attributeFormDefault pour déterminés si les éléments

(resp. les attributs), par défaut, sont qualifiés
l'assignation de ce type de document Schema dans un document XML de racine Root

afin de le valider se fait comme suit :
<Root xmlns="URI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance“

xsi:schemaLocation="URI Modele.xsd">
</Root>
Brahim ER-RAHA
Voir le dossier Exemple cours XML
Brahim ER-RAHA
III-1 Déclaration des éléments dans un Schema
Les éléments sont les principaux composant d'un document schema.
 Un élément ne contenant pas de sous-élément ni d'attribut est considéré

comme étant de type simple (p.ex. <auteur>Bertrand Ibrahim</auteur>).
 Un élément contenant soit des sous-éléments (p.ex. <titre> Un journaliste
<souligne> accuse </souligne>, ...</titre>), soit des attributs, ou même les deux
à la fois est considéré de type complexe.
Il y a trois formes de déclaration d'élément
- <xs:element name=" LeNomDeMonElement ">

... simple or complex type definition
</xs:element>
- <xs:element name="LeNomDeMonElement" type="LeTypeDeContenuDeCetElement "/>
-<xs:element ref=" LeNomDeMonElement "/>
Avec name représente le nom de l'élément et type détermine le type de son contenue
Brahim ER-RAHA
a- Définition des types simples
a-1 Type simple prédéfini
Les éléments peuvent avoir un continue simple de l'un des tes types prédéfinis
suivants :
string, boolean, byte, int, integer, long, float, double, date, time, Name (un nom
conforme à XML), anyURI
Exemple :
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified">
<xs:element name="Prix" type="xs:decimal"/>
</xs:schema>
<Prix xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="C:\Untitled2.xsd">192.25</Prix>
----------------------------------------------------------------------------------------------------
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="DateNaissance" type="xs:date"/>
</xs:schema>
<DateNaissance xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="C:\Untitled3.xsd">1923-12-05</DateNaissance>
Brahim ER-RAHA
Les types simples (1)
 string  integer
 Confirm this is electric  -126789, -1, 0, 1, 126789
 normalizedString  positiveInteger
 Confirm this is electric  1, 126789
 token  negativeInteger
 Confirm this is electric  -126789, -1
 byte  nonNegativeInteger
 -1, 126  0, 1, 126789
 unsignedByte  nonPositiveInteger
 0, 126  -126789, -1, 0
 base64Binary  int
 GpM7  -1, 126789675
 hexBinary  unsignedInt
 0FB7  0, 1267896754
Schema
 long  boolean
 -1, 12678967543233  true, false 1, 0
 unsignedLong  time
 0, 12678967543233  13:20:00.000, 13:20:00.000-
 short 05:00
 -1, 12678  dateTime
 unsignedShort  1999-05-31T13:20:00.000-
 0, 12678 05:00
 decimal  duration
 -1.23, 0, 123.4, 1000.00  P1Y2M3DT10H30M12.3S
 float  date
 -INF, -1E4, -0, 0, 12.78E-2, 12,  1999-05-31
INF, NaN  gMonth
 double  --05--
 -INF, -1E4, -0, 0, 12.78E-2, 12,
INF, NaN
 gYear
 1999
Schema
 gYearMonth  language
 1999-02  en-GB, en-US, fr
 gDay
 ---31
 ID
 gMonthDay  "A212"
 --05-31  IDREF
 Name  "A212"
 shipTo
 IDREFS
 QName
 po:USAddress
 "A212" "B213"
 NCName  ENTITY
 USAddress  ENTITIES
 anyURI
 http://www.example.com/,
 NOTATION
 http://www.example.com/  NMTOKEN, NMTOKENS
doc.html#ID5  US
 Brésil Canada Mexique
Schema
a-2 Type simple personnalisé (dérivé)
Les types simples personnalisés peuvent être utilisés soit :
 Localement
<xs:element name="myelt">
<xs:simpleType>
definition de type
</xs:simpleType>
</xs:element>
Globalement et réutilisés
et le déclaration de type dans l'élément se
<xs:simpleType name="mytype"> fait par:
definition de type <xs:element name="myelt" type="mytype"/>
</xs:simpleType>
La dérivation de ces types à partir des types prédéfinis se fait soit par :
- Restriction (en utilisant des facettes de contrainte)

- List
- Union
- Extension
Brahim ER-RAHA
1- Restriction
Une restriction limite les valeurs possibles d'un type donné (appelé type de base) et est
définie sur certaines propriétés du type de base, appelées facettes de contraintes
dont les valeurs les plus utilisés sont :
-length (longueur de chaîne) ou minLength et maxLength (bornes inf. et sup. de la

langueur)
- pattern (expression régulière)
- enumeration (ens. de valeurs)
- minInclusive, maxInclusive , minExclusive, maxExclusive (bornes des valeurs)
- totalDigits (nombre de chiffres d'un nb. entier)
-fractionalDigits (nombre de chiffres significatifs pour la partie décimale)
la facette pattern permet de contraindre la forme lexicale à l'aide d'une expression

régulière (en perl)
- [abc] désigne les lettres a, b, c

- [a-z] désigne les lettres allant de a à z - E{n} signifie exactement n fois
- ^[abc] signifie toutes les lettres sauf a, b, c - E|F signifie soit E soit F
- E? signifie 0 ou 1 fois - \ sert de caractère d'échappement
- E* signifie 0 ou plusieurs fois
- E+ signifie 1 ou plusieurs fois
- E{n,m} signifie entre n et m fois
Brahim ER-RAHA
<xsd:simpleType name="Code"> <xsd:simpleType name="JourDeSemaine">
<xsd:restriction base="xsd:integer"> <xsd:restriction base="xsd:string">
<xsd:minInclusive value="1000" /> <xsd:enumeration value="lundi" />
<xsd:maxInclusive value="9999" /> <xsd:enumeration value="mardi" />
</xsd:restriction> <xsd:enumeration value="mercredi" />
</xsd:simpleType> <xsd:enumeration value="jeudi" />
<xsd:element name="AA" type="Code"/> <xsd:enumeration value="vendredi" />
<AA> 9999 </AA> <xsd:enumeration value="samedi" />
<xsd:enumeration value="dimanche" />
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="AA" type="JourDeSemaine"/>
<AA> lundi </AA>
<xsd:simpleType name="Date"> <xsd:restriction <xsd:simpleType name="code"> <xsd:restriction
base="xsd:string"><xsd:pattern value="\d{2}-\ base="xsd:string"><xsd:pattern value="[A-Za-z]{6}-\
d{2}-\d{4}"/> d{2}"/> </xsd:restriction></xsd:simpleType>
</xsd:restriction></xsd:simpleType> <xsd:element name="AA" type="code"/>
<xsd:element name="AA" type="Date"/> <AA> Agadir-25 </AA>
<AA> 23-05-1998 </AA>
<xs:simpleType name="type-no-tel"> <xs:simpleType name="AS">
<xs:restriction base="xs:string"> <xs:restriction base="xs:float">
<xs:pattern <xs:totalDigits value="4"/>
value="0[1-9]{1,2} [0-9]{3} [0-9]{3}" /> <xs:fractionDigits value="2"/>
</xs:restriction> </xs:restriction>
</xs:simpleType> </xs:simpleType>
<xsd:element name="AA" type="type-no-yel"/> <xs:element name="AA" type="AS"/>
<AA> 066 000 000 </AA> <AA> 12.56 </AA>
Brahim ER-RAHA
2- List
La liste permet de définir un nouveau type à partir d'un type de base, où une valeur du nouveau
type correspond à plusieurs valeurs du type de base séparées par un espace. Exemple :
<xsd:simpleType name="Ville"> <xsd:simpleType name="ListeVille"> <xsd:list

<xsd:restriction base="xsd:string"> itemType="Ville"/></xsd:simpleType>
<xsd:enumeration value="Agadir"/> <xsd:element name="villes" type="ListeVille"/>
<xsd:enumeration value="Fes"/> <villes>Agadir </villes>
<xsd:enumeration value="Casa"/>
<xsd:enumeration value="Rabat"/>
</xsd:restriction>
</xsd:simpleType>
3- Union
L'union permet de définir un nouveau type incluant toutes les valeurs possibles d'un certain
nombre d'autres types. Par exemple :
<xsd:simpleType name="JourDeSemaine"> <xsd:simpleType name="AbregeSemaine">

<xsd:restriction base="xsd:string"> <xsd:restriction base="xsd:string">
<xsd:enumeration value="lundi" /> <xsd:enumeration value="lu" />
<xsd:enumeration value="mardi" /> <xsd:enumeration value="ma" />
<xsd:enumeration value="mercredi" /> <xsd:enumeration value="me" />
<xsd:enumeration value="jeudi" /> <xsd:enumeration value="je" />
<xsd:enumeration value="vendredi" /> <xsd:enumeration value="ve" />
<xsd:enumeration value="samedi" /> <xsd:enumeration value="sa" />
<xsd:enumeration value="dimanche" /> <xsd:enumeration value="di" />
</xsd:restriction> </xsd:restriction>
</xsd:simpleType> </xsd:simpleType
Brahim ER-RAHA
<xsd:simpleType name="JrSemaine">
<xsd:union memberTypes="JourDeSemaine AbregeSemaine" />
</xsd:simpleType>
<xsd:element name="AA" type="JrSemaine"/>
<AA> Lundi lu </AA>
le type JrSemaine ci-dessous est défini à partir des types JourDeSemaine et

AbregeSemaine définis précédemment et correspond à une chaîne de caractères
indiquant un jour de la semaine ou un abrégé de jour de la semaine
4- Extension
Une extension consiste à définir un nouveau type à partir d'un type existant en lui
ajoutant éventuellement des sous-éléments et/ou des attributs. Une extension produit
donc toujours un type complexe. On en verra des exemples plus loin
Brahim ER-RAHA
b- Définition de types complexes
Un type complexe est défini à l'aide de l'élément <xsd:complexType name="..."> qui
pourra contenir, entre autres, une séquence d'éléments, une série d'attributs, etc. On
définit d'abord les sous-éléments, puis les attributs.
Comme les types simples, les types complexe peuvent être utilisés soit:
 localement  globalement et réutilisés

<xs:element name="myelt"> <xs:complexType name="mytype">
<xs:complexType> definition de type
definition de type </xs:complexType>
</xs:complexType> <xs:element name="myelt" type="mytype"/>
</xs:element>
Un type complexe est définit à l'aide de compositeurs (règles de composition), il existe

trois sortes de compositeurs :
-<xs:sequence> : les sous-éléments énumérés doivent être tous présents dans l'ordre
indiqué
-<xs:choice> : un seul des sous-éléments énumérés doit être présent (exclusion
mutuelle)
-<xs:all> : les sous-éléments énumérés doivent être tous présents au plus une fois,
dans n'importe quel ordre. Les attributs minOccurs et maxOccurs doivent
valoir 0 ou 1.
Brahim ER-RAHA
Les attributs minOccurs et maxOccurs contrôlent les occurrences d'apparition
d'un élément, par défaut, minOccurs="1" et maxOccurs="1" et en particulier
minOccurs="0" signifie qu'il est optionnel et maxOccurs="unbouded" signifie qu'il est
répétitif. Ces attributs peuvent être utilisés dans une définition d'élément
<element ...> et aussi dans les compositeurs (sequence, choice, all)
b-1 contenu composé uniquement de sous-éléments
Compositeur déclaration du type document XML

valide
sequence <xsd:complexType name="EnteteType" > <entete>
<xsd:sequence> <titre>...</titre>
<xsd:element name="titre" type="xsd:string" /> <auteur>...</auteur>
<xsd:element name="auteur" type="xsd:string" /> <date> …</date>
<xsd:element name="date" type="xsd:string" /> <lieu>…</lieu>
<xsd:element name="lieu" type="xsd:string" /> </entete>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="entete" type="EnteteType" />
Brahim ER-RAHA
sequence
<xsd:complexType name="EnteteType" >
<xsd:sequence minOccurs=2>
<xsd:element name="titre" type="xsd:string" />
<xsd:element name="auteur" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
<entete>
<titre>...</titre>
<auteur>...</auteur>
<titre> …</titre>
<auteur>…</auteur>
</entete>
Brahim ER-RAHA
<xsd:sequence minOccurs=2>
<xsd:element name="titre" type="xsd:string" minOccurs=2/>
</xsd:sequence>
</xsd:complexType>
<entete>
<titre>...</titre>
<titre>….</titre>
<titre> …</titre>
<titre>….</titre>
</entete>
Brahim ER-RAHA
Choice
<xsd:choice minOccurs=2>
<xsd:element name="titre" type="xsd:string" />
</xsd:choice>
</xsd:complexType>
<entete>
<titre>...</titre>
</entete>
Brahim ER-RAHA
<xsd:choice minOccurs="2">
<xsd:element name="titre" type="xsd:string" minOccurse="2" />
</xsd:choice>
</xsd:complexType>
<entete>
<titre>...</titre>
<titre>….</titre>
</entete>
Brahim ER-RAHA
all
<xsd:all minOccurs="1">
<xsd:element name="titre" type="xsd:string" minOccurse="1" />
</xsd:choice>
</xsd:complexType>
<entete>
<titre>...</titre>
<auteur> …</auteur>
<titre>….</titre>
</entete>
minOccurs ou maxOccurs de all et de ses éléments n’accepte que 0 ou 1
Brahim ER-RAHA
b-2 contenu composé uniquement d'attributs (Element vide)
On commence par déclaration du type:
<xsd:complexType name="ImageType">
<xsd:attribute name="src" type="xsd:anyURI" />
</xsd:complexType>
b-3 Exemple de contenu composé d'un contenu simple et d'attributs
Pour indiquer qu'un élément est composé d'un continu simple on utilise
l'élément s:simpleContent avec l'élément de dérivation xs:extension
comme il est monté sur les exemples suivants:
Brahim ER-RAHA
 Déclaration de type :
<xsd:element name="price">
<xsd:complexType>
<xsd:simpleContent>
<xsd:extension base="xsd:decimal">
<xsd:attribute name="currency" type="xsd:string" />
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
</xsd:element>
utilisation de l'élément dans un document XML:
<prix currency="EUR">423.46</prix>
Brahim ER-RAHA
 déclaration du type :
<xsd:simpleType name="NombreDeuxDecimales">
<xsd:restriction base="xsd:decimal">
<xsd:fractionDigits value="2"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="PrixType">
<xsd:simpleContent>
<xsd:extension base="NombreDeuxDecimales">
<xsd:attribute name="monaie" type="xsd:string" />
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
 déclaration d'un élément de ce type:

<xsd:element name="prix" type="PrixType" />
 utilisation de l'élément dans un document XML:

<prix monaie="CHF">3.50</prix>
Brahim ER-RAHA
b-4 Exemple de contenu composé de caractères et de sous-éléments (utilisation
de l'attribut mixed="true")
Pour indiquer qu'un élément est d'un continu composé on utilise l'attribut mixed="true"
de l' élément xs:complexType.
 déclaration du type :
<xsd:complexType name="TexteType" mixed="true">

<xsd:sequence>
<xsd:element name="grand" type="xsd:string" minOccurs="0" maxOccurs="unbounded" />
</xsd:sequence>
</xsd:complexType>
 déclaration d'un élément de ce type :
<xsd:element name="texte" type="TexteType" />
De par l'attribut mixed de l'élément xsd:complexType, l'élément texte pourra contenir du

texte aussi bien qu'un nombre indéterminé de sous-éléments grand. De par sa
déclaration, l'élément grand ne peut contenir que du texte simple.
Brahim ER-RAHA
c-Définitions d'attributs dans un type complexe
Pour illustrer la définition d'attributs, reprenons l'exemple suivant :
<article titre="Un journaliste accuse, un policier dément" auteur="Alain Connu"

date="14 juin 1972" lieu="banquise">...</article>
Le schéma correspondant serait :
<xsd:element name="article" >

<xsd:complexType>
... 
<xsd:attribute name="titre" type="xsd:string" />
<xsd:attribute name="auteur" type="xsd:string" use="required" />
<xsd:attribute name="date" type="xsd:date" use="required" />
<xsd:attribute name="lieu" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
Dans une déclaration d'attribut, l'attribut use peut prendre les valeurs suivantes
valeur de l'attribut use signification
prohibited l'attribut ainsi défini ne doit pas apparaître
optional l'attribut peut apparaître au plus une fois
required l'attribut doit apparaître
Brahim ER-RAHA
Si l'attribut use n'est pas utilisé, la valeur par défaut est optional.
autres
signification
attributs
si l'attribut ainsi défini est présent dans la balise, il ne peut prendre que la valeur associée à
fixed fixed. Exemple:
<xsd:attribute name="..." type="xsd:decimal" fixed="0" />
l'attribut peut ne pas être défini, auquel cas il prendra une valeur par défaut. Exemple:
default
<xsd:attribute name="..." type="xsd:decimal" default="10" />
fixed et default ne peuvent pas être utilisés simultanément
d- Définition de groupes d'attributs

Les groupes d'attributs permettent de regrouper plusieurs déclarations d'attributs, la syntaxe
d'utilisation est :
<xs:attributeGroup name="N1" ...>
définition des attributs
</xs:attributeGroup>
Ensuite, ils peuvent être utilisés ensemble
<xs:attributeGroup ref="N1"/>
Exemple: groupe d'attributs
<xs:attributeGroup name="books"> <xs:element ...>

<xs:attribute name="pubisher" type="xs:string"> <xs:attributeGroup ref="books">
<xs:attribute name="isbn" type="xs:string"> </xs:element>
</xs:attributeGroup>
Brahim ER-RAHA
e- Annotations
Les annotations <xs:annotation> permettent d'ajouter des informations pour :

- l'utilisateur (humain) <xs:documentation>
- une application (machine) <xs:appInfo>
f- Définition de groupes modèles
Les groupes modèles permettent de définir des composants de schéma, la syntaxe

d'utilisation est :
<xs:group name="myGroup">
... composition
</xs:group>
et de les réutiliser comme suis :
<xs:complexType>
<xs:group ref="myGroup">
</xs:complexType>
Brahim ER-RAHA
Application
Un service d’envoi des mandats établit
mensuellement un rapport qui contient
les mandats envoyés. Chaque mandat
concerne un expéditeur et un
destinataire. L’expéditeur est défini par
son cin, son nom, son prénom et sa ville.
Le destinataire est défini également par
son cin, son nom, son prénom et sa ville.
Un exemple de fichier XML correspondant à ce problème est le suivant

<rapport>
<mandat num="7124536" date="2007-1-1" montant="1000" etat="reçu">
<expediteur cin="A123245" nom="slimani" prenom="youssef" ville="casa"/>
<destinataire cin="P98654" nom="hassouni" prenom="laila" ville="fes"/>
</mandat>
<mandat num="7124537" date="2007-1-1" montant="3200" etat="non reçu">
<expediteur cin="M123245" nom="alaoui" prenom="mohamed" ville="marrakech"
<destinataire cin="M92654" nom="alaoui" prenom="imane" ville="casa"/>
</mandat>
<expediteur cin="H123222" nom="qasmi" prenom="slim" ville="oujda"/>
<destinataire cin="B91154" nom="qasmi" prenom="hassan" ville="rabat"/>
</mandat>
</rapport>
Brahim ER-RAHA
Travail à faire
Faire une représentation graphique de l’arbre XML
Ecrire une DTD qui permet de déclarer la structure du document XML
Ecrire le schéma XML qui permet de déclarer la structure du document
XML
Créer le fichier XML valide respectant ce schéma.
Ecrire une feuille de style XSL qui permet de transformer le document
XML en document HTML suivant :
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
IV- Mise en page d'un document XML
L’utilisation d’une feuille de style est obligatoire en XML pour contrôler la mise en page
du document, en effet un document XML ne contient que des informations sur la
structure, aucune information relative à la mise en page n’apparaît dans le document. Il
est possible d’utiliser pour présenter un document XML les feuilles de style CSS ou les
feuilles de style XSL (eXtensible StylesheetLanguage). Ces dernières sont issues de
DSSSL (Document Style Semantics and Specification Language) la norme
internationale ISO 10179 de feuilles de style pour les documents SGML
A l'heure actuelle il existe trois solutions pour mettre en forme un document XML :
CSS (Cascading StyleSheet), la solution la plus utilisée actuellement, étant donné qu'il
s'agit d'un standard qui a déjà fait ses preuves avec HTML
XSL (eXtensible StyleSheet Language), un langage de feuilles de style extensible

développé spécialement pour XML. Toutefois, ce nouveau langage n'est
pas reconnu pour l'instant comme un standard officiel
XSLT (eXtensible StyleSheet Language Transformation). Il s'agit d'une

recommandation W3C du 16 novembre 1999, permettant de transformer
un document XML en document HTML accompagné de feuilles de style
Brahim ER-RAHA
IV-1 feuilles de style CSS.
Les cascading style sheets ont été initialement conçues pour le langage HTML. La
première version du standard, dite CSS niveau 1, a été publiée en 1996. En mai 1998,
le consortium W3 a publié une nouvelle version dite CSS niveau 2 qui introduit des
possibilités nouvelles par rapport a CSS-1.
CSS est un mécanisme puissant et relativement complexe et on a plusieurs manières

de procéder :
1- En incluant en-tête de page HTML les styles que l'on souhaite employer dans la
page en question.
2- En écrivant une feuille de style dans un fichier séparé. Et Cette seconde solution
est celle qui a été retenue pour l'utilisation avec XML
Cela s'écrit de la façon suivante :
<?xml version='1.0'?>
<?xml-stylesheet href="FeuilleDeStyle.css" type="text/css" ?>
Brahim ER-RAHA
1- Principe de base
Une feuille de style CSS se compose de règles de style qui s'appliquent à un ou
plusieurs éléments du document traité, voire à une partie seulement d'un élément
(première ligne ou première lettre). Chaque règle est composée d'un sélecteur qui
indique quels sont les éléments auxquels elle s'applique, et d'une ou plusieurs propriétés
qui décrivent les conditions de rendu physique de cet élément.
Syntaxiquement, une règle se présente ainsi :
Sélecteur {propriété:valeur; propriété:valeur}
Le nombre de couples "proriété-valeur" contenus dans la régle n'est pas limité. Une
règle très simple pour définir le formatage des éléments titre peut s'écrire :
Titre { font-weight:bold;
Font-size:14pt;
Font-family:Garamond;
Font-style: normal}
Des règles de style alternatives peuvent être définies pour un même élément en fonction
*de type de média visé. Par exemple, une feuille de style spécifiera que le contenu des
éléments titre doit être réalisé en police Garmond 10 points pour le type média Print, et
en police Arial 12 points pour le type de media Screen.
Toutes les feuilles de style CSS sont insensibles à la casse
Brahim ER-RAHA
2-Héritage
Pour chaque propriété définie pour un élément, il est possible d’indiquer si sa valeur
doit être héritée par les éléments descendants du premier. Soit par exemple un
document dont l’élément racine est article, la règle suivante :
Article {background : yellow}
Réalisera tous les éléments du document sur fond jaune, sauf ceux pour les quels
une règles plus spécifique serait indiquée dans la suite de la feuille de style.
Exemple, cette feuille de style :

Article { font-size: 10pt } titre { font-size: 120% }
et cet extrait d'un document :
<Article> <Titre>Un <EM>grand</EM> titre</Titre></Article>
Ici, la propriété 'font-size' de l'élément Titre aura une valeur calculée de '12pt' (120%
de la valeur de son parent). Et, comme la valeur de la propriété 'font-size' est héritée,
la valeur calculée pour l'élément EM sera aussi '12pt'.
Quelque fois, on utilise la valeur Inherit qui signifie que pour un élément donné, la
propriété de cet élément prend la même valeur calculée que pour celle de son parent.
La valeur héritée qui est normalement utilisée comme une valeur refuge, peut être
renforcée par une valeur 'inherit' explicite.
Brahim ER-RAHA
3- Importation des règles
La règle '@import', placée impérativement en tête de la feuille de style avant toute
règle de formatage, permet aux utilisateurs l'importation de règles de style à partir
d'une autre feuille de style. Le mot-clé '@import' doit être suivi de l'URI de la feuille de
style à intégrer.
Les lignes suivantes ont une signification équivalente et illustrent les deux syntaxes
(celle avec "url()" et celle avec une simple chaîne) :
@import "mystyle.css";
ou @import url("mystyle.css");
@import “http://foo.bar.org/somestyle.css”;
Les feuilles de styles importées et enveloppées dans une règle @media produiraient
les mêmes effets, avec ce média, que les feuilles de style suivantes,
@import url("fineprint.css") print;

@import url("bluish.css") screen, tv;
Si le type de média n'est pas précisé, l'import est inconditionnel. De même, si on

spécifie le type de média 'all'
Brahim ER-RAHA
4- La cascade
Toute règle peut se voir affecter un niveau de priorité parmi deux valeurs possibles.
Par défaut, elles ont toutes le niveau « normale ». Une règle dont on souhaite quelle
ait priorité sur une autre règle concurrente peut avoir le niveau important. Cela
s’indique de la façon suivante :
Sélecteur {propriété : valeur !important}
Lorsque plusieurs règles s’appliquent à un élément si l’une d’entre elle est spécifiée
avec l’indicateur !important elle a priorité sur une règle normale.
En fin, les règles importées par @import participent aussi à la cascade des
propriétés : à niveau d’importance égale, les règles locales définies dans la feuille
de style ont la priorité sur les règles importés.
Brahim ER-RAHA
Exemple :
<?xml-stylesheet type="text/css" href="css.css"?>
<ARTICLE> voila un exemple d’article
<HEADLINE>La rencontre de Frédéric le Grand et de Bach</HEADLINE>
<AUTHOR>Johann Nikolaus Forkel</AUTHOR>
<PARA>
Un soir, alors qu'il préparait sa
<INSTRUMENT>flûte</INSTRUMENT> et que ses
musiciens étaient réunis, un officier lui apporta
la liste des étrangers qui venaient d'arriver.
</PARA>
</ARTICLE>
Fichier css.css Fichier im.css

@import url("im.css"); article {
article { color: red !important;
color: #ff45ee; background: yellow ;
background: green !important; }
}
Brahim ER-RAHA
4- Types Médias
Une des fonctions primordiales des feuilles de style repose sur le fait de pouvoir
spécifier comment représenter un document (réalisation physique d’un document) pour
différents médias : un écran, une feuille de papier, un synthétiseur de parole, un appareil
(TV). Pour spécifier les règles propres à chaque type de media, trois méthodes
complémentaires sont possibles.
 La première consiste à réaliser une feuille de style différente par type de média visé.
 La seconde méthode consiste à déclarer les différentes règles dans une même
feuille en les regroupant dans des sections spécifiques
@media print { article { font-size: 10pt }

@media screen { article { font-size: 12pt } }
@media screen, print { article { line-height:
1.2 } }
 La troisième méthode consiste à réaliser une feuille de style différente

contenant les déclarations propres à chaque style, et à réaliser en outre une feuille
de style contenant les règles communes à l’ensemble des médias visés. Plus des
règles d’importation des feuilles spécifiques ; en indiquant à quels types de médias
elles correspondent.
Brahim ER-RAHA
@import “style-papier.css” print;
@import “style-papier.css” screen ;
@media screen, print { ici les régles valides pour les deux types }
Les types de médias reconnus sont :
All : convient pour tous les appareils ;
Aural : destiné aux synthétiseurs de parole.
Handheld : destiné aux appareils portatifs (typiquement ceux avec petits

écrans, monochromes et à bande passante limitée).
Print : destiné à un support paginé opaque et aux documents vus sur

écran en mode aperçu avant impression.
Projection : destiné aux présentations en projection, par exemple avec

des projecteurs ou des impressions pour des transparents
screen : destiné principalement aux moniteurs couleurs.
tv : destiné aux appareils du type télévision (avec ces caractéristiques :

basse résolution, couleur, défilement des pages limité, sonorisé).
Brahim ER-RAHA
5- Les commentaires
Dans les feuilles de style les commentaires sont de la même façons que dans les
langages de programmation C ou Java.
Syntaxe est /* Ecrire Commentaire */
Exemple :
@media print {titre { color:red;font-size: 10pt } /*la couleur de contenu est rouge ici*/
@media screen {titre{ color:green;font-size:12pt }/* la couleur de contenu est vert ici*/
Brahim ER-RAHA
6- Sélecteurs d’éléments : Les sélecteurs d’éléments disponibles en CSS sont :
Motif Signification Décrit au chapitre...
* Correspond à tout élément. Sélecteur universel

E Correspond à tout élément E (c.à.d., un élément de type E). Sélecteurs de type
EF Correspond à tout élément F qui est un descendant de l'élément E. Sélecteurs descendants
E>F Correspond à tout élément F aussi un enfant de l'élément E. Sélecteurs d'enfant
Correspond à un élément E aussi le premier enfant de son élément
E:first-child La pseudo-classe :first-chil
parent. d
E,F,G Groupement des éléments F, E et G Sélecteurs de type
Correspond à l'élément de type E qui emploie une langue c (la
E:lang(c) détermination de cette langue est spécifique au langage du La pseudo-classe :lang()
document).
Correspond à tout élément F immédiatement précédé par un élément
E+F Les sélecteurs adjacents
E.
Correspond à tout élément E avec l'attribut "foo" (quelles qu'en soient
E[foo] Sélecteurs d'attribut
les valeurs).
E[foo="warnin Correspond à tout élément E dont l'attribut "foo" a exactement la
Sélecteurs d'attribut
g"] valeur "warning".
Correspond à tout élément E dont l'attribut "foo" a pour valeur une
E[foo~="warni
liste de valeurs séparées par des blancs et dont une de celles-ci est Sélecteurs d'attribut
ng"]
"warning".
Correspond à tout élément E dont l'attribut "lang" a pour valeur une
E[lang|="en"] liste de valeurs séparées par des tirets, cette liste commençant (à Sélecteurs d'attribut
gauche) par "en".
Brahim ER-RAHA
Exemple :
-Pa > el [att= "foo "] {propriété : valeur} sélectionne tout élément el ayant
l’attribut att= "foo ", et fils d’un élément pa.
- pa [att="bar"]>* {propriété : valeur}sélectionne n'importe quel élément (*), fils

d'un élément pa, et doté de l'attribut att="bar".
7- Propriétés
7-1 Dimension
Lorsque on exprime la dimension (hauteur, largeur, épaisseur, distance) d'une
propriété, celle-ci est généralement indiquer à l'aide d'une unités absolues ou
relatives:
Les unités absolues sont : Les unités relatives sont :

- in : pouce, soit 2,54 cm - em : égale à la taille de la police courante.
- cm : centimètre - ex : égale à la hauteur de glyphe dans la police
- mm : millimètre courante
- pt : point typographique
- pc : pica (=12 points)
Brahim ER-RAHA
7-2 Couleur
Les propriétés CSS permettent aux auteurs la spécification d'une couleur d'avant-
plan et d'arrière-plan pour un élément.
 La couleur d'avant-plan : la propriété ‘color’
Cette propriété décrit la couleur d'avant-plan du contenu de texte d'un

élément. Voici plusieurs façons d'indiquer la couleur rouge :
EM { color: red } /* nom de couleur prédéfini */

EM { color: rgb(255,0,0) } /* couleurs en RGB allant de 0 à 255 */
EM { color: #FF0000 } /* couleurs en code héxadécimal */
 L'arrière-plan
Les propriétés d'arrière-plan :
'background-color', : mettre une couleur en arrière plan
'background-image' : ajouter une image en arrière plan
Brahim ER-RAHA
'background-repeat' : Quand on spécifie une image d'arrière-plan, cette propriété
indique si l'image est répétée (apposée) et la manière de la répétition. Les
significations des valeurs sont :
repeat : L'image se répète à la fois horizontalement et verticalement ;

repeat-x : L'image ne se répète qu'horizontalement ;
repeat-y : L'image ne se répète que verticalement ;
no-repeat : L'image ne se répète pas : un seul exemplaire de celle-ci est dessiné
'background-attachment' : Quand on spécifie une image d'arrière-plan, cette propriété

indique si l'image est fixe par rapport à la zone de visualisation (pour la valeur 'fixed'),
ou si celle-ci défile en même temps que le document (pour la valeur 'scroll')
'background-position' : Quand on spécifie une image d'arrière-plan, cette propriété

indique la position initiale de celle-ci. Les valeurs de cette propriété sont :
left, left center et center left bottom left et left bottom

top left et left top
Identique à '0% 0%' ; Identique à '0% 50%' ; Identique à '0% 100%' ;
top, top center et center top center et center center bottom, bottom center et center bottom
Identique à '50% 0%'; Identique à '50% 50%' ; Identique à '50% 100%'
right top et top right right, right center et center right
Identique à '100% 0%' ; Identique à '100% 50%' ;
Brahim ER-RAHA
7-3 Police
Les propriétés de police de CSS décrivent l'apparence souhaitée pour le texte dans le
document, on distingue :
 famille de polices : la propriété 'font-family' : cette propriété donne une liste, par
ordre de priorité, de noms de familles de polices, exemple :
BODY { font-family: Baskerville, "Heisi Mincho W3", Symbol, serif }
La police "Baskerville" va fournir les glyphes pour les caractères latins, la police "Heisi
Mincho W3", ceux pour les caractères japonais, la police "Symbol", ceux pour les
symboles mathématiques, et la famille de polices générique 'serif', ceux éventuels
d'autres caractères.
 style de police : pour déterminer le style de police, on utilise 3 propriétés :
font-style : La propriété 'font-style' sélectionne, parmi les polices d'une famille de

polices, celles avec un dessin normal, italique et oblique.
font-variant : qui prend deux valeurs normal ou small-caps (lettre en petit
majiscule)
font-weight : La propriété 'font-weight' spécifie la graisse de la police. Les
significations des valeurs sont : Normal et bold
taille de police : la propriété utilisé et font-size ces valeurs sont : xx-small | x-
small | small | medium | large | x-large | xx-large ou directemet
par une valeur réelle comme 12 pt.
Brahim ER-RAHA
7-4 Formatage de texte
word-spacing : espacement entre les mots (en pt)
letter- spacing:espacement entre les lettres (en pt)
text-decoration: {none, underline, overline, blink} blink : le text clignote
vertical-align: ajuster l'alignement vertical d'un élément
text-transform : {u uppercase, l lowercase}
text-align : { left, right, center, j justify}
text-indent : fixe l'indentation de la première ligne d'un bloc de texte
7-5 modèle de boite

La mise en boite de continue d'un élément se fait par la propriété Display, ces
valeurs sont : Block : boite de type bloc
Inline : boite en ligne
- width : la largeur de bloc
- height : la hauteur de bloc
-margin-top, margin-right, margin-left, margin-bottom : définissent les largeurs
des quatre marges.
-padding, padding-top,…, padding-bottom : déterminent les épaisseurs des
quatres cotés de la boite.
- Border-width, border-top-width,.. : définissent l'épaisseur de la bordure.
- Border-color, Border-top-color,… : définissent la couleur de la bordure
-Border-style, Border-top-style,... : none, hidden, dotted, deshed, solid, double,
ridge (effet de relief)
Brahim ER-RAHA
IV-1 feuilles de style XSL
eXtensible Stylesheet Language est un langage construit sur des principes

profondément différents de ceux de CSS et il offre par rapport à ce formalisme
des possibilités nouvelles très puissantes. XSL procède par reconstruction d'un
arbre à partir de l'arbre XML. Ce nouvel arbre peut avoir un ordre différent de
l'arbre source et de nouveaux éléments peuvent y être introduit. Des traitements
spécifiques peuvent même être mis en place au moment de sa construction. XSL
est donc un langage de feuille de style avec des possibilités de traitement assez
puissantes.
Le langage XSL se divise en deux parties :
1- XSLT (eXtensible Stylesheet Language Transformation) il permet de

transformer un document XML en un autre document XML (HTML, xHTML,
WML, SVG, SMIL,…), par défault, cette transformation produit un document
HTML bien formés.
2- XSL FO (Formatting Objects) c'est un langage de mise en page, il permet de

transformer un document XML en document non XML par exemple : PDF,
PostScript, RTF, Doc, text,…
Brahim ER-RAHA
1- Langage XSLT
1-1 Association d'une feuille XSL à un document XML
Une feuille de style XSL (enregistré dans un fichier dont l'extension est .xsl) peut
être liée à un document XML (de telle manière à ce que le document XML utilise la
feuille XSL) en insérant la balise suivante au début du document XML :

<?xml-stylesheet href="fichier.xsl" type="text/xsl"?>
Cette dernière instruction de traitement indique le type de la feuille de style et son

emplacement.
Voir le dossier TestXSLT…
Brahim ER-RAHA
1-2 Structure d’une feuille de style XSLT
XSLT est une application XML, une feuille de style XSL est donc un document
XML. La feuille de style contient donc une déclaration XML et tous ses
éléments sont placés dans l’élément racine <xsl:stylesheet>. D’autre part, les
éléments XSL sont préfixés par xsl : qui fait référence à deux types de
domaines de nom :
- http://www.w3.org/TR/WD-xsl
-http://www.w3.org/1999/XSL/Transform
Exemple :
<?xml version="1.0" encoding="ISO-8859-1">

<xsl:stylesheet>
<xsl:template ... >

</xsl:template >
</xsl:stylesheet>
L’élément racine contient principalement des balises xsl:template (modèle de

transformation) définissant les transformations à faire subir à certains éléments
du document XML
Brahim ER-RAHA
I-3 Modèle unique pour un document XML
Une feuille de styles XSL contient un ou plusieurs modèles (templates), chaque
modèle contient des informations sur l’affichage d’une branche des éléments du
document.
<?xml version="1.0"?> <?xml version= “1.0 “?>
<?xml-stylesheet type="text/xsl" <xsl:stylesheet xmlns:xsl="
href="biblio.xsl" ?> http://www.w3.org/1999/XSL/Transform
<bibliotheque> ">
<livre> <xsl:template match="/">
<titre>N ou M</titre> <H2>Bibliotheque</H2>
<auteur>Agatha Christie</auteur> <xsl:for-each
<ref>Policier-C-15</ref> select="bibliotheque/livre">
</livre> <P style="font-style:italic">
<livre> <xsl:value-of select="titre"/>
<titre>Le chien des Baskerville</titre> </P>
<auteur>Sir Arthur Conan Doyle</auteur> <P style="color:red">
<ref>Policier-D-3</ref> <xsl:value-of select="auteur"/>
</livre> </P>
<livre> <P style="color:blue">
<titre>Dune</titre> <xsl:value-of select="ref"/>
<auteur>Franck Heckbert</auteur> </P>
<ref>Fiction-H-1</ref> </xsl:for-each>
</livre> </xsl:template>
</bibliotheque> </xsl:stylesheet>
Brahim ER-RAHA
Le modèle est appliqué à la branche spécifiée par l’attribut match de l’élément
template.
La transformation d’un document XML par une feuille de style XSL s’effectue donc
par un modèle traitant un nœud donné. Chaque modèle est divisé en deux parties :
un nœud cible indiqué par l’attribut match et une action sur le nœud :
<xsl:template match="noed_cible">
action
</xsl:template>
L'attribut "match" de la balise <xsl:template> permet de définir (grâce à la notation

XPath) le ou les éléments du document XML sur lesquels s'applique la
transformation.
La notation Xpath permet de définir des patterns, c'est-à-dire des chaînes de

caractères permettant de repérer un nœud dans le document XML.
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
a- Langage Xpath
Le langage XPath est un standard du W3C pour décrire des "patterns"

(localisation de nœud) et extraire des valeurs de l'arbre du document XML. Il sert
en fait 2 autres "standards" XML :
XSLT : partie de XSL, ensemble de règles de transformation d'un document XML

vers un autre document.
XPointer : mécanisme de pointage pour les liens XLink de XML.
Un sélecteur de nœud (XPATH) est formée de trois parties :
<xsl:template match="//nom[position()=1]">
• un axe : il permet de se déplacer dans l'arbre du document

• un test : il permet de sélectionner un nœud
• un prédicat (entre crochets [xx]): il effectue une opération booléenne sur le
nœud sélectionné.
Considérons l'exemple suivant: (Fichier atome.xml)
Brahim ER-RAHA
Brahim ER-RAHA
<?xml version="1.0" encoding="iso-8859-1" ?>
<classification_atomique>
<famille type="gaz rare">
<atome>
<nom>hélium</nom>
<symbole>He</symbole>
<numero>2</numero>
<masse>4</masse>
</atome>
<atome>
<nom>néon</nom>
<symbole>Ne</symbole>
<numero>10</numero>
<masse>20</masse>
</atome>
<atome>
<nom>argon</nom>
<symbole>Ar</symbole>
<numero>18</numero>
<masse>40</masse>
</atome>
</famille>…..
< /classification_atomique> Brahim ER-RAHA
Axes
Les axes décrivent les directions des chemins dans une arborescence, ils ont deux
allure identique :
1- Syntaxe Xpath (notation étendue) : racine, parent, nœud courant, descendant,

les axes s'utilisent ainsi : axe :: test
Supposons que le nœud courant soit <famille type="gaz rare">
• ancestor:: tous les nœuds parent de la branche du nœud courant

• ancestor-or-self:: tous les nœuds parent de la branche du nœud courant et la
branche en cours
• child:: les nœuds fils
• descendant:: les descendant du nœud courant
• descendant-or-self:: les descendant du nœud courant et le nœud courant
• following:: tous les nœuds suivant le nœud courant dans le document
• following-sibling:: sélectionne les nœuds frères du nœud courant se trouvant
après ce nœud courant
• parent:: parent de noeud courant
• preceding:: tous les nœuds précédent le nœud courant dans le document.
• preceding-sibling:: sélectionne les nœuds frères du nœud courant se trouvant
avant ce nœud courant
• self:: le nœud courant
• following :: parent :: tous les nœuds suivants le nœud parent du nœud
Brahim ER-RAHA
Figure1 : Exemple de syntaxe Xpath sur un document
Brahim ER-RAHA
2- Syntaxe Simple
/ ou /classification_atomique sélectionne l'élément racine du document, donc

/ classification_atomique /famille sélectionne les éléments famille fils de l'élément
racine
./atome ou atome sélectionne les éléments atome fils du nœud courant.
atome/nom sélectionne les éléments nom fils d'un élément atome fils du nœud
courant
.. sélectionne l'élément père, donc <classification_atomique>
../famille sélectionne les éléments famille fils du père du nœud courant
//atome sélectionne les éléments atome descendant de l'élément racine
.//nom sélectionne les éléments nom descendant du nœud courant
* sélectionne tous les éléments fils du nœud courant
atome/* sélectionne tous les éléments fils d'un élément atome fils du nœud courant
@type sélectionne l'attribut type du nœud courant
/famille/@type sélectionne l'attribut type des éléments famille fils de l'élément
racine
@* sélectionne tous les attributs du nœud courant
./atome | .//nom union des 2 sélections
atome/node() sélectionne tous les nœuds (pas uniquement les nœuds éléments)
fils d'un élément atome fils du nœud courant
comment() tous les nœuds commentaire du nœud courant
Brahim ER-RAHA
Test
Il permet de déterminer dans un chemin Xpath le nom ou et le type de nœud

sélectionné. Exemple :
 nom d’élément: film

 nom d’attribut: @titre
 type de nœud:
– nœuds: node() (pas de sélection).
– éléments: *,
– attributs: @*,
– nœuds de type texte (PCDATA): texte():
 commentaires: comment()
Brahim ER-RAHA
Prédicat
Les prédicats sont utilisés dans les tests de XSLT. De plus, l'ensemble des nœuds
obtenus par un chemin XPtah peut être filtré à l'aide de prédicats entre crochets [].
./atome[3] sélectionne le 3ème élément atome fils du nœud courant

./atome[position()=3] sélectionne l'élément atome fils du nœud courant dont le
position est en 3ème place.
atome[last()] sélectionne le dernier élément atome fils du nœud courant
atome[numero!=4] sélectionne les éléments atome fils du nœud courant dont le
numéro est différent de 4
atome[numero >= 4] Remarquons qu'il faut utiliser < (respectivement >) à la
place de < (resp. >) dans les documents XML
following-sibling :: .[@type="non métal"] sélectionne les nœuds frère (suivant dans
le document) du nœud courant dont l'attribut type vaut "non métal"
atome[masse mod 2 =1] sélectionne les éléments atome fils du nœud courant dont la
masse est impair.
Brahim ER-RAHA
../famille[(@type="non métal") and (atome/masse > 34)] sélectionne les nœuds
famille fils du père du nœud courant dont l'attribut type vaut "non
métal" et dont l'un des fils atome a un fils masse dont le
contenu est > à 34.
../famille[@type="non métal"]/atome[masse > 34] sélectionne les nœuds atome,

ayant un fils masse dont le contenu est > à 34, et qui sont fils de
nœud
famille fils du nœud racine dont l'attribut type vaut "non métal".
/famille/atome[3] [masse > 34] sélectionne parmi les 3ème éléments atome des fils
famille du nœud racine ceux dont la masse est > à 34
/famille/atome[masse > 34] [3] sélectionne le 3ème élément parmi les atomes,
dont la masse est > à 34, des fils famille du nœud racine
/famille[count(atome[masse > 34]) != 0] sélectionne les nœuds famille du nœud

racine ayant au moins un fils atome de masse > à 34
/famille[not(contains(@type, 'gaz'))] sélectionne les nœuds famille du nœud racine

ayant un attribut type qui ne comporte pas la chaine 'gaz'
opérateurs : and, or, *, +, -, /, mod

fonctions numériques : number, sum, floor, ceiling, round
Brahim ER-RAHA
Correspondance entre syntaxe Xpath simple et étendu
Syntaxe Etendu Syntaxe Simple
/child::film/child::acteur /film/acteur
/child::cinéma/descendant::acteur /cinéma//acteur
/descendant::* //*
/descendant::film[@année=’2000’] //film[@année=’2000’]
Self .
Parent ..
Brahim ER-RAHA
1- AAA : Sélectionne l'élément racine AAA
I- Syntaxe Simple
<AAA>
<BBB/>
<CCC/> <xsl:template match="/">
<BBB/> <xsl:value-of select="AAA"/>
<BBB/> </xsl:template>
<DDD>
<BBB/>
</DDD>
<CCC/>
</AAA>
2- /AAA/CCC : Sélectionne tous les éléments CCC qui sont enfants de l'élément
racine AAA
<AAA>
<BBB/>
<CCC/>
<BBB/>
<BBB/>
<DDD>
<BBB/>
</DDD>
<CCC/>
</AAA>>
Brahim ER-RAHA
3- /AAA/DDD/BBB : Sélectionne tous les éléments BBB qui sont enfants de DDD, qui
sont enfants de l'élément racine AAA
<AAA>
<BBB/>
<CCC/>
<BBB/>
<BBB/>
<DDD>
<BBB/>
</DDD>
<CCC/>
</AAA>
4- //BBB : Sélectionne tous les éléments BBB

<AAA>
<BBB/>
<BBB/>
<CCC/>
<BBB/>
<BBB/>
</DDD>
<DDD>
</CCC>
<BBB/>
</AAA>
</DDD>
<CCC>
<DDD>
Brahim ER-RAHA
5- //DDD/BBB :Sélectionne tous les éléments BBB qui sont enfants de DDD
<AAA> <CCC>
<BBB/> <DDD>
<CCC/> <BBB/>
<BBB/> <BBB/>
<DDD> </DDD>
<BBB/> </CCC>
</DDD> </AAA>
6- /AAA/CCC/DDD/* : Sélectionne tous les éléments inclus dans les éléments

/AAA/CCC/DDD
Brahim ER-RAHA
6- /*/*/*/BBB
Sélectionne tous les éléments BBB qui ont trois ancêtres
Brahim ER-RAHA
7- /AAA/BBB[1] : Sélectionne le premier élément BBB, fils de l'élément racine AAA
<AAA>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
</AAA>
8- /AAA/BBB[last()] : Sélectionne le dernier élément :BBB, fils de l'élément racine

AAA
<AAA>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
</AAA>
9- //@id : Sélectionne tous les attributs id

<AAA>
<BBB id = "b1"/>
<BBB id = "b2"/>
<BBB name = "bbb"/>
<BBB/>
</AAA>
Brahim ER-RAHA
10- //BBB[@id] : Sélectionne tous les BBB qui ont un attribut id
<AAA>
<BBB id = "b1"/>
<BBB id = "b2"/>
<BBB name = "bbb"/>
<BBB/>
</AAA>
10- //BBB[@name] Sélectionne tous BBB qui ont un attribut name
<AAA>
<BBB id = "b1"/>
<BBB id = "b2"/>
<BBB name = "bbb"/>
<BBB/>
</AAA>
11- //BBB[@*] Sélectionne tous BBB qui ont un attribut
<AAA>
<BBB id = "b1"/> 12- //BBB[not(@*)] :Sélectionne
<BBB id = "b2"/> Tous les BBB qui n'ont pas d'attribut
<BBB name = "bbb"/> <AAA>
<BBB/> <BBB id = "b1"/>
</AAA> <BBB id = "b2"/>
<BBB name = "bbb"/>
<BBB/>
Brahim ER-RAHA </AAA>
13- //BBB[@id='b1'] :Sélectionne tous les éléments BBB ayant un attribut id dont la
valeur est b1
<AAA>
<BBB id = "b1"/>
<BBB name = " bbb "/>
<BBB name = "bbb"/>
</AAA>
14- //BBB[@name='bbb'] : Sélectionne tous les éléments BBB ayant un attribut name
dont la valeur est bbb
<AAA>
<BBB id = "b1"/>
<BBB name = "bbb"/>
</AAA>
15- //BBB[normalize-space(@name)='bbb'] :Sélectionne tous les éléments BBB

ayant un attribut name dont la valeur est bbb. Les espaces de début et de fin sont
supprimés avant la comparaison
<AAA>
<BBB id = "b1"/>
<BBB name = "bbb"/>
</AAA>
Brahim ER-RAHA
16- //*[count(BBB)=2]
Sélectionne les éléments ayant deux enfants BBB
<AAA>
<CCC>
<BBB/>
<BBB/>
<BBB/> 17- //*[count(*)=2] : Sélectionne les éléments ayant
</CCC> deux enfants
<DDD> <AAA>
<BBB/> <CCC>
<BBB/> <BBB/>
</DDD> <BBB/>
<EEE> <BBB/>
<CCC/> </CCC>
<DDD/> <DDD>
</EEE> <BBB/>
</AAA> <BBB/>
</DDD>
<EEE>
<CCC/>
<DDD/>
</EEE>
</AAA>
Brahim ER-RAHA
18- //*[count(*)=3] : Sélectionne les éléments ayant trois enfants
Brahim ER-RAHA
19- //*[name()='BBB']
La fonction name() retourne le nom de l'élément
Brahim ER-RAHA
21- //*[starts-with(name(),'B')] :
la fonction start-with retourne vrai si la chaîne du premier argument commence

par celle du deuxième
<AAA>
<BCC>
<BBB/> 22- //*[contains(name(),'C')]
<BBB/> <AAA>
<BBB/> <BCC>
</BCC> <BBB/>
<DDB> <BBB/>
<BBB/> <BBB/>
<BBB/> </BCC>
</DDB> <DDB>
<BEC> <BBB/>
<CCC/> <BBB/>
<DBD/> </DDB>
</BEC> <BEC>
</AAA> <CCC/>
<DBD/>
</BEC>
</AAA>
Brahim ER-RAHA
23- //*[string-length(name()) = 3]
<AAA>
<Q/>
<SSSS/>
<BB/>
<CCC/>
<DDDDDDDD/>
<EEEE/>
</AAA>
24- //*[string-length(name()) < 3]

<AAA>
<Q/>
<SSSS/> 26- //CCC | //BBB : Sélectionne tous les éléments
<BB/> CCC et BBB
<CCC/> <AAA>
<DDDDDDDD/> <BBB/>
<EEEE/> <CCC/>
</AAA> <DDD>
<CCC/>
</DDD>
<EEE/>
</AAA>
Brahim ER-RAHA
27- /AAA/EEE | //BBB : Sélectionne tous les éléments BBB et EEE qui sont
enfants de l'élément racine AAA
<AAA>
<BBB/>
<CCC/>
<DDD>
<CCC/>
</DDD>
<EEE/>
</AAA>
Plusieurs chemins peuvent être combinés avec le séparateur |
28- /AAA/EEE | //DDD/CCC | /AAA | //BBB : Le nombre de combinaisons n'est

pas restreint
<AAA>
<BBB/>
<CCC/>
<DDD>
<CCC/>
</DDD>
<EEE/>
</AAA>
Brahim ER-RAHA
II- Noms d'axes
1- /AAA : Équivalent à /child::AAA
<AAA>
<BBB/>
<CCC/>
</AAA>
2- /AAA/BBB : Equivalent à /child::AAA/child::BBB

<AAA>
<BBB/>
<CCC/>
</AAA>
3- /child::AAA/BBB
Les deux possibilités peuvent être combinées
<AAA>
<BBB/>
<CCC/>
</AAA>
4- /descendant::* Sélectionne tous les descendants de l'élément racine et donc tous les
éléments
Brahim ER-RAHA
6- /AAA/BBB/descendant::* :Sélectionne tous les descendants de /AAA/BBB
7- //CCC/descendant::* : Sélectionne tous les éléments qui ont CCC comme ancêtre
Brahim ER-RAHA
8- //CCC/descendant::DDD : Sélectionne les descendants de CCC dont au moins un
est un DDD
9- //DDD/parent::*
Brahim ER-RAHA
10- /AAA/BBB/DDD/CCC/EEE/ancestor::*: Sélectionne tous les éléments donnés dans
ce chemin absolu
11- //FFF/ancestor::* Sélectionne tous les ancêtres de l'élément FFF
Brahim ER-RAHA
12- /AAA/BBB/following-sibling::* //CCC/following-sibling::*
Brahim ER-RAHA
13- /AAA/XXX/preceding-sibling::*
Brahim ER-RAHA
12- //CCC/preceding-sibling::*
Brahim ER-RAHA
L'axe suivant (following) tous les nœuds du même document que le nœud contextuel
qui sont après le nœud contextuel dans l'ordre du document, à l'exclusion de tout
descendant, des attributs et des espaces de noms
13- /AAA/XXX/following::*
Brahim ER-RAHA
15- //ZZZ/following::*
Brahim ER-RAHA
L'axe cible précédente (preceding) contient tous les prédécesseurs du nœud contextuel; si
le nœud contextuel est un attribut ou un espace de noms, la cible précédente est vide
16- /AAA/XXX/preceding::*
Brahim ER-RAHA
17- //GGG/preceding::*
Brahim ER-RAHA
L'axe 'descendant-or-self' contient le nœud contextuel et ses descendants
18- /AAA/XXX/descendant-or-self::*
Brahim ER-RAHA
19- //CCC/descendant-or-self::*
Brahim ER-RAHA
L'axe ancestor-or-self contient le nœud contextuel et ses ancêtres; ainsi
l'axe ancestor-or-self contient toujours le nœud racine
20- /AAA/XXX/DDD/EEE/ancestor-or-self::*
Brahim ER-RAHA
21- //GGG/ancestor-or-self::*
Brahim ER-RAHA
22- //GGG/ancestor::*
23- //GGG/descendant::*
Brahim ER-RAHA
24- //GGG/following::*
25- //GGG/preceding::*
Brahim ER-RAHA
26- //GGG/self::*
27- //GGG/ancestor::* | //GGG/descendant::* | //GGG/following::* |

//GGG/preceding::* | //GGG/self::*
Brahim ER-RAHA
III- les opérateurs
L'opérateur div réalise une division à virgule flottante, l'opérateur mod retourne le
reste d'une division. La fonction floor() retourne le plus grand nombre (le plus près
de l'infini positif) qui n'est pas plus grand que l'argument et qui est un entier. La
fonction ceiling() retourne le plus petit nombre (le plus près de l'infini négatif) qui
n'est pas plus petit que l'argument et qui est un entier
1- //BBB[position() mod 2 = 0 ]
<AAA>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<CCC/>
<CCC/>
<CCC/>
</AAA>
Brahim ER-RAHA
2- //BBB[ position() = floor(last() div 2 + 0.5) or position() = ceiling(last() div 2 + 0.5) ]
<AAA>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<CCC/>
<CCC/>
<CCC/>
</AAA>
3- //CCC[ position() = floor(last() div 2 + 0.5) or position() = ceiling(last() div 2 + 0.5) ]
<AAA>
<BBB/><BBB/>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<BBB/>
<CCC/>
<CCC/>
<CCC/></AAA> Brahim ER-RAHA
<?xml version="1.0" encoding="iso-8859-1" ?>
<atome ligne="1" colone="8">
<nom>hélium</nom>
<symbole>He</symbole>
<numero>2</numero>
<masse>4</masse>
<type>gaz rare</type>
</atome>
<nom>néon</nom>
<symbole>Ne</symbole>
<numero>10</numero>
<masse>20</masse>
</atome>
<nom>argon</nom>
<symbole>Ar</symbole>
<numero>18</numero>
<masse>40</masse>
</atome>…..
Brahim ER-RAHA
b- Action possible par le langages XSLT
b-1 Extraction de contenue d'un élément
Pour insérer le contenu des éléments sélectionnés par la règle de gabarit (template)
dans le fichier résultat, il suffit d'utiliser l'élément value-of, qui permet d'insérer le
contenu de la balise sélectionnée par l’attribut obligatoir select.
Exemple :
<xsl:output method="html"/> Fichier Résultat

<xsl:template match="/classification_atomique"> <html>
<html> <body>
<body> <p style="color:red">H</p>
<P style="color:red"> </body>
<xsl:value-of select="atome/symbole"/> </html>
</p></body></html>
</xsl:template>
Brahim ER-RAHA
b-2 Réalisation des boucles
Grâce à l'élément <xsl:for-each>, il est possible de sélectionner un ensemble

des éléments enfants et de leur appliquer une règle de transformation.
Fichier XSL appliquée sur atomes.xml --> résultat

<xsl:template <html> <body>
match="/classification_atomique"> H<br>
<html> He<br>
<body> Li<br>
<xsl:for-each select="atome/symbole"> Be<br>
<xsl:value-of select="."/> B<br>
<br/> C<br>N<br>O<br>F<br>Ne<br>Na<br>Mg<br>A
</xsl:for-each> l<br>Si<br>Ar<br>
</body></html> </body></html>
</xsl:template>
L'instruction de boucle for-each sélectionne tous les nœuds correspondants au

pattern atome/symbole à partir du nœud courant classification_atomique, et
leur applique les transformations spécifiées.
Brahim ER-RAHA
b-3 Utilisation des structure de condition
XSLT propose deux instructions qui pemettent le traitement conditionnel dans un

modèle : xsl:if et xsl:choose . L'instruction xsl:if sert à exprimer la condition simple si-
alors ; L'instruction xsl:choose permet quant à elle un choix parmi plusieurs
possibilités
Traitement conditionnel par xsl:if
la syntaxe d'utilisation est :
<xsl:if test = boolean-expression>

traitement….
</xsl:if>
L'élément xsl:if a un attribut test qui spécifie une expression. Le contenu est un
modèle.
Brahim ER-RAHA
Fichier XSL Résultat HTML
<?xml version="1.0" encoding="UTF-8"?> <html>
<xsl:stylesheet version="1.0" xmlns:xsl= <body>
http://www.w3.org/1999/XSL/Transform> <table>
<xsl:template match="/classification_atomique"> <tr>
<html><body> <th>symbole</th>
<table border="1"> <th>numero</th>
<tr> </tr>
<th>symbole</th> <tr>
<th>numero</th> <td>hélium</td>
</tr>
<xsl:for-each select="atome"> <td>2</td>
<xsl:if test="type='gaz rare'"> </tr>
<tr> <tr>
<td> <td>néon</td>
<xsl:value-of select="nom"/> <td>10</td>
</td> </tr>
<td> <tr>
<xsl:value-of select="numero"/> <td>argon</td>
</td> <td>18</td>
</tr> </tr>
</xsl:if> </table>
</xsl:for-each> </body>
</table></body></html> </html>
</xsl:template>
</xsl:stylesheet>
Brahim ER-RAHA
 Traitement conditionnel par xsl:choose
<xsl:choose> <xsl:when test = boolean- <xsl:otherwise>

(xsl:when+, expression> 
xsl:otherwise?)>  </xsl:otherwise>
</xsl:choose> </xsl:when>
L'élément xsl:choose permet de faire un choix parmi plusieurs alternatives. Il

consiste en une séquence d'éléments xsl:when suivis par un élément
xsl:otherwise optionnel. Chacun des éléments xsl:when possède un attribut test
unique qui spécifie une expression. Le contenu des éléments xsl:when et
xsl:otherwise est un modèle de traitement
Brahim ER-RAHA
Fichier XSL Résultat HTML
<xsl:template match="/classification_atomique"> <html> <body> <table>
<html><body><table border="1">
<tr> <tr>
<th>type</th> <th>type</th>
<th>symbole</th> <th>symbole</th>
<th>numero</th> <th>numero</th>
</tr> </tr>
<xsl:for-each select="atome"> <tr>
<tr> <td> <td></td>
<xsl:choose> <td>hydrogène</t
<xsl:when test="contains(type,'métal')"> d> <td>1</td>
métal </xsl:when> </tr>
<xsl:when test="contains(type,'gaz')"> <tr>
gaz </xsl:when> <td>gaz</td>
<xsl:otherwise>Rien</xsl:otherwise> <td>hélium</td>
</xsl:choose> <td>2</td>
</td> </tr>
<td> <tr>
<xsl:value-of select="nom"/> <td>métal</td>
</td> <td>lithium</td>
<td>
<xsl:value-of select="numero"/> <td>3</td>
</td> </tr> </tr>
</xsl:for-each> </table></body></html> <tr>....
</xsl:template> </xsl:stylesheet>
Brahim ER-RAHA
Exemple
Brahim ER-RAHA
DTD
XML
Brahim ER-RAHA
XSL
HTML
Brahim ER-RAHA
Exemple 1
Un opérateur Télécom fournit périodiquement, à l’opérateur de réglementation des
télécoms ANRT un fichier XML qui contient les clients de cet opérateur. Chaque
client possède plusieurs abonnements et chaque abonnement reçoit plusieurs
factures. Un exemple de fichier XML correspondant à ce problème est le suivant :

<operateur>
<client code="1" nom="hassouni">
<abonnement num="123" type="GSM" dateAb="2006-1-11">
<facture numFact="432" dateFact="2006-2-11"
montant="350.44"
reglee="oui"/>
<facture numFact="5362" dateFact="2006-4-13" montant="800.54"
reglee="non"/>
</abonnement>
<abonnement num="2345" type="FIXE" dateAb="2006-12-1">
</abonnement>
</client>
<client code="2" nom="abbassi">
<abonnement num="7543" dateAb="2006-12-1" type="GSM">
<facture numFact="7658" dateFact="2007-2-12"
montant="350.44"
reglee="oui"/>
<facture numFact="7846" dateFact="2007-3-12" montant="770"
reglee="non"/>
</abonnement>
</client>
</operateur>
Travail demandé
1. Faire une représentation graphique de l’arbre XML.
2. Ecrire une DTD qui permet de valider ce document XML
3. Créer le fichier XML
4. Ecrire une feuille de style XSL qui permet de transformer le document
XML en une page HTML qui permet d’afficher pour chaque client la
liste de ses abonnements en affichant le montant total des factures de
chaque abonnement
Corrigé : DTD operateur
+client
<!ELEMENT operateur (client+) > @code
<!ELEMENT client (abonnement+) > @nom
<!ELEMENT abonnement (facture+) >
<!ELEMENT facture EMPTY > +abonnement
<!ATTLIST client
code NMTOKEN @num
#REQUIRED
nom CDATA #REQUIRED> @type
<!ATTLIST
numabonnement
NMTOKEN #REQUIRED @dateAb
type (GSM|FIXE) 'FIXE'
dateAb CDATA +facture
#REQUIRED>
<!ATTLIST
numFactfacture
NMTOKEN #REQUIRED @numFact
dateFact CDATA #REQUIRED
@dateFact
montant CDATA #REQUIRED
reglee (oui|non) 'non'> @montant
@reglee
<html>
<head></head>
<body>
<xsl:for-each select="operateur/client">
<h3>
Nom Client : <xsl:value-of
select="@nom"/>
</h3>
<tr>
<th>Num</th><th>Type</th><th>Date</th><th>Total
Factures</th>
</tr>
<xsl:for-each select="abonnement">
<tr>
<td><xsl:value-of select="@num"/></td>
<td><xsl:value-of select="@type"/></td>
<td><xsl:value-of select="@dateAb"/></td>
<td><xsl:value-of
select="sum(facture/@montant)"/></td>
</tr>
</xsl:for-each>
</table>
</xsl:for-each>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Application
Un exemple de fichier XML correspondant à ce problème est le suivant :
<rapport>
<expediteur cin="A123245" nom="slimani" prenom="youssef"
ville="casa"/>
<destinataire cin="P98654" nom="hassouni" prenom="laila" ville="fes"/>
</mandat>
<mandat num="7124537" date="2007-1-1" montant="3200" etat="non reçu">
<expediteur cin="M123245" nom="alaoui" prenom="mohamed"
ville="marrakech"/>
<destinataire cin="M92654" nom="alaoui" prenom="imane" ville="casa"/>
</mandat>
<expediteur cin="H123222" nom="qasmi" prenom="slim" ville="oujda"/>
<destinataire cin="B91154" nom="qasmi" prenom="hassan" ville="rabat"/>
</mandat>
</rapport>
Travail à faire
Faire une représentation graphique de l’arbre XML
Ecrire une DTD qui permet de déclarer la structure du document XML
Ecrire le schéma XML qui permet de déclarer la structure du document
XML
Créer le fichier XML valide respectant ce schéma.
Ecrire une feuille de style XSL qui permet de transformer le document
XML en document HTML suivant :
b-4 Triage des données
Le triage des données est spécifié en ajoutant des éléments xsl:sort comme fils d'un
élément xsl:apply-templates ou d'un élément xsl:for-each. Le premier fils xsl:sort
spécifie la clé primaire de tri, le deuxième fils xsl:sort spécifie la clé de tri secondaire
et ainsi de suite.
xsl:sort possède un attribut select dont la valeur est une expression représentant la
nœud courante sur le quelle on effectue le tri et un autre attribut order indique si les
chaînes de caractères devraient être triées dans un ordre ascendant ou
descendant; par défaut, l'ordre est ascending
Brahim ER-RAHA
b-5 Création de l'arbre résultat
 Créer des éléments avec xsl:element

L'élément xsl:element permet la création d'un élément ayant un nom déterminé. Le
nom étendu de l'élément à créer est spécifié par l'attribut obligatoire name. Le
contenu de l'élément xsl:element est le modèle des attributs et enfants de l'élément
créé.
La syntaxe d'utilisation est :
<xsl:element name = { qname } use-attribute-sets = qnames>

</xsl:element>
Créer des attributs avec xsl:attribute
L'élément xsl:attribute peut être utilisé pour ajouter des attributs aux éléments
résultats qui sont créés par un xsl:element. Le nom étendu de l'attribut à créer est
spécifié par l'attribut obligatoire name. le contenu de l'élément xsl:attribute est un
modèle de la valeur de l'attribut créé.
La syntaxe d'utilisation est:
<xsl:attribute name = { qname }>

</xsl:attribute>
Brahim ER-RAHA
 Créer de texte dans l'arbre résultat
l'élément xsl:text permet de créer des nœuds textuels dans le document
résultat, la syntaxe d'utilisation est :
<xsl:text >

</xsl:text>
 Créer des commentaires
L'élément commentaire xsl:comment sert à créer un nœud commentaire dans
l'arbre résultant.
<xsl:comment>
Contenu de commentaire
</xsl:comment>
 Créer des instructions de traitement

L'élément xsl:processing-instruction sert à créer un nœud instruction de
traitement. L'élément xsl:processing-instruction possède un attribut obligatoire name qui
spécifie le nom du nœud instruction de traitement
La syntaxe d'utilisation est:
<xsl:processing-instruction name = { nom de l'instruction }>
</xsl:processing-instruction>
Brahim ER-RAHA
Exemple
Document XSL Document Résultat
<xsl:processing-instruction name="xml- <?xml-stylesheet

stylesheet">href="book.css" type="text/css“ href="book.css"type="text/css"?>
</xsl:processing-instruction>
Brahim ER-RAHA
Exemple :Xsl:element :
Fichier XSL Arbre générée

Fichier XML
<source> <xsl:stylesheet version = '1.0' <H1>Header1</H1>
<text xmlns:xsl='http://www.w3.org/1999/ <H3>Header3</H3>
size="H1">Header1</text> XSL/Transform'> <b>Bold text</b>
<text <xsl:output omit-xml-declaration="yes" <sub>Subscript</sub>
size="H3">Header3</text> method="html"/> <sup>Superscript</sup>
<text size="b">Bold <xsl:template match="/">
text</text> <xsl:for-each select="//text">
<text <xsl:element name="{@size}">
size="sub">Subscript</text> <xsl:value-of select="."/>
<text </xsl:element>
size="sup">Superscript</text </xsl:for-each>
> </source> </xsl:template></xsl:stylesheet>
Brahim ER-RAHA
Xsl:attribute
Fichier XSL Arbre généré
Fichier XML
<source> <xsl:stylesheet version = '1.0' <TABLE>
<color>blue</color> xmlns:xsl='http://www.w3.org/1999/ <TR>
<color>navy</color> XSL/Transform'> <TD style="color:blue">blue</TD>
<color>green</color> <xsl:template match="color"> </TR>
<TABLE> </TABLE>
<color>lime</color> <TR> <TABLE>
<color>red</color> <TD> <TR>
</source> <xsl:attribute name="style"> <TD style="color:navy">navy</TD>
<xsl:text>color:</xsl:text> </TR>
<xsl:value-of select="."/> </TABLE>
</xsl:attribute> <TABLE>
<xsl:value-of select="."/> <TR>
</TD> <TD style="color:green">green</TD>
</TR> </TR>
</TABLE> </TABLE>
</xsl:template></xsl:stylesheet> <TABLE>
<TR>
<TD style="color:lime">lime</TD>
</TR>
</TABLE>
<TABLE>
<TR>
<TD style="color:red">red</TD>
</TR>
</TABLE>
Brahim ER-RAHA
Xsl: attribute-set : Avec l'élément xsl:attribute-set on ne peut pas utiliser l'élément value of
Fichier XSL Arbre généré

Fichier XML
<source> <xsl:stylesheet version = '1.0' <h1 align="center"
<h1>GREETING</h1> xmlns:xsl='http://www.w3.org/1999/XSL/Transform'> style="color:red">GREETING
<p>Hello, world!</p> <xsl:template match="/"> </h1>
</source> <xsl:apply-templates select="/source/*"/> <p align="left"
</xsl:template> style="color:blue">Hello,
<xsl:template match="h1"> world!</p>
<xsl:copy use-attribute-sets="H1">
<xsl:value-of select="."/>
</xsl:copy>
</xsl:template>
<xsl:template match="p">
<xsl:copy use-attribute-sets="P ">
</xsl:copy>
</xsl:template>
<xsl:attribute-set name="H1">
<xsl:attribute name="align">center</xsl:attribute>
<xsl:attribute name="style">color:red</xsl:attribute>
</xsl:attribute-set>
<xsl:attribute-set name="P">
<xsl:attribute name="align">left</xsl:attribute>
<xsl:attribute name="style">color:blue</xsl:attribute>
</xsl:stylesheet>
Brahim ER-RAHA
 copier des nœuds vers le document résultat : XSl:Copy et XSl:Copy-of :
L'élément copy permet de copier uniquement le nœud courant (sans contenus, ni attribues).
L'élément copy-of permet de copier le nœud courant, sont contenu, ces attribues et ces enfants
Fichier XML Fichier XSL Arbre générée

<source> <xsl:stylesheet version = '1.0' <DIV>
<p id="a12"> Compare xmlns:xsl='http://www.w3.org/1999/XSL/Transform'> <B>
<B>these <xsl:template match="p"> copy-of : </B>
constructs</B>. <DIV> <p id="a12">
</p> <B> Compare <B>these
</source> <xsl:text>copy-of : </xsl:text> constructs</B>.
</B> </p>
<xsl:copy-of select="."/> </DIV>
</DIV> <DIV>
<DIV> <B>copy : </B>
<B> <p/>
<xsl:text>copy : </xsl:text> </DIV>
</B> <DIV>
<xsl:copy/> <B>value-of : </B>
</DIV> Compare these constructs.
<DIV> </DIV>
<B>
<xsl:text>value-of : </xsl:text>
</B>
</DIV>
</xsl:template>
</xsl:stylesheet>
Brahim ER-RAHA
 Création des listes
number Cet élément permet d'insérer un nombre formaté pouvant servir de

compteur. L'utilisation de cet élément est de la forme :
<xsl:number level="single"|"multiple" count="noeud" value="expression"

format="chaine" />
avec:
level : indique quels niveaux doivent être sélectionnés pour le comptage.
count : indique quels nœuds doivent être comptés dans les niveaux sélectionnés ;
dans le cas où cet attribut n'est pas défini, les nœuds comptés sont ceux
ayant le même type que celui du nœud courant.
Value : indique l'expression correspondant à la valeur du compteur ; si cet attribut

n'est pas défini, le nombre inséré correspond à la position du nœud
(position()).
Format : spécifie le format de l'affichage du nombre ; cela peut être un chiffre, un

caractère (a-z, A-Z) et comprendre un caractère de séparation tel que le
point (.), le trait d'union (-) ou autre. Les formats possibles sont "1", "01",
"a", "A", "i", "I"
Brahim ER-RAHA
Exemple 1
Fichier XML Fichier XSL Arbre

généré
<source> <xsl:stylesheet version = '1.0' 1. one
<n>one</n> xmlns:xsl='http://www.w3.org/1999/XSL/Transform'> 2. two
<n>two</n> <xsl:template match="/"> 3. three
<n>three</n> <TABLE> 4. four
<n>four</n> <xsl:for-each select="//n">
</source> <TR>
<TD>
<xsl:number value="position()" format="1. "/>
</TD>
</TR>
</xsl:for-each>
</TABLE>
</xsl:template>
</xsl:stylesheet>
Brahim ER-RAHA
Exemple 2:
Fichier XML Fichier XSL Arbre généré

<source> <xsl:stylesheet version = '1.0'
<chapter>First xmlns:xsl='http://www.w3.org/19
Chapter</chapter> 99/XSL/Transform'> Number text
<chapter>Second Chapter <xsl:template match="/">
1 First Chapter
<chapter>Subchapter <TABLE BORDER="1">
1</chapter> <TR> Second
2
<chapter>Subchapter <TH>Number</TH> Chapter
2</chapter> <TH>text</TH> 2.1 Subchapter 1
</chapter> </TR>
2.2 Subchapter 2
<chapter>Third Chapter <xsl:for-each select="//chapter">
<chapter>Subchapter Third
3
A</chapter> <TR> Chapter
<chapter>Subchapter B <TD> 3.1 Subchapter A
<chapter>sub a</chapter> <xsl:number level="multiple"/>
3.2 Subchapter B
<chapter>sub b</chapter> </TD> 3.2.1 sub a
<TD>
3.2.2 sub b
</chapter> <xsl:value-of select="./text()"/>
<chapter>Subchapter </TD> 3.3 Subchapter C
C</chapter> </TR>
</chapter> </xsl:for-each>
</source> </TABLE>
</xsl:template>
</xsl:stylesheet>
Brahim ER-RAHA
Brahim ER-RAHA
<xsl:stylesheet xmlns:xsl=http://www.w3.org/1999/XSL/Transform
version="2.0">
<xsl:output method="xml" indent="yes"/>
<xsl:template match="/source">
<xsl:copy>
<xsl:attribute name="salaireMoyenne" select="format-
number(sum(employe/salaire) div count(employe), '0000.00 DH')"/>
<xsl:for-each select="//employe">
<xsl:sort order="descending" select="./nom"/>
<xsl:element name="{name(.)}" use-attribute-sets="att"/>
</xsl:for-each>
</xsl:copy>
</xsl:template>
<xsl:attribute-set name="att">
<xsl:attribute name="code" select="code"/>
<xsl:attribute name="nom" select="nom"/>
<xsl:attribute name="salaire" select="salaire"/>
</xsl:stylesheet>
Brahim ER-RAHA
 Utilisation des variables
L'élément <xsl:variable> sert à créer les variables dans XSLT. Il possède les
attributs suivants :
name : cet attribut est obligatoire. Il spécifie le nom de la variable.

select : expression XPath qui spécifie la valeur de la variable.
Par exemple :
<xsl:variable name="nombre_livres" select="255"/>
<xsl:variable name="Auteur" select="'Victor Hugo'"/>
<xsl:variable name="nombre_pages" select="livre/tome/@page"/>
On notera la présence des guillemets imbriqués quand il s'agit d'affecter une chaîne
de caractères à une variable. La valeur de la variable peut aussi être donnée de
cette façon :
<xsl:variable name="Auteur">Victor Hugo </xsl:variable>
La portée d'une variable est limitée aux éléments-frères et à leurs descendants. Par
conséquent, si une variable est déclarée dans une boucle xsl:for-each ou un
élément xsl:choose ou xsl:if, on ne peut s'en servir en-dehors de cet élément.
Une variable est appelée en étant précédée du caractère $ :
<xsl:value-of select="$nombre_pages" />.

Brahim ER-RAHA
Eléments de XSLT
<xsl:variable>
◦ L'élément <xsl:variable> sert à créer les variables dans

XSLT. Il possède les attributs suivants :
name : cet attribut est obligatoire. Il spécifie le nom de la variable.
select : expression XPath qui spécifie la valeur de la variable.
Par exemple :
<xsl:variable name="nombre_livres" select="255" />
<xsl:variable name="auteur" select="'Victor Hugo'" />

<xsl:variable name="nb" select="livre/tome/@page" />
On notera la présence des guillemets imbriqués quand il s'agit d'affecter
une chaîne de caractères à une variable.
La portée d'une variable est limitée aux éléments-frères et à leurs
descendants. Par conséquent, si une variable est déclarée dans une boucle
xsl:for-each ou un élément xsl:choose ou xsl:if, on ne peut s'en servir en-
dehors de cet élément.
Une variable est appelée en étant précédée du caractère $ :
<xsl:value-of select="$nb" />.
caractères, et pour faciliter la mise à jour de la feuille de style.
◦ On peut utiliser une variable pour éviter la frappe répétitive d'une chaîne de
<source> <xsl:stylesheet version = '1.0' First Chapter : Chapter A
<chapter>Chapter xmlns:xsl='http://www.w3.org/1999/XSL/Transform'> Chapter : Chapter B
A</chapter> <xsl:variable name="text">Chapter</xsl:variable> Chapter : Chapter C
<chapter>Chapter <xsl:template match="/"> Last Chapter : Chapter D
B</chapter> <TABLE>
<chapter>Chapter <xsl:for-each select="//chapter">
C</chapter> <TR>
<chapter>Chapter <TD>
D</chapter> </source> <xsl:choose>
<xsl:when test="position() = 1">
<xsl:variable name="text">First
chapter</xsl:variable>
</xsl:when>
<xsl:when test="position()=last()">
<xsl:variable name="text">Last
chapter</xsl:variable>
</xsl:when>
<xsl:otherwise>
<xsl:variable name="text">
<xsl:value-of select="$text"/>
</xsl:variable>
</xsl:otherwise>
</xsl:choose>
<xsl:value-of select="$text"/>
<xsl:text> : </xsl:text>
</TD>
</TR>
</xsl:for-each>
</TABLE>
</xsl:template>
</xsl:stylesheet>
Brahim ER-RAHA
I-4 Utilisation de plusieurs modèles dans le document XSL
Un document XSL peut contenir plusieurs modèles. il est possible d’appeler un
modèle a partir d'un autre en utilisant l'élément xsl:apply-templates la syntaxe
d'utilisation est
< xsl:apply-templates select="Xpath"/>
Document XML Document XSL Document Résultat

<source> <xsl:stylesheet version = '1.0' <html>
<AAA id="a1" pos="start"> xmlns:xsl='http://www.w3.org/1999/XSL/Transform'> <h3
<BBB id="b1"/> <xsl:template match="/"> style="color:blue">CCC
<BBB id="b2"/> <html> (id=c1)</h3>
</AAA> <xsl:apply-templates select="//CCC"/> <h2 style="color:red">CCC
<AAA id="a2"> </html> (id=c2)</h2>
<BBB id="b3"/> </xsl:template> <h3
<BBB id="b4"/> <xsl:template match="CCC" priority="1"> style="color:blue">CCC
<CCC id="c1"> <h3 style="color:blue"> (id=c3)</h3>
<CCC id="c2"/> <xsl:value-of select="name()"/> </html>
</CCC> <xsl:text> (id=</xsl:text>
<BBB id="b5"> <xsl:value-of select="@id"/>
<CCC id="c3"/> <xsl:text>)</xsl:text>
</BBB> </h3>
</AAA> </xsl:template>
</source> <xsl:template match="CCC/CCC" priority="2">
<h2 style="color:red">
<xsl:value-of select="name()"/>
<xsl:text> (id=</xsl:text>
<xsl:value-of select="@id"/>
<xsl:text>)</xsl:text>
</h2> </xsl:template></xsl:stylesheet>
Brahim ER-RAHA
Eléments de XSLT
<xsl:call-template>
◦ L'élément <xsl:template> peut être appelé
indépendamment d'une sélection d'un
nœud.
◦ Pour cela, il faut renseigner l'attribut name,
et l'appeler à l'aide de l'élément
<xsl:call-template>.
◦ Par exemple
<xsl:template name="separateur">
<hr />
<img src="ligne.gif" alt="séparation“height="2" width="150“ />
<hr />
</xsl:template>
Il suffit alors de l'appeler avec

<xsl:call-template name="separateur"/>
Eléments de XSLT
<xsl:param> et <xsl:with-param>
◦ Un paramètre est créé avec l'élément <xsl:param>, et passé à
un modèle avec l'élément <xsl:with-param>.
◦ Les deux ont deux attributs :
name, obligatoire, qui donne un nom au paramètre ;
select, une expression XPath facultative permettant de donner une valeur par défaut
au paramètre.
◦ Par exemple, on peut imaginer un template permettant d'évaluer le résultat d'une
expression polynômiale :
◦
<xsl:template name="polynome">
<xsl:param name="x"></xsl:param>
<xsl:value-of select="2*$x*$x+(-5)*$x+2" />
</xsl:template>
◦
Ce template peut être appelé comme suit:
◦
<xsl:call-template name="polynome">
<xsl:with-param name="x" select="3.4"></xsl:with-param>
</xsl:call-template>
◦
permet d'afficher le résultat de 2*3.4^2-5*3.4+2.
Fichier XML Fichier XSL Arbre
généré
<source> <xsl:template match="/"> 1 (odd)
<number>1</number> <TABLE> 3 (odd)
<number>3</number> <xsl:for-each select="//number"> 4 (even)
<number>4</number> <TR> 17 (odd)
<number>17</number <TH> 8 (even)
> <xsl:choose>
<number>8</number> <xsl:when test="text() mod 2">
</source> <xsl:apply-templates select=".">
<xsl:with-param name="type">odd</xsl:with-param>
</xsl:apply-templates>
</xsl:when>
<xsl:otherwise>
<xsl:apply-templates select="."/>
</xsl:otherwise>
</xsl:choose>
</TH>
</TR>
</xsl:for-each>
</TABLE> param et with param
</xsl:template>
<xsl:template match="number">
<xsl:param name="type">even</xsl:param>
<xsl:text> (</xsl:text>
<xsl:value-of select="$type"/>
<xsl:text>)</xsl:text>
</xsl:template>
Brahim ER-RAHA
<xsl:stylesheet xmlns:xsl=http://www.w3.org/1999/XSL/Transform version="2.0">
<xsl:output method="xml" indent="yes"/>
<xsl:template match="/source">
<xsl:copy>
<xsl:attribute name="salaireMoyenne" select="format-
number(sum(employe/salaire) div count(employe), '0000.00 DH')"/>
<xsl:for-each select="//employe">
<xsl:sort order="descending" select="./nom"/>
<xsl:variable name="code" select="code"/> Solution

<xsl:variable name="salaire" select="salaire"/> exercice
« employe.x
<xsl:copy> ml »
<xsl:apply-templates select=".">
<xsl:with-param name="code" select="$code"/>
<xsl:with-param name="salaire" select="$salaire"/>
</xsl:apply-templates>
</xsl:copy>
</xsl:for-each>
</xsl:copy>
</xsl:template>
Brahim ER-RAHA
<xsl:template match="employe">
<xsl:param name="code"/>
<xsl:param name="salaire"/>
<xsl:attribute name="{name(code)}" select="$code"/>

<xsl:attribute name="{name(nom)}">
<xsl:value-of select="./nom/text()"/>
</xsl:attribute>
<xsl:attribute name="salaire" select="$salaire"/>
</xsl:template>
</xsl:stylesheet>
Brahim ER-RAHA
<source> <xsl:variable name="var1" select="//AAA/CCC/text()"/> //AAA/CCC/DDD : D1
<AAA> <xsl:variable name="var2">//AAA/CCC/text()</xsl:variable //AAA/CCC/text() : C2C3
<BBB> >
<CCC>C1</CCC> <xsl:template match="/">
</BBB> <xsl:call-template name="function">
<CCC>C2</CCC> <xsl:with-param name="path1“
<CCC>C3</CCC> select="//AAA/CCC/DDD"/>
</AAA> <xsl:with-param name="path2">//AAA/CCC/DDD</
<AAA> xsl:with-param>
<CCC> </xsl:call-template>
<DDD>D1</DDD> </xsl:template>
<DDD>D2</DDD>
</CCC> <xsl:template name="function">
</AAA> <xsl:param name="path1"/>
</source> <xsl:param name="path2"/>
<P>
<xsl:value-of select="$path2"/>
<xsl:value-of select="$path1"/>
</P>
<P>
<xsl:value-of select="$var2"/>
<xsl:for-each select="$var1">
<xsl:text/>
</xsl:for-each>
</P>
</xsl:template>
Brahim ER-RAHA
Document XML Document XSL Document Résultat
<source> <xsl:stylesheet version = '1.0' <html>
<AAA id="a1" xmlns:xsl='http://www.w3.org/1999/XSL/Transf <div
pos="start"> orm'> style="color:red">CCC
<BBB id="b1"/> <xsl:template match="/"> id=c1</div>
<BBB id="b2"/> <xsl:apply-templates select="//CCC" mode <div
</AAA> ="red"/> style="color:red">CCC
<AAA id="a2"> <xsl:apply-templates select="//CCC" mode id=c2</div>
<BBB id="b3"/> ="yellow"/> <div
<BBB id="b4"/> </xsl:template> style="color:red">CCC
<CCC id="c1"> <xsl:template match="CCC" mode="red"> id=c3</div>
<CCC id="c2"/> <div style="color:red"> </html>
</CCC> <xsl:value-of select="name()"/>
<BBB id="b5"> <xsl:text> id=</xsl:text>
<CCC id="c3"/> <xsl:value-of select="@id"/>
</BBB> </div>
</AAA> </xsl:template>
</source> <xsl:template match="CCC">
<div style="color:purple">
<xsl:value-of select="name()"/>
<xsl:text> id=</xsl:text>
<xsl:value-of select="@id"/>
</div>
</xsl:template>
</xsl:stylesheet>
Brahim ER-RAHA
1-5 Importation des feuilles de styles
Une feuille de styles XSLT peut importer une autre feuille XSLT en utilisant l'élément
xsl:import. L'élément xsl:import possède un attribut href dont la valeur est une adresse
URI identifiant la feuille de styles à importer. La syntaxe d'utilisation est :
<xsl:import href = uri-reference />
L'élément xsl:import n'est permis que comme un élément de haut niveau. Les éléments
xsl:import doivent précéder tous les autres éléments fils de l'élément xsl:stylesheet.
Document XML Document XSL (Doc1.xsl) Document Résultat
<source> <xsl:stylesheet version = '1.0' <h3

<AAA>red</AAA> xmlns:xsl='http://www.w3.org/1999/XSL/Transform'> style="color:red">red
<BBB>blue</BBB> <xsl:template match="AAA"> </h3>
<CCC>purple</CCC> <h3 style="color:{.}"> blue
</source> <xsl:value-of select="."/> purple
</h3>
</xsl:template></xsl:stylesheet>
Brahim ER-RAHA
<AAA>red</AAA> xmlns:xsl='http://www.w3.org/1999/XSL/Transform'> style="color:red">re
<BBB>blue</BBB> <xsl:import href="doc1.xsl"/> d</h3>
<CCC>purple</CCC> <xsl:template match="BBB"> <h2
</source> <h2 style="color:{.}"> style="color:blue">b
<xsl:value-of select="."/> lue</h2>
</h2> purple
</xsl:template></xsl:stylesheet>

<AAA>red</AAA> xmlns:xsl='http://www.w3.org/1999/XSL/Transform'> style="color:red">re
<BBB>blue</BBB> <xsl:include href="Doc2.xsl"/> d</h3>
<CCC>purple</CCC> <xsl:template match="CCC"> <h2
</source> <h1 style="color:{.}"> style="color:blue">b
<xsl:value-of select="."/> lue</h2>
</h1> <h1
</xsl:template></xsl:stylesheet> style="color:purple"
>purple</h1>
Brahim ER-RAHA
Brahim ER-RAHA
1. Donner le résultat d’application de fichier point.xlst
2. Modifiez points.xslt pour qu'il affiche deux nouvelles lignes:
• l’une contenant la moyenne des totaux hebdomadaires de points
(donc la moyenne de {7, 30, 4}).
• l’autre contenant la moyenne des points journaliers (donc la moyenne
de {1, 3, 2, 1, 2, 8, 20, 1, 3}).
Attention! Faites-le sans utiliser foreach ni sum ni avg! On peut tout faire
comme l'exemple, à coup de template. (il vous faudra quand même un
petit div quelquepart).
3. Ajoutez l'affichage du nombre maximal de points obtenu en un jour.

Et toujours sans foreach ni sum, etc.
Brahim ER-RAHA
Exercice
Considérons le fichier xml suivant : Etoiles.xml
1- présenter les données sous la forme d'une liste donnant pour chaque planète
son nom, sa distance par rapport au Soleil, sa masse et son diamètre. Sol Voir
2- Ajouter à la distance, la masse et le diamètre les unités employées en

récupérant la valeur de l'attribut unit pour chacun de ces éléments. Sol voir
3- Effectuer pour chaque planète un test sur l'élément satellite. S'il existe, afficher le
nombre de satellites. Sol voir
4- Ne plus afficher les informations sur la Terre. Sol voir
5- Classer les planètes sauf la Terre par ordre croissant de leur masse ; Sol voir
6- faire un test sur le type de planète et afficher suivant le cas : Sol voir
 "Planète de type tellurique" si la planète est de type tellurique ;
 "Planète pleine de gaz!" si la planète est de type gazeuse ;
 "Autre type de planète" dans les cas restants.
Brahim ER-RAHA
II- Language XSL-FO
XSL/FO est un langage qui permet de formater l’affichage et/ou l’impression d’un
document XML. Il s’agit de l’équivalent (en plus puissant) des stylesheet CSS.
Principe de formatage d'un document XML
Brahim ER-RAHA
XSL-FO : le formatage
 Permet les mises en
pages sophistiquées
 Objets de mise en forme
applicables aux résultats
avec XSLT
 Distinction
 Formatage des pages
 Formatage des objets à
l'intérieur des pages
• Statiques
• Dynamiques
Principes
 Peut s'appliquer aux résultats des feuilles
XSLT
Les processeurs XSL-FO
 Apache Group : FOP
 Formating Object Processor
 Génère du PDF http://www.apache.org
 JFOR (Open Source)
 Génère du RTF http://www.jfor.org
 Antenna House
 XSL Formatter http://www.antennahouse.com
 RenderX
 Génère du PDF http://www.renderx.com
 Altova
 StyleVision http://www.altova.com/products_xsl.html
 XML Mind FO Converter
 Génère du RTF http://www.xmlmind.com/foconverter
 Autres
 Arbortext, Adobe, Scriptura, XMLPDF, APOC, XSL-FO to TeX
2-1 Principes de base XSL/FO
La feuille de style XSL-FO est un document XML. Elle contient donc une déclaration
XML et tous ses éléments sont placés dans l’élément racine <fo:root>. D’autre part, les
éléments XSL-FO sont préfixés par fo : qui fait référence à l'espace de nom :
xmlns:fo="http://www.w3.org/1999/XSL/Format"
Un document FO est formé donc d'un élément racine fo:root qui comprend 2 parties
bien distinctes:
 Une description des structures en page (fo:layout-master-set)

 Une description du contenu (fo:page-sequence)
a-1 Modèle de page unique
L'élément fo:simple-page-master permet de spécifier les régions d'une simple page,

les attributs de cet élément sont :
- master-name="..." sert de référence pour la page.
- page-width="14.8cm"
- page-height="21cm"
- margin-top="1cm" tous ces attributs définissent le format de la page
- margin-bottom="1.5cm"
- margin-left="2cm"
- margin-right="2cm"
Brahim ER-RAHA
Cet élément contient aussi un autre élément fo:region-body possédant les attributs
suivant :
- region-name="..." sert de référence pour la region.

- margin-top="1cm"
- margin-bottom="1.5cm" tous ces attribus définissent le format de la page
- margin-left="2cm"
- margin-right="2cm“
Le modèle de page comprend en plus de la région centrale, quatre régions

périphériques :
- region-before,
- region-after,
- region-strat,
- region-end
Les dimensions des régions périphériques sont déterminées par :
-l'attribut extend qui détermine sa "largeur" (dans le sens orthogonal au coté

considéré)
- sa "longueur" est déterminée par la région centrale
Brahim ER-RAHA
Exemple :

<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" font-size="16pt">
<fo:layout-master-set>
<fo:simple-page-master
margin-right="15mm" margin-left="15mm"
margin-bottom="15mm" margin-top="15mm"
page-width="210mm" page-height="297mm"
master-name="book">
<fo:region-body region-name="R1"
margin-bottom="5mm" margin-top="5mm"/>
<fo:region-before extent="2mm" region-name="entete"/>
<fo:region-after extent="1.5cm" region-name="pied"/>
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence master-reference="book">
<fo:title>Hello world example</fo:title>
<fo:flow flow-name=“R1">
<fo:block> Salut XSLFO!</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
Brahim ER-RAHA
les marges de la page et de la région centrale
Brahim ER-RAHA
a-2 Structure des modèles de pages
Dans cette paragraphe, nous allons voir comment on peur définir un modèle
représentant une séquence de modèles de page.
Pour définir des pages multiples, il faut déclarer un élément fo:page-sequence-

master contenant un élément fo:repeatable-page-master-reference faisant
référence à l'objet fo:simple-page-master
Exemple :
<fo:simple-page-master master-name="single-page" ...>
...
</fo:simple-page-master>
<fo:page-sequence-master master-name="many-pages">
<fo:repeatable-page-master-reference master-reference="single-page"/>
</fo:page-sequence-master>
<fo:page-sequence master-reference="many-pages">
...
</fo:page-sequence>
Brahim ER-RAHA
Pour définir des pages alternées (par ex. impaire, paire), il faut définir plusieurs
modèles de page simples puis définir un modèle de pages alternatives de type
fo:repeatable-page-master-alternatives contenant des conditionnelles de type
fo:conditional-page-master-reference avec les propriétés suivantes :
odd-or-even : odd ou even, permet d’associer un modèle différent selon si la page

est impaire ou paire
page-position : first, last, rest ou any, permet d’associer un modèle différent selon
la position de la page
blank-or-not-blank : blank ou not-blank, permet d’associer un modèle différent
selon si la page est vide ou non.
master- reference : détermine le type de page simple a utilisée
La syntaxe totale d'utilisation d'un modèle de séquence de page

est :
<fo:page-sequence-master master-name="nomsequence">
( simple-page-master-reference |
repeatable-page-master-reference |
repeatable-page-master-alternatives )+
L'attribut master-name sert comme référence de la séquence de
page définit.
Brahim ER-RAHA
<fo:repeatable-page-master-reference master-refrence="aaa">
<fo:simple-page-master-reference master-name="aaa">
<fo:simple-page-master-reference master-name="bbb">
<fo:simple-page-master-reference master-name="ccc">
<fo:repeatable-page-master-alternatives>
<fo:conditional-page-master-reference page-position="first“ master-reference="aaa"/>
<fo:conditional-page-master-reference odd-or-even="odd“ master-reference="bbb"/>
<fo:conditional-page-master-reference odd-or-even=“even" master-reference="ccc"/>
</fo:repeatable-page-master-alternatives>
Brahim ER-RAHA
<fo:simple-page-master master-name="first-page" ...> ...

<fo:simple-page-master master-name="odd-page" ...> ...
<fo:simple-page-master master-name="even-page" ...> ...
<fo:page-sequence-master master-name="chapter-pages">
<fo:repeatable-page-master-alternatives>
<fo:conditional-page-master-reference page-position="first“
master-reference="first-page"/>
<fo:conditional-page-master-reference odd-or-even="odd“
master-reference="odd-page"/>
<fo:conditional-page-master-reference odd-or-even="even“
master-reference="even-page"/>
</fo:repeatable-page-master-alternatives>
Brahim ER-RAHA
b- génération de continu des pages
Le contenu d'un document se trouve dans un élément fo:page-sequence avec

l'attribut master-reference="..." pour référencer le modèle de page la Syntaxe est :
<fo:page-sequence master-reference="nom modele de page">
(static-content*, flow)
</fo:page-sequence>
Le contenu (paragraphes, d’images, tableaux,…) est placé dans des flux

représentés par deux éléments fo:flow et un élément fo:static-content
 fo:flow (destiné à la région centrale)

 fo:static-content (pour les en-têtes, etc): pour Les informations qui se répètent sur
chaque page
Ces deux éléments ont un attribut obligatoire flow-name qui prendre l'une des
valeurs suivantes:
- xsl-region-after
- xsl-region-before
- xsl-region-body
- xsl-region-start
- xsl-region-end
L'élément fo flow est un élément obligatoire et unique, la valeur xsl-region-body est
obligatoire pour son attribut flow-name
Brahim ER-RAHA
Génération de continu d'une page
Brahim ER-RAHA
b-1 Les Blocs
La mise en page est décrite à l'aide de boîtes (block). Chaque boîte est formée
d'un contenu, d'un espace interne (padding), d'une bordure (border) et d'un espace
externe (space). Les quatre côtés sont nommés relativement au sens d'écriture
(before, after, start, end)
Représentation d'une boite (bloc)

Brahim ER-RAHA
Les boîtes de blocs sont des éléments récursifs de type fo:block et correspondent
à des sections, titres, paragraphes, listes, tableaux, etc. (cf <div> en HTML).
Les principaux attributs sont (ce sont les même attribut vu dans CSS):
 text-align avec comme valeurs start (ou left), end (ou right), center, justify, ...
 line-height
 text-indent, start-indent
 space-before, space-after, padding-...
 border, border-...
 color, background-color, background-image
 font-family, font-size, font-style, font-weight, font-strech, font-variant, text-
decoration, ...
 letter-spacing, word-spacing, ...
Pour modifier les propriétés graphiques d’une portion de texte au sein d’un élément de
niveau bloc on utilise l'élémént fo:inline, la syntaxe est :
<fo:inline> contenu </fo:inline>
Exemple :
<fo:block font-size="18pt" color="black" font-family="sans-serif">
Il était <fo:inline font-style="italic" color="Red"> une fois </fo:inline>
le langage XML
</fo:block>
Le résultat est : Il était une fois le langage XML
Brahim ER-RAHA
b-2 Les tableaux
La structure globale de tableaux est similaire au modèle de tableau de HTML. Tous
les éléments nécessaires sont représentés sur le schéma suivant :
Avec:
• fo:table-and-caption
• fo:table-caption: La caption d’une table
• fo:table: la table proprement dite. Elle contient header et footer à option et un
body.
• fo:table-column: permet de spécifier notamment la longueur d’une colonne
(éléments vides)
• fo:table-header: Ligne entête, contient des lignes ou cellules (facultatifs)
• fo:table-footer: Ligne "footer", contient des lignes ou cellules (facultatifs)
• fo:table-body: contient des lignes ou cellules
• fo:table-row: les cellules qui contiennent des fo:blocks (le contenus)
On commence par définir les colonnes et leurs largeurs. Puis on définit le continu
(corps) du tableau
Brahim ER-RAHA
Exemple :
<fo:table-column column-number="1" column-width="8cm" />

<fo:table-column column-number="2" column-width="8cm" />
<fo:table-column column-number=“3" column-width="8cm" />
<fo:table-body>
<fo:table-row>
<fo:table-cell column-number="1" border-style="solid">
<fo:block text-align="left">08 – 09</fo:block>
</fo:table-cell>
<fo:table-cell column-number="2" number-columns-spanned="2" border- tyle="solid">
<fo:block text-align="center">plenary session</fo:block>
</fo:table-cell>
</fo:table-row> Session1 Session2
<fo:table-row> 08-09 plenary session
<fo:table-cell border-style ="solid">
09-10 Paper1-session1 tutorial
<fo:block text-align="left">09 – 10</fo:block>
</fo:table-cell> 10-11 Paper2-session2
11-12 Paper3-session3
<fo:table-cell border-style="solid">
<fo:block text-align="center">Paper 1 - session 1</fo:block>
</fo:table-cell >
<fo:table-cell border-style="solid" number-rows-spanned="2">
<fo:block text-align="center">tutorial</fo:block>
</fo:table-cell>
</fo:table-row>
</fo:table-body>
Brahim ER-RAHA
b-3 Les listes
L'organigramme des éléments de liste dans un fichier XSL-FO est :
Avec :
 fo:list-block : contient la liste et contient quelques définitions pour la géométrie
fo:list-item : enfants de fo:list-block, c.a.d. des items qui contiennent un label et un
body (voir ci-dessous)
fo:list-item-label : contient le contenu du label (typiquement un fo:block avec un
nombre, un caractère dingbat, etc.)
fo:list-item-body : contient le corps d’un item, un ou plusieurs fo:block
L'indentation d’une liste est contrôlée via les attributs start-indent et end-indent
associés aux étiquettes et aux corps de liste :
 Comme alternative, on peut utiliser les attributs provisional-label-separation et
provisional-distance-between-starts
 La fonction label-end() retourne la position de la marge droite du label et body-start()
retourne la position de la marge gauche du corps
Brahim ER-RAHA
Différents attributs des éléments liste
Brahim ER-RAHA
Exemple :
<fo:list-block provisional-label-separation="1cm" provisional-distance-between-tarts="1cm">

<fo:list-item>
<fo:list-item-label end-indent="label-end()" start-indent="0.5cm">
<fo:block>1.</fo:block>
</fo:list-item-label>
<fo:list-item-body end-indent="1cm" start-indent="body-start()">
<fo:block> Vive XML ! </fo:block>
</fo:list-item-body>
</fo:list-item>
<fo:list-item>
<fo:list-item-label end-indent="label-end()" start-indent="0.5cm">
<fo:block>•</fo:block>
</fo:list-item-label>
<fo:list-item-body end-indent="1cm" start-indent="body-start()">
<fo:block>
Gloire à XSL ! Gloire à XSL ! Gloire à XSL !
Gloire à XSL ! Gloire à XSL ! Gloire à XSL !
</fo:block>
</fo:list-item-body>
</fo:list-item>
</fo:list-block>
le résultat est :
1. Vive XML !
2. Gloire à XSL ! Gloire à XSL ! Gloire à XSL ! Gloire à XSL ! Gloire à XSL ! Gloire à XSL !
Brahim ER-RAHA
b-4 Les graphes
Deux éléments peuvent être utilisés pour inclure des éléments de type graphique :
fo:external-graphic pour insérer un graphique dont le format de description n’est

pas XML (par exemple, une image JPEG)
fo:instream-foreign-object pour insérer un graphique dont le format de
description est exprimé dans la syntaxe XML (par
exemple, un graphique SVG ou une formule MathML)
Les attributs de ces éléments sont :
 L’attribut src qui a une valeur de type URI qui désigne l’emplacement du graphique
à insérer
 L’attribut content-type qui permet de spécifier le type de graphique
Soit comme un type MIME : <fo:external-graphic contenttype= «content-
type:image/gif» src=«resultat.gif»>
Soit en termes d’espace de nom <fo:instream-foreign-object
xmlns:svg=«http://www.w3.org/2000/svg» content-
type=«namespace-prefix:svg»>
Les attributs Width, et Height définissent la largeur et la hauteur du graphe.
Un fo:external-graphic est de type inline (il est placé sur une ligne de texte). Pour le
traiter comme un block il suffit de l’imbriquer dans un élément de type fo:block
Brahim ER-RAHA
Exemple
<fo:block>
<fo:external-graphic src="url(D:\Bureau\webshots.bmp)" width="20pt"
height="20pt"/>
</fo:block
<fo:block> Exemple de graphe SVG

<fo:instream-foreign-object>
<svg xmlns=http://www.w3.org/2000/svg width="1.5cm" height="1cm">
<polygon style="fill:#FFCCCC" points="0,31 18,0 36,31"/>
</svg>
</fo:instream-foreign-object>
</fo:block>
Brahim ER-RAHA
b-5 Les Liens (Hyperliens)
Deux types de liens peuvent être créer avec l'élément principal fo:basic-link :
 Liens internes à travers l’attribut internal-destination en lui affectant l’ID du

block à atteindre
 Liens externes a travers l’attribut external-destination en lui affectant l’URL
Exemple
<fo:page-sequence master-reference="simple">
<fo:flow flow-name="xsl-region-body">
<fo:block id="A">
<fo:basic-link internal-destination="B"> Cliquer-ici pour aller vers
le bloc avec id="B"
</fo:basic-link>
</fo:block>
<fo:block id="B">Block with id="B".
<fo:basic-link internal-destination="A"> Cliquer-ici pour aller vers
le bloc avec id= " A"
</fo:basic-link>
</fo:block>
</fo:flow>
</fo:page-sequence>
Brahim ER-RAHA
b-6 Numérotation des pages
L’élément fo:page-number utilisé dans un contenu statique permet de placer le numéro de page.
La présentation des numéros de page est régie via des attributs associés aux éléments de type
fo:page-sequence, ces attributs sont :
 initial-page-number : force-page-count
 format, letter-value
 grouping-separator
 grouping-size
Exemple :
<fo:page-sequence master-reference="alterning">
<fo:static-content flow-name="evenFooter">
<fo:block font-family="Helvetica" font-size="10pt" text-align="left">
<fo:page-number/>
</fo:block>
</fo:static-content>
<fo:static-content flow-name="oddFooter">
<fo:block font-family="Helvetica" font-size="10pt" text-align="right">
<fo:page-number/>
</fo:block>
</fo:static-content>
<fo:flow flow-name="xsl-region-body">
<xsl:apply-templates select=".//Recipe"/>
<fo:block break-before="page">
<xsl:apply-templates select=".//Recipe/Title"/>
</fo:block>
</fo:flow>
</fo:page-sequence>
Brahim ER-RAHA
XQUERY
XQuery, langage non XML, permet de

traiter des ressources XML (fichier ou
SGBD-XML) pour obtenir des structures
XML.
C'est un langage fonctionnel typé et
basé sur la manipulation de liste de
noeuds XML.
Brahim ER-RAHA
Brahim ER-RAHA
La place de XQuery dans le monde XML
Brahim ER-RAHA
Comment interroger des documents XML?
Solutions :
 SQL: il faut stocker XML dans une BD relationnel
 XPath : extraction de fragments d’arbres
 XQuery : vrai langage de requêtes pour XML
 XSLT : extraction + transformation (règles)
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
LE BLOC DE BASE EN SQL
Brahim ER-RAHA
LE BLOC DE BASE EN XQUERY
Brahim ER-RAHA
DTD Exemple: bib.dtd
<!ELEMENT bib (book*) >

<!ELEMENT book ((author)+, title,publisher, price) >
<!ATTLIST book year CDATA #REQUIRED>
<!ELEMENT title (#PCDATA)>
<!ELEMENT author (la, fi )>
<!ELEMENT la (#PCDATA )>
<!ELEMENT fi (#PCDATA )>
<!ELEMENT publisher (#PCDATA)>
<!ELEMENT price (#PCDATA)>
Brahim ER-RAHA
Brahim ER-RAHA
EXEMPLE 1 : ÉNONCÉ
Livres (titre et année) publiés par Addison-Wesley avant 1995, triés par
ordre alphabétique de titre ?
<bib>
{
for $b in doc("bib.xml")//book
where $b/publisher = "Addison-Wesley" and
$b/@year < 1995
order by $b/title
return
<book year="{$b/@year}">
{$b/title}
</book>
}
</bib>
Brahim ER-RAHA
EXEMPLE 1 : RÉPONSE
Brahim ER-RAHA
Brahim ER-RAHA
STRUCTURE D’UNE REQUÊTE XQUERY
Une requête XQuery est formée :
 d’un prologue composé d’une suite de déclarations,
 d’un corps composé d’une expression dont la valeur est le résultat

de la requête.
 La valeur d’une requête est la valeur de l’expression qui constitue

son corps, évaluée dans le contexte défini par le prologue.
Brahim ER-RAHA
Brahim ER-RAHA
EXEMPLE 2
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
VALEURS/SÉQUENCES
 Pas de distinction entre un item et une séquence de

longueur 1 : 47 = (47)
 Une séquence peut contenir des valeurs hétérogènes :

(1, ‘‘toto’’, <toto/>)
 Pas de séquences imbriqués :

(1, (2, 6), "toto", <toto/>) =(1, 2, 6, ‘‘toto’’, <toto/>)
 Une séquence peut être vide : ()
 Les séquences sont triées : (1,2)#(2,1).
Brahim ER-RAHA
Valeurs construites : true(), date(‘‘2002-10-23’
Noeud XML
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
OPÉRATIONS ARITHMÉTIQUES
exp1 + exp2
exp1 - exp2
exp1 * exp2
exp1 div exp2
Attention ! l’opérateur de division est div et non / réservé

aux expressions de chemin.
Brahim ER-RAHA
Brahim ER-RAHA
Opérations sur les séquences
L’expression 1 + 5, 4 – 2, 7 * 3
a pour valeur la séquence
6, 2, 10
 L’expression ((9, 1), 5, (8, 2))

9, 1, 5, 8, 2
 L’expression 2 to 5
2, 3, 4, 5
L’expression 5 to 2
a pour valeur la séquence vide
Brahim ER-RAHA
COMPARAISON DE VALEURS
COMPARAISON DE VALEURS ATOMIQUES
exp1 eq exp2
exp1 ne exp2
exp1 lt exp2
exp1 le exp2
exp1 gt exp2
exp1 ge exp2
La valeur de exp1 op exp2 est obtenue en comparant les

valeurs atomisées de exp1 et exp2.
Brahim ER-RAHA
 L’expression 5 gt 7
a la valeur false.
 L’expression <a>8</a> gt <b>9</b>

a la valeur false,
 L’expression nom = "Dupont"

a la valeur : true si le noeud contexte a un noeud fils
<nom>Dupont</nom> false sinon.
Brahim ER-RAHA
Requête:
document("bib.xml")//book/author[la eq "Scholl"]
Résultat:
<author><la>Scholl</la><fi>M.</fi></author>
Requête:
document("bib.xml")//book[author/la eq "Scholl"]
Résultat:
ERROR
L’expression author/la dans le prédicat ne retourne pas une

valeur atomique mais une séquence de valeurs.
Brahim ER-RAHA
COMPARAISONS GÉNÉRALES
exp1 = exp2
exp1 != exp2
exp1 < exp2
exp1 <= exp2
exp1 > exp2
exp1 >= exp2
Les comparateurs généraux ont une sémantique existentielle :

exp1 op exp2 a la valeur :
true s’il existe un item i1 dans la valeur de exp1 et un item i2

dans la valeur de exp2 tel que
i1 op i2 est vrai,
false sinon.
Brahim ER-RAHA
COMPARAISONS GÉNÉRALES
 L’expression
(1, 2) = (7, 2, 9, 12) a la valeur true
L’expression
5 > (2, 9, 3) a la valeur true
Si l’item contextuel est un noeud élément dont la

valeur est
<auteur>Dupont</auteur><auteur>Durand</auteur>
alors l’expression
auteur = "Dupont"
a la valeur true
Brahim ER-RAHA
Comparaisons de noeuds
exp1 is exp2
exp1 << exp2
exp1 >> exp2
 Les deux opérandes doivent avoir pour valeur, soit une
séquence vide, soit un noeud.
 Si l’un des opérandes a pour valeur la séquence vide, la
valeur de la comparaison est false.
 Si la valeur de exp1 est le noeud n1 et la valeur de exp2 est
le noeud n2 :
 exp1 is exp2 a la valeur true, si les noeuds n1 et n2 sont

les mêmes (même identifiant), sinon elle a la valeur false.
 exp1 << exp2 a la valeur true, si le noeud n1 précède le
nœud n2 dans l’ordre du document, sinon elle a la valeur
false.
 exp1 >> exp2 a la valeur true, si le noeud n1 suit le
nœud n2 dans l’ordre du document, sinon elle a la valeur
false. Brahim ER-RAHA
L’expression /bib/book[@id="1"] << /bib/book[@id="2"]

a la valeur true
Brahim ER-RAHA
Comparaison de l’identité de deux noeuds : s1 is s2
s1 est identique à s2
Requête:
document("bib.xml")//book[author[2] is author[last()]]
Résultat:
<book title="Comprendre XSLT">
<author><la>Amann</la><fi>B.</fi></author>
<author><la>Rigaux</la><fi>P.</fi></author>
<publisher>O’Reilly</publisher>
<price>28.95</price>
</book>
Brahim ER-RAHA
Comparaisons par la position
Comparaison de la position de deux noeuds : s1<<s2 (s1>>s2)

s1 apparaît avant (après) s2 dans le document.
Requête:
<livre>
{ document("bib.xml")//book[author[la="Abiteboul"] <<
author[la="Suciu"]]/@title }
</livre>
Résultat:
<livre title="Data on the Web"/>
Brahim ER-RAHA
Opérations sur les séquences de noeuds
exp1 union exp2

exp1 | exp2
exp1 intersect exp2
Dans la séquence résultante :
 les doubles (noeuds de même identifiant) sont éliminés,

 les noeuds sont rangés dans l’ordre du document si le
mode ordered n’est pas spécifié.
Brahim ER-RAHA
L’expression doc("bib.xml")//(author | editor)
a pour valeur
la séquence des noeuds de type author et editor du document

bib.xml.
Brahim ER-RAHA
Opérations sur les séquences de noeuds
Brahim ER-RAHA
CONCATÉNATION DE SÉQUENCES
Requête:
<livre>
(:Le prix suivi des auteurs:) 'commentaire
{ document("bib.xml")//book[1]/(price,author) }
</livre>
Résultat:
<livre>
Le prix suivi des auteurs:
<price>28.95</price>
</livre>
On a changé l’ordre des noeuds (#union)
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Expressions de chemins
Requête:
document("bib.xml")//author
Résultat:
<author><la>Amann</la><fi>B.</fi></author>,
<author><la>Rigaux</la><fi>P.</fi></author>,
<author><la>Rigaux</la><fi>P.</fi></author>,
<author><la>Scholl</la><fi>M.</fi></author>,
<author><la>Voisard</la><fi>A.</fi></author>,
<author><la>Abiteboul</la><fi>S.</fi></author>,
<author><la>Buneman</la><fi>P.</fi></author>,
<author><la>Suciu</la><fi>D.</fi></author>
Brahim ER-RAHA
Expressions de chemins
Chaque étape est une expression XQuery (XPath 2.0) :
doc(“bib.xml”)/bib/book/author
doc(“bib.xml”)/bib//book[1]/publisher
doc(“bib.xml”)//book/(author, publisher) :résultat ?
doc(“bib.xml”)/(descendant::author,descendant::publisher) :
résultat ?
doc(“bib.xml”)//book/(@title union publisher)
doc(“bib.xml”)//book[position() lt last()]
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Le nom et le contenu sont calculés:
element { expr-nom } { expr-contenu }

attribute { expr-nom } { expr-contenu }
Requête:
element { document("bib.xml")//book[1]/name(*[1]) } {
attribute { document("bib.xml")//book[1]/name(*[3]) } {
document("bib.xml")//book[1]/*[3]
}
}
Résultat:
<title publisher="Addison-wesley"/>
Brahim ER-RAHA
Brahim ER-RAHA
Affectation de variables: for et let (FLWOR)
La clause for $var in exp affecte la variable $var successivement avec
chaque item dans la séquence retournée par exp.
La clause let $var := exp affecte la variable $var avec la séquence

“entière” retournée par exp.
Requête:
for $b in document("bib.xml")//book[1]
let $al := $b/author
return <livre nb_auteurs="{count($al)}">
{ $al }
</livre>
Résultat:
<livre nb_auteurs="2">
</livre>
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
SÉLECTION: WHERE
La clause where exp permet de filtrer le résultat par rapport au résultat

booléen de l’expression exp (= prédicat dans l’expression de chemin).
Requête:
<livre>
{ for $a in document("bib.xml")//book
where $a/author[1]/la eq "Abiteboul"
return $a/@title
}
</livre>
Résultat:
<?xml version="1.0"?>
<livre title="Data on the Web"/>
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
TESTS: IF-THEN-ELSE
Requête:
<livres>
{ for $b in document("bib.xml")//book
where $b/author/la = "Rigaux"
return
if ($b/@year > 2000)
then <livre recent="true"> {$b/@title} </livre>
else <livre> {$b/@title} </livre> }
</livres>
Résultat:
<livres>
<livre title="Comprendre XSLT"/>
<livre recent="true" title="Spatial Databases"/>
</livres>
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
QUANTIFICATION
some $var in expr1 satisfies expr2 il existe au moins un noeud

retourné par l’expression expr1 qui satisfait l’expression expr2.
every $var in expr1 satisfies expr2 tous les nœuds retournés

par l’expression expr1 satisfont l’expression expr2
Requête:
for $a in document("bib.xml")//author
where every $b
in document("bib.xml")//book[author/la = $a/la]
satisfies $b/publisher="Morgan Kaufmann Publishers"
return string($a/la)
Résultat:
Scholl, Voisard, Abiteboul, Buneman, Suciu

Brahim ER-RAHA
Brahim ER-RAHA
TRIER AVEC SORT BY
Expr1 sort by Expr2 (ascending | descending)?
Trier les éléments de la séquence retournée par l’expression Expr1 par

les valeurs retournées par Expr2.
Requête:
<livres>{ for $b in document("bib.xml")//book
return <livre> { $b/@title, $b/@year } </livre>
sort by(@year) }
</livres>
Résultat:
<livres>
<livre title="Data on the Web" year="2000"/>
<livre title="Spatial Databases" year="2001"/>
<livre title="Comprendre XSLT"/>
</livres>
Brahim ER-RAHA
JOINTURE
Utilisation de plusieurs Document XML
Fichier d’adresses:
Brahim ER-RAHA
JOINTURE: REQUÊTE
Requête:
for $b in document("bib.xml")//book
return element livre {
attribute titre {$b/@title},
for $a in $b/author
return element auteur {
attribute nom {$a/la},
for $p in document("addr.xml")//person
where $a/la = $p/name
return attribute institut {$p/institution}
}}
Brahim ER-RAHA
Résultat:
<livre titre="Comprendre XSLT">

<auteur nom="Amann" institut="CNAM"/>
<auteur nom="Rigaux"/>
</livre>,
<livre titre="Spatial Databases">
<auteur nom="Rigaux"/>
<auteur nom="Scholl" institut="CNAM"/>
<auteur nom="Voisard" institut="FU Berlin"/>
</livre>,
<livre titre="Data on the Web">
<auteur nom="Abiteboul"/>
<auteur nom="Buneman"/>
<auteur nom="Suciu"/>
</livre>
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
XQuery : Langage de
programmation
XQuery n'est pas seulement un langage de
requête "à la SQL".
C'est aussi un vrai langage de
programmation fonctionnel.
Il possède un certain nombre de
caractéristiques qui, couplées à quelques
extensions, en font un outil intéressant pour
du développement d'applications Web.
Nous allons évoquer ici quelques
caractéristiques de bases.
Déclaration de variables externes
Les variables externes sont déclarées de
la manière suivante :
◦ declare variable $v [as type] external;
◦ Exemple :
◦ declare variable $v as xs:double external;
Les types de variables

Les types, aussi bien pour les variables que
pour les signatures des fonctions, sont ceux
de XSD avec, en plus, des types spécifiques.
La figure (http://www.w3.org/TR/xpath-
functions/type-hierarchy.png ). les rappelle
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
EXEMPLE: INDEX-OF
Requête:
<books> {
let $bl := document("bib.xml")//book
for $b in $bl
return <book> {
$b/@title,
attribute no {index-of($bl, $b)}}
</book> }
</books>
Résultat:
<books>
<book title="Comprendre XSLT" no="1"/>
<book title="Spatial Databases" no="2"/>
<book title="Data on the Web" no="3"/>
</books>
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Pour exemple voir le diapo
présentationXquery
Brahim ER-RAHA
Brahim ER-RAHA
Pour exemple voir le diapo
présentationXquery
Avec base Xbase
dossier testxquery
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
DOM & SAX
Brahim ER-RAHA
Utilisation des Parseurs (DOM et SAX)
Il existe plusieurs types de parseur. Les deux plus répandus sont ceux qui utilisent un
arbre pour représenter et exploiter le document et ceux qui utilisent des événements. Le
parseur peut en plus permettre de valider le document XML.
Ceux qui utilisent un arbre permettent de le parcourir pour obtenir les données et
modifier le document. Ceux qui utilisent des événements associent à des méthodes
particulières pour traiter le document.
SAX (Simple API for XML) est une API libre créée par David Megginson qui utilisent
les événements pour analyser et exploiter les documents au format XML.
Les parseurs qui produisent des objets composant une arborescence pour représenter
le document XML utilisent le modèle DOM (Document Object Model) défini par les
recommandations du W3C.
Le choix d'utiliser SAX ou DOM doit tenir compte de leurs points forts et de leurs
faiblesses :
les avantages les inconvénients
parcours libre de l'arbre gourmand en mémoire
DOM possibilité de modifier la structure et le doit traiter tout le document avant
contenu de l'arbre d'exploiter les résultats
peut gourmand en ressources mémoire
traite les données séquentiellement
rapide
un peu plus difficile à programmer, il est
SAX principes faciles à mettre en oeuvre
souvent nécessaire de sauvegarder des
permet de ne traiter que les données
informations pour les traiter
utiles
Brahim ER-RAHA
SAX et DOM ne fournissent que des définitions : ils ne fournissent pas d'implémentation
utilisable. L'implémentation est laissée aux différents éditeurs qui fournissent un parseur
compatible avec SAX et/ou DOM. L'avantage d'utiliser l'un deux est que le code utilisé
sera compatible avec les autres : le code nécessaire à l'instanciation du parseur est
cependant spécifique à chaque fournisseur.
- IBM fourni gratuitement un parseur XML : xml4j. Il est téléchargeable à l'adresse

suivante : http://www.alphaworks.ibm.com/tech/xml4j
- Le groupe Apache développe Xerces à partir de xml4j : il est possible de télécharger la
dernière version à l'URL http://xml.apache.org
- Sun a développé un projet dénommé Project X. Ce projet a été repris par le groupe
Apache sous le nom de Crimson.
Ces trois projets apportent pour la plupart les mêmes fonctionnalités : ils se distinguent
sur des points mineurs : performance, rapidité, facilité d'utilisation etc. ... Ces
fonctionnalités évoluent très vite avec les versions de ces parseurs qui se succèdent
très rapidement.
Pour les utiliser, il suffit de dézipper le fichier et d'ajouter les fichiers .jar dans la variable
définissant le CLASSPATH.
Il existe plusieurs autres parseurs que l'on peut télécharger sur le web:
JDOM (acronyme de l'anglais Java Document Object Model), est une bibliothèque open
source pour manipulation des fichiers XML en Java. Elle intègre DOM et SAX, et
supporte XPath et XSLT
Brahim ER-RAHA
Brahim ER-RAHA
XML: le traitement par programme
XML
Schema
(ou DTD)
DOM
XML XML
Parser
<ville>Paris</ville> <ville>Paris</ville>
<pays>France</pays> Manipulation
Bien formé <pays>France</pays>
<temp Valide <temp de l'arbre
echelle="C">18</temp> echelle="C">18</temp>
SAX
XSL <ville>Paris</ville>
Stylesheet
Mal formé/Invalide
événements – call back
XSLT XSLFO
<city>Paris</city>
<temp
degree="F">65</te
mp>
WML XML (X)HTML PDF RTF, Word
Brahim ER-RAHA
Brahim ER-RAHA
V-3-1 les objets de DOM
DOM est l'acronyme de Document Object Model. C'est une spécification du W3C
pour proposer une API qui permet de modéliser, de parcourir et de manipuler un
document XML. Le principal rôle de DOM est de fournir une représentation
mémoire d'un document XML sous la forme d'un arbre d'objets et d'en permettre
la manipulation (parcours, recherche et mise à jour).
A partir de cette représentation (le modèle), DOM propose de parcourir le

document mais aussi de pouvoir le modifier. Ce dernier aspect est l'un des
aspects les plus intéressants de DOM.
DOM est défini pour être indépendant du langage dans lequel il sera implémenté.
DOM n'est qu'une spécification qui pour être utilisée doit être implémentée par
un éditeur tiers.
Il existe deux versions de DOM nommées «niveau» :
DOM Core Level 1 : cette spécification contient les bases pour manipuler un
document XML (document, élément et noeud)
DOM level 2 et 3
Le level 4 est en cours de développement
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
org.w3c.dom.Node
 La classe de base
 Tout objet DOM est un Node
 Methodes
 public Node getFirstChild();
 public java.lang.String getNodeName();
 public short getNodeType();
 public Node appendChild(Node newChild) throws
DOMException
 …
Brahim ER-RAHA
org.w3c.dom.NodeList
 Liste ordonnée de Node
 L’index commence à Zéro
 Méthodes
 public int getLength();
 public Node item(int index) ;
Brahim ER-RAHA
org.w3c.dom.NamedNodeMap
 Liste non ordonnée de Node
 Recherche par nom
 Méthodes
 public Node
getNamedItem(java.lang.String name);
 public Node setNamedItem(Node arg) throws
DOMException
 …
Brahim ER-RAHA
org.w3c.dom.Document
 Un objet de type Document représente le
document XML en cours de traitement
 Méthodes :
 public NodeList getElementsByTagName(String tagname)
 public Element getDocumentElement();
 public Attr createAttribute(String name) throws
DOMException
 public Text createTextNode(String data)
 public Comment createComment(String data)
 …
Brahim ER-RAHA
org.w3c.dom.Element
 Un objet de type Element représente un
élément du document XML
 Méthodes :
 public java.lang.String getAttribute(String name);
 public NodeList
getElementsByTagName(String name);
 public java.lang.String getTagName();
 …
Brahim ER-RAHA
org.w3c.dom.Attr
 Un objet de type Attr représente l’attribut d’un
élément du document XML
 Un objet de type Attr n’est pas le fils d’un objet
de type Element représentant l’élément qui
contient l’attribut (voir Node).
 Méthodes :
 public java.lang.String getName();
 public java.lang.String getValue();
 public void setValue(java.lang.String value) throws
DOMException
 …
Brahim ER-RAHA
org.w3c.dom.CharData
 Supertype de tout objet représentant du texte
 Méthodes :
 public String getData() throws DOMException
 public void setData(String data) throws DOMException
 public int getLength()
 public void appendData(String arg) throws
DOMException
 public void insertData(int offset, String arg) throws
DOMException
 …
Brahim ER-RAHA
org.w3c.dom.Text
 Hérite de CharData
 Représente La valeur textuelle
 D’un élément
 D’un attribute
 Deux objets Text consécutif seront uni lors
du prochain parsing
 Méthode :
 public Text splitText(int offset) throws
DOMException
Brahim ER-RAHA
org.w3c.dom.Comment
 Hérite de CharData
 Représente un commentaire XML
 Ne contient pas les balises
 <!- -
 -->
Brahim ER-RAHA
org.w3c.dom.CDATASection
 Hérite de Text
 Représente une section littérale
 Ne contient pas les balises
 <![CDATA[
 ]]>
Brahim ER-RAHA
org.w3c.dom.DocumentType
 Les documents XML ont un attribut doctype qui
a pour valeur null ou un objet DocumentType
 Représente la liste des entitées définies pour le
document
 Méthodes :
 public NamedNodeMap getEntities()
 public java.lang.String getName()
 …
 Attention un DocumentType ne représente pas
la totalité de la DTD
Brahim ER-RAHA
org.w3c.dom.Entity
 Représente une Entité XML (parsable ou
non parsable)
 Représente l’entité et non pas la déclaration
 Pas de trace de la valeur
 Méthodes :
 public java.lang.String getNotationName()
 public java.lang.String getSystemId()
 public java.lang.String getPublicId()
Brahim ER-RAHA
org.w3c.dom.EntityReference
 Représente une référence vers une entité
 Méthode :
 Aucune
 Sous-spécifié
Brahim ER-RAHA
Voir le projet Eclipse
XML-JDOM-DOM-SAX
Chaque élément qui compose l'arbre possède un type. Selon ce type, l'élément peut
avoir certains éléments fils comme le montre le schéma ci-dessus. Toutes les
classes et interfaces sont regroupées dans le package org.w3c.dom
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
Architecture d'une application utilisant SAX :
Brahim ER-RAHA
l'application récupère un parseur (javax.xml.parsers.SAXParser) à partir
d'une fabrique de parseurs (javax.xml.parsers.SAXParserFactory).
Ce parseur parcourt le document XML grâce à un lecteur

(org.xml.sax.XMLReader). Ce dernier contient plusieurs
gestionnaires (ou handlers). Ce sont ces différents gestionnaires qui sont
chargés du traitement des "événements" lors du parsing.
Voici les quatres principaux types de handlers (interfaces du package
org.xml.sax) :
• Gestionnaire de Contenu : Le ContentHandler est chargé des événements
comme le début ou la fin du document, l'ouverture ou a fermeture de
balises ou encore la lecture de caractères.
• Gestionnaire d'Erreurs : Le ErrorHandler va traiter les trois types d'erreurs
possibles lors du parsing : les erreurs simples, les erreurs fatales et les
warnings.
• Gestionnaire de DTD : Le DTDHandler (Document Type Definition) gère les
événements relatifs aux DTD.
• Gestionnaire d'entités externes : L'EntityResolver est chargé de gérer les
entités externes, en fournissant une InputSource adéquate.
Brahim ER-RAHA
On ne doit pas implémenter les quatre types de handlers, Il faut utiliser
la classe DefaultHandler du package org.xml.sax.helpers. Le fonctionnement
de cette classe peut être comparé à celui des adapters pour les listeners (AWT
et Swing). C'est-à-dire que cette classe propose une implémentation par défaut
des quatres types de gestionnaires.
Voir l’exemple

XML-JDOM-DOM-SAX
Brahim ER-RAHA
Parseur SAX DOM
Pour traiter la totalité d’un document XML au moment de
sa lecture, il faut utiliser un parseur SAX.
JDK fournit un parseur DOM et un parseur SAX qui

peuvent être utilisé sans passer par JDOM
Interpréter un fichier XML
SAX
import javax.xml.parsers.*;import org.xml.sax.*;
import org.xml.sax.helpers.*;
public class SaxParser extends DefaultHandler {
public SaxParser() {
try {
SAXParserFactory parserFactory=SAXParserFactory.newInstance();
SAXParser saxParser=parserFactory.newSAXParser();
saxParser.parse("EX3.xml",this);
} catch (Exception e) { e.printStackTrace(); }
}
@Override
public void startDocument() throws SAXException {
System.out.println("Début Document");
}
@Override
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
// Début de chaque élément
System.out.println("Elément :"+qName);
System.out.println("\t Attributs:");
for(int i=0;i<attributes.getLength();i++){
System.out.println("\t\t"+attributes.getQName(i)
+"="+attributes.getValue(i));
}
}
@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
// Fin de chaque élément
}
@Override
public void endDocument() throws SAXException {
// Fin du document
}
public static void main(String[] args) {

new SaxParser();
}
}
JDOM ?
JDOM est une API du langage Java développée
indépendamment de Sun Microsystems.
Elle permet de manipuler des donnés XML plus
simplement qu'avec les API classiques.
Son utilisation est pratique pour tout développeur Java et
repose sur les API XML de Sun.
JDOM permet donc de construire des documents, XML,
de naviguer dans leur structure, s'ajouter, de modifier, ou
de supprimer leur contenu.

XML-JDOM-DOM-SAX
Origines de JDOM
Les Parseurs SAX
◦ SAX est l'acronyme de Simple API for XML.
◦ Ce type de parseur utilise des événements pour piloter le traitement d'un
fichier XML.
◦ JDOM utilise des collections SAX pour parser les fichiers
XML.
◦ DOM
Les Parseurs DOM : de Document Object Model. C'est une spécification du W3C
est l'acronyme
pour proposer une API qui permet de modéliser, de parcourir et de manipuler
un document XML.
◦ Le principal rôle de DOM est de fournir une représentation mémoire d'un
document XML sous la forme d'un arbre d'objets et d'en permettre la
manipulation (parcours, recherche et mise à jour).
◦ A partir de cette représentation (le modèle), DOM propose de parcourir le
document mais aussi de pouvoir le modifier.
◦ Ce dernier aspect est l'un des aspect les plus intéressant de DOM.
◦ DOM est défini pour être indépendant du langage dans lequel il sera
implémenté.
◦ JDOM utilise DOM pour manipuler les éléments d'un Document Object Model
spécifique (créé grâce à un constructeur basé sur SAX).
Créer un document XML avec JDOM
L’API JDOM :
◦ Il vous faut dans un premier temps télécharger la dernière version de JDOM
disponible à cette adresse : http://www.jdom.org/dist/binary/.
◦ Il suffit ensuite de rendre accessible le fichier /build/jdom.jar, en le plaçant dans votre
classpath.
Création d’un document XML avec JDOM:
◦ La création d'un fichier XML en partant de zéro est des plus simple.
◦ Il suffit de construire chaque élément puis de les ajouter les uns aux autres de façon
logique.
◦ Un noeud est une instance de org.jdom.Element.
◦ Nous commençons donc par créer une classe JDOM1 qui va se charger de créer
l'arborescence suivante :
<personnes>
<etudiant classe="P2">
<nom>Katib</nom>
</etudiant>
</personnes>
Exemple d’application pour la création d’un document XML avec JDOM
import java.io.*;import org.jdom.*;
import org.jdom.output.*;
public class App1 {
public static void main(String[] args) throws IOException {
/*Créer l’élément racine */
Element racine = new Element("personnes");
/*Créer un document JDOM basé sur l’élément racine*/
Document document = new Document(racine);
/*Créer un nouveau Element xml etudiant
*/
Element etudiant = new Element("etudiant");
/* Ajouter cet élément à la racine */
racine.addContent(etudiant);
/*Créer un nouveau attribut classe dont la valeur est P2
*/
Attribute classe = new Attribute("classe","P2");
/* Ajouter cet attrubut à l’élément etudiant */
etudiant.setAttribute(classe);
Element nom = new Element("nom"); /* Créer l’élément nom */
nom.setText("Katib"); /* Définir le texte de nom */
etudiant.addContent(nom); /* ajouter nom à etudiant */
/* Afficher et enregistrer le fichier XML */
XMLOutputter sortie=new XMLOutputter(Format.getPrettyFormat());
sortie.output(document, System.out);
sortie.output(document, new
FileOutputStream("EX1.xml"));
}}
Parcourir un document XML avec JDOM
Parser un fichier XML revient à transformer un fichier XML en une arborescence
JDOM.
Nous utiliserons pour cela le constructeur SAXBuilder, basé, comme son nom
l'indique, sur l'API SAX.
Créez tout d'abord le fichier suivant dans le répertoire contenant votre future
classe JDOM2 :

<personnes>
<nom>katib</nom>
<prenoms>
<prenom>mohamed</
prenom>
<prenom>amine</prenom>
</etudiant>
</prenoms>
<nom>talbi</nom>
</etudiant>
<nom>santel</nom>
</etudiant>
</personnes>
Afficher les noms des étudiants du fichier XML
import java.io.*;import java.util.List;
import org.jdom.*;import org.jdom.input.SAXBuilder;
public class App2 {
public static void main(String[] args) throws Exception {
/* On crée une instance de SAXBuilder */
SAXBuilder sb=new SAXBuilder();
/* On crée un nouveau document JDOM avec en argument le fichier XML */
Document document=sb.build(new File("EX2.xml"));
/*On initialise un nouvel élément racine avec l'élément racine du
document.*/
Element racine=document.getRootElement();
/* On crée une List contenant tous les noeuds "etudiant" de l'Element
racine */
List<Element> etds=racine.getChildren("etudiant");
/* Pour chaque Element de la liste etds*/
for(Element e:etds){
/*Afficher la valeur de l'élément nom */
System.out.println(e.getChild("nom").getText());
}
}
}
Modifier une arborescence avec JDOM
Quelques méthodes de JDOM:
◦ addContent : Ajoute le contenu de l'argument à la fin du contenu d'un Element. On
peut spécifier un index pour l'inserer à la position voulu.
◦ clone : Retourne un clone parfait de l'Element.
◦ cloneContent : on ne copie que le contenu.
◦ removeAttribute : Supprime un attribut d'un Element
◦ removeChild : Supprime le premier enfant portant ce nom.
◦ removeChildren : Supprime tous les enfants ayant ce nom.
◦ removeContent : Supprime l'intégralité d'un noeud donné en argument ou par sa
position. removeContent accept aussi les filtres, tout comme getContent vu
précédement.
◦ setAttribute : permet à la fois de créer un attribut et d'en modifier sa valeur.
◦ setContent : Remplace le contenu d'un Element. On peut spécifier un index si l'on
ne veut pas tout remplacer.
◦ setName : Change le nom de l'Element.
◦ setText : Change le text contenu par l'Element. <element>TEXT</element>
◦ toString : Retourne une représentation de l'Element sous forme de chaine.
JDOM et XSLT
Grâce à l'API JAXP et TraX il est très
facile de faire des transformation XSLT
sur un document JDOM.
Dans l'exemple suivant nous allons créer
une méthode qui prend en entrée un
document JDOM et le nom d'un fichier
XSL et qui crée en sortie un fichier XML
transformé.
Fichier XML
<personnes>
<nom>katib</nom>
<prenoms>
<prenom>mohamed</
prenom>
<prenom>amine</prenom>
</etudiant>
</prenoms>
<nom>talbi</nom>
</etudiant>
<nom>santel</nom>
</etudiant>
</personnes>
Fichier XSL pour générer une sortie HTML
<html>
<head></head>
<body>
<tr>
<th>Nom</
th><th>Prénoms</th>
</tr>
<xsl:for-each select="personnes/etudiant">
<tr>
<td><xsl:value-of select="nom"/></td>
<td><xsl:value-of select="prenoms/prenom[1]"/></td>
</tr>
</xsl:for-each>
</table>
</
body>
</html>
</xsl:template>
</xsl:stylesheet>
Exemple de transformation XSL avec
JDOM
import java.io.*; import org.jdom.*;
import org.jdom.input.SAXBuilder;
import javax.xml.transform.*;
import javax.xml.transform.stream.StreamSource;
public class JDOM4{
public static void main(String[] args) {
SAXBuilder sb=new SAXBuilder();
try {
Document
jDomDoc=sb.build(new
File("Exercice2.xml"));
outputXSLT(jDomDoc,
"classe.xsl");
} e.printStackTrace
catch (Exception e) {
();
}}
Exemple de transformation XSL avec JDOM
public static void outputXSLT(org.jdom.Document documentJDOMEntree,String
fichierXSL){
/*Document JDOMResult, résultat de la transformation TraX */
JDOMResult documentJDOMSortie = new JDOMResult();
/* Document JDOM après transformation */
org.jdom.Document resultat = null;
try{
/* On définit un transformer avec la source XSL qui va permettre la
transformation */
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer(new
StreamSource(fichierXSL));
/* On transforme le document JDOMEntree grâce à notre transformer. La
méthoded transform() prend en argument le document d'entree associé au
transformer et un document JDOMResult, résultat de la transformation
TraX */
transformer.transform(new org.jdom.transform.JDOMSource
(documentJDOMEntree), documentJDOMSortie);
/* Pour récupérer le document JDOM issu de cette transformation, il faut
utiliser la méthode getDocument() */
resultat = documentJDOMSortie.getDocument();
/* On crée un fichier xml corespondant au résultat */
XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat());
outputter.output(resultat, new FileOutputStream("resultat.htm"));
} catch(Exception e){}
}}
Fichier HTML généré : resultat.htm
<html>
<head />
<body>
<tr>
<th>Nom</th>
<th>PrÃ©noms</
th>
</tr>
<tr>
<td>CynO</td>
<td>Nicolas</
td>
</tr>
<tr>
<td>Superwoman</td>
<td />
</tr>
<tr>
<td>Don Corleone</td>
<td />
</tr>
</
table>
</body>
</html>
Application
1- Créer une application java qui permet
de créer le fichier XML suivant :
meteo.xml
<meteo>
<mesure date="2006-1-1">
<ville nom="casa"
temp="25" />
<ville nom="rabat" temp="28" />
</meteo>
</mesure>
Application
4 - Créer une feuille de style XSL qui permet de transformer le
document XML meteo2.xml en document HTML suivant :
5 - Créer une application java qui permet d’afficher la transformation du

fichier XML meteo2.xml par la feuille de style XSL que vous venez de créer.
Enregistrer la sortie dans un fichier m.htm
Brahim ER-RAHA
Voir les video projet eclipse : XML_JDOM_DOM_SAX
Brahim ER-RAHA
Brahim ER-RAHA
XML ET LES BASES DE DONNÉES
1 INTRODUCTION
XML est devenu dans peu de temps le format standard de structuration et

d’échange de données le plus populaire. Ce métalangage est capable d’être le
format du stockage, du transport et d’affichage des données. Parallèlement, les
bases de données relationnelles constituaient depuis un bon moment et constituent
toujours le moyen le plus utilisé pour le stockage des données dans la plupart des
entreprises, et ce pour leur capacité de mettre à disposition d’un grand nombre
d’utilisateurs des données avec un accès rapide et un bon niveau de sécurité.
Pour ces raisons et pour les avantages qu’offrent ces deux moyens, à savoir XML
et les SGBDs, plusieurs auteurs pensent que « l’utilisation combinée de ces deux
méthodes offre également au programmeur un grand nombre de possibilités.
D’une part, les bases de données relationnelles apportent une gestion et des
fonctionnalités de sécurité fiables…
d’autre part, dans la mesure où le langage XML est composé uniquement de
texte, il peut facilement être transmis sur un réseau, et d’une plate-forme à
l’autre… de plus, il peut facilement être traduit d’un langage à l’autre»
Brahim ER-RAHA
Plusieurs raisons donc nous poussent à associer XML et les bases de données :
stocker des documents XML dans une base de données ou utiliser un contenu
d’une base de données au format XML :
-XML fournit une méthode de représentation des données structurées sans ajout
d’informations,
- XML permet la réutilisation des données par des systèmes d’héritage,
- XML peut être utilisé par des outils déjà disponibles (Feuilles de style : XSLT et
serveurs XML : ex : Biztalk…),
- XML, en contenant les données et la structure, permet facilement la

transmission et la représentation des données,
- Les bases de données sont plus adaptées que XML pour des utilisations
internes de recherche.
Brahim ER-RAHA
Brahim ER-RAHA
Brahim ER-RAHA
2- TRANSFORMATION BASÉE SUR LES TABLES
La correspondance basée sur des tables est utilisée par de nombreux logiciels qui
transfèrent les données entre une base relationnelle et un document XML. Elle modélise
les documents sous la forme d’une table unique ou comme un ensemble de tables. Cela
signifie que la structure d’un document XML doit être comme suit :
<database>
<table>
<row>
<column1>...</column1>
<column2>...</column2>
...
</row>
...
</table>
<table>
...
</table>
...
</database>
Selon le logiciel, il peut être possible de spécifier si la colonne de données est stockée
en tant qu’éléments fils ou comme attributs, ainsi que les noms à utiliser pour chaque
élément ou attribut. La correspondance basée sur des tables est utile pour sérialiser des
données relationnelles, comme par exemple pour transférer des données entre deux
bases de données relationnelles. Son inconvénient évident est qu’elle ne peut pas être
utilisée par les autres SGBD. (voir exemple pg :61)
Brahim ER-RAHA
Dans une base de données, il y a des différentes tables qui stockent chacune un
ensemble de données liées à une entité déterminée. Une table représentant une
adresse postale d’une personne par exemple peut être schématisée comme suit :
Prénom Nom Rue Ville Code postale Pays

Omar Ramki Rue des Far Agadir 80000 Maroc
Cette table est créée, par le biais du langage SQL, comme suit :
Create table PERSONNE (Prenom VARCHAR(35), Nom VARCHAR (35), Rue

VARCHAR (35), Ville VARCHAR (35), Code_postal VARCHAR (9), Pays
VARCHAR (35)) ;
XML permet deux moyens de représenter ces données : en utilisant des éléments
ou des attributs
Brahim ER-RAHA
En utilisant des éléments, nous pouvons présenter l’élément « Personne » comme
suit :
<Personne>
<Prénom>Omar</Prénom>
<Nom>Ramki</Nom>
<Rue>Rue des FAR</Rue>
<Ville>Agadir</Ville>
<Code_postal>80 000</Code_postal>
<Pays>Maroc</Pays>
</Personne>
En utilisant des attributs, l’élément « Personne » peut être présenté comme suit :
<Personne
Prénom="Omar"
Nom="Ramki"
Rue="Rue des FAR"
Ville="Agadir"
Code_postal="80 000"
Pays="Maroc"/>
Brahim ER-RAHA
Considérons le cas d'une base de données relationnelle qui contient deux tables en
relation à travers l'exemple suivant :
Le script qui permet de créer ces deux tables est le suivant :
CREATE TABLE PROPRIETAIRE (ID_Proprietaire BIGINT(100) NOT NULL,

Prenom_Owner VARCHAR(255) NOT NULL,Nom_Owner VARCHAR(255) NOT NULL,
Tel_Owner VARCHAR (25) NOT NULL, Email_Owner VARCHAR (255), Ville_Owner
VARCHAR (35) PRIMARY KEY (ID_Proprietaire));
CREATE TABLE MODELEXML (ID_Modele BIGINT(100) NOT NULL ,

Designation_Modele VARCHAR(255) NOT NULL, Version VARCHAR(255) NOT NULL,
Date_Version DATE NOT NULL, Mots_Cles TEXT, ID_Proprietaire BIGINT (100),
PRIMARY KEY (ID_Modele), FOREIGN KEY (ID_Proprietaire) REFERENCES
PROPRIETAIRE (ID_Proprietaire));
Brahim ER-RAHA
En XML, cette association des deux tables peut être illustrée par une imbrication en
éléments fils de la table référence.
< !ELEMENT PROPRIETE_MODELE (MODELEXML+)>

< !ATTLIST PROPRIETE_MODELE
Prenom_Owner CDATA #REQUIRED
Nom_Owner CDATA #REQUIRED
Tel_Owner CDATA #REQUIRED
Email_Owner CDATA #REQUIRED
Ville_Owner CDATA #REQUIRED>
<!ELEMENT MODELEXML EMPTY>
<!ATTLIST MODELEXML
Designation_Modele CDATA #REQUIRED
Version CDATA #REQUIRED
Date_Version CDATA #REQUIRED
Mots_Cles CDATA #REQUIRED>
Brahim ER-RAHA
Considérons le cas :
Brahim ER-RAHA
Le script qui permet de créer cette troisième table est le suivant :
CREATE TABLE PROPRIETAIRE (ID_Proprietaire BIGINT(100) NOT NULL,

Prenom_Owner VARCHAR(255) NOT NULL, Nom_Owner VARCHAR(255) NOT NULL,
Tel_Owner VARCHAR (25) NOT NULL, Email_Owner VARCHAR (255), Ville_Owner
VARCHAR (35), PRIMARY KEY (ID_Proprietaire));
CREATE TABLE ORGANISATION (ID-Organisation BIGINT (100) NOT NULL, om_Org

VARCHAR (35), Acronyme_Org VARCHAR (35), Tel_Org VARCHAR (25),
Site_Web_Org VARCHAR (255), Ville_Org VARCHAR (255), PRIMARY KEY
(ID_Organisation));
CREATE TABLE MODELEXML (ID_Modele BIGINT(100) NOT NULL,

Designation_Modele VARCHAR(255) NOT NULL, Version VARCHAR(255) NOT NULL,
Date_Version DATE NOT NULL, Mots_Cles TEXT, ID_Proprietaire BIGINT (100),
PRIMARY KEY (ID_Modele), FOREIGN KEY (ID_Proprietaire) REFERENCES
PROPRIETAIRE (ID_Proprietaire), FOREIGN KEY (ID_Organisation) REFRENCES
ORGANISATION (ID_Organisation));
Brahim ER-RAHA
Pour présenter cette relation plus complexe en XML, nous pouvons créer le
modèle de données suivant
< !ELEMENT DONNEES_MODELE (PROPRIETE_MODELE, ORGANISATION+)>
<!ELEMENT PROPRIETE_MODELE (MODELEXML+)>

< !ATTLIST PROPRIETE_MODELE Prenom_Owner CDATA #REQUIRED
Nom_Owner CDATA #REQUIRED Tel_Owner CDATA #REQUIRED
Email_Owner CDATA #REQUIRED Ville_Owner CDATA #REQUIRED>
<!ELEMENT MODELEXML EMPTY>

<!ATTLIST MODELEXML IDREFORGANISATION IDREF #REQUIRED
Designation_Modele CDATA #REQUIRED Version CDATA #REQUIRED
Date_Version CDATA #REQUIRED Mots_Cles CDATA #REQUIRED>
<!ELEMENT ORGANISATION EMPTY>

<!ATTLIST ORGANISATION ID_Organisation ID #RQUIRED
Nom_Org CDATA #REQUIRED Acronyme_Org CDATA #REQUIRED
Tel_Org CDATA #REQUIRED Site_Web_Org CDATA #REQUIRED
Ville_Org CDATA #REQUIRED>
Brahim ER-RAHA
2 EXTRACTION CONTROLÉE PAR UN MODÈLE XML
Dans cette méthode, nous écrivons un modèle XML, qui va décrir exactement le modèle
cible, les données extraites de SGBD étant insérées dans cette structure. Nous utilisant
pour cela une API ODBC2XML qui est typique dans ce modèle (cette API est de type
Shareware).
Le modèle XML est un document XML bien formé dans le quel les requêtes SQL
apparaissent dans des instructions de traitement. Les données reçues de la connexion
ODBC en réponse à ces requêtes sont utilisées pour générer les éléments qui suivent
immédiatement l'instruction de traitement
Exemple :
Supposons qu'on a la table "produits" suivante :
ProduitRef Nom Poids

R1 Oxava212 255
R2 Siripi314 300
R3 Siripi433 433
R4 Slim633 236
R5 Remoc500 652
Brahim ER-RAHA
Le modèle XML d'extraction de données est :
<Catalogue>
<Titre> Voici le poids de chacun de nos produits : </Titre>
<Liste>
<?odbc2xml q1: select * from produits?>
<Produit id=" odbc2xml q1.ProduitRef ">
<Nom> <?odbc2xml q1.Nom?> <Nom>
<Poids> <?odbc2xml q1.Poids?> <Poids>
</Produit>
</Liste>
</Catalogue> <Catalogue>
<Titre> Voici le poids de chacun de nos produits :</Titre>
<Liste>
<Produit id=" R1 ">
<Nom> Oxava212<Nom>
<Poids>255 <Poids>
</Produit>
Après avoir exécuter l'api ODBC2XML
<Produit id=" R2 ">
, on obtiendra comme résultat :
<Nom> Siripi314<Nom>
<Poids>300 <Poids>
</Produit>
<Produit id=" R3 ">
<Nom> Siripi433<Nom>
<Poids>433 <Poids>
</Produit>
...</Liste></Catalogue>
Brahim ER-RAHA
Considérons la requête suivante : Select * from produit, fournisseurs
Where fournisseurs.ville="Casa"
And
Fournisseurs.CodeFournisseur=Produit.Co
deFournisseur
Le modèle XML d'extraction de données est :
<Catalogue>
<Titre> Voici le poids de chacun de nos produits : </Titre>
<ListeParFournisseur>
<?odbc2xml q1: select * from Fournisseur where
ville="Casa"?>
<Fournisseur id=" odbc2xml q1.CodeFournisseur ">
<Nom> <?odbc2xml q1.NomFournisseur?> </Nom>
</Fournisseur>
<ListProduit>
<?odbc2xml q2: select * from Produit where
CodeFournisseur = :
q1.CodeFournisseur ?>
<Produit id=" odbc2xml q1.ProduitRef ">
<Nom> <?odbc2xml q1.Nom?> <Nom>
<Poids> <?odbc2xml q1.Poids?> <Poids>
</Produit>
</ListeProduit>
</ListeParFournisseur></Catalogue>
Brahim ER-RAHA

Cours XML Final

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours XML Final

Transféré par

Droits d'auteur :

Formats disponibles

Cours XML

On peut l'envoyer tel quel, dans le texte du courrier

A la réception, le lecteur humain saura décoder les différents champs de l'adresse

• il faut l'extraire du reste du texte => identification

1. il ne permet pas d’échanger des données

On ne sait pas interpréter des données fournies en HTM

Nouvelles utilisations du Web

Commerce électronique : les entreprises veulent échanger des informations

Moteur de recherche : si je sais interpréter les données transmises, je peux les

Services en ligne : je peux envoyer mes données à un serveur pour leur

Le réseau est hétérogène : les données doivent être représentées

Les applications sont variées : les données doivent être représentées

Une application = un format de données : il faut pouvoir transformer

Le langage XML est une réponse à ces besoins :

Un document XML est au format ASCII : il voyage (relativement) facilement

Hyper Text Markup Language

eXtensible Markup Language

XML ( Sépare les données la structure des données et la

XML (eXtensible Markup Language et traduisez Langage à balises étendu, ou

En réalité les balises XML décrivent le contenu plutôt que la présentation

Serveur d’application IIS Serveur d’application J2EE

Application .net Application JEE

Client Leger Fichiers XML dont le contenu

HTTP POST Mapping

Projet AMELI : Une application de Interface avec les applications

Voici les principaux atouts de XML :

 La lisibilité : aucune connaissance ne doit théoriquement être nécessaire pour

 Une structure arborescente : permettant de modéliser la majorité des problèmes

 Universalité et portabilité : les différents jeux de caractères sont pris en compte

 Déployable : il peut être facilement distribué par n'importe quels protocoles à

MathML Mathematical Markup Language notation mathématique sur le web

CML Chemical Markup Language pour la publication Internet des formules

VML Vector Markup Language langage de balisage d’information graphique

PGML Precision Graphics Markup Language décrit les structures de données

SMIL Synchronized Multimedia Integration Language pour la création

WML Wireless Markup Language le langage de balisage pour l’internet mobile

XML est un format de description des données et non de leur représentation,

CSS (Cascading StyleSheet), la solution la plus utilisée actuellement, étant donné

XSL (eXtensible StyleSheet Language), un langage de feuilles de style extensible

XSLT (eXtensible StyleSheet Language Transformation). Il s'agit d'une

XML permet donc de définir un format d'échange selon les besoins de

Un document XML se compose de 3 fichiers :

Fichier XML DTD Feuille de style

 d’un prologue, dont la présence est facultative mais conseillée. Il contiendra un

Syntaxe : <?xml version="1.0" encoding="ISO-8859-1" standalone="yes" ?>

 d’un arbre d’éléments. Il forme le contenu du document.

 de commentaires et d’instructions de traitement, dont la présence est facultative.

Tibco Turbo XML DTD, XSL, XQuery

Insight Soft. XMLMate DTD, Schéma,

Représentation graphique de l’arbre XML

a- Choisir le nom de nos propre balise

b- Les balises sont sensibles au majuscules et minuscules

d- Les balises doivent être correctement imbriquées.

L'écriture correcte avec une bonne imbrication des éléments est :

En fait, la première paire de balises d'un document XML sera considéré

f- Les attributs des éléments

<date anniversaire=071185> La bonne écriture est :

Un auteur peut vouloir insérer un caractère non disponible sur sa plate-forme

Par exemple &#38; ou &#x2267; correspond au caractère et commercial &

k- Référence à des entités prédéfinies

Il existe quelques entités prédéfinies afin de faciliter leur insertion dans un

Syntaxe :

Le corps du commentaire peut contenir n’importe quel caractère à l’exception de

répondant aux règles de base du XML

Par exemple & ou ≧ correspond au caractère et commercial &