Slides XML

Le Méta-Langage XML
2ème GI
Ecole Hassania des Travaux Publics
Mohammed Karim GUENNOUN
1
Généralités et historique
2
Le concept de document électronique
 ISO TC-46: un document est un "ensemble formé par un

support et une information"
 Wikipedia: "un document électronique signifie toute
donnée informatique qui doit être utilisée sous forme
informatique. À l'inverse du document matériel, le
document électronique peut permettre de séparer
l'aspect présentation (mise en forme, mise en page...) et
l'aspect information (contenu, données...), offrant alors la
possibilité d’une exploitation séparée."
 Un document possède un fond (structure logique) et une
forme (structure physique)
 Il peut correspondre à plusieurs formes: textes, croquis,
tableaux, images…
3
La structure d’un document
 Structure logique
– Correspond au contenu du document
(l’information)
 Titre, chapitres, sections, figures, notes de bas de page…
 Structure physique
– Correspond à la forme et à la présentation du
document
 Police, style, taille, couleur des caractères, alignement,
espacement…
4
Structure logique: exemple
<Article>
<Titre> XML: eXtensible Markup Language </Titre>
<Auteur>Wikipédia</Auteur>
<Section titre = "Introduction">
<Paragraphe>XML (Extensible Markup Language, « langage de balisage
extensible ») est un langage informatique de balisage générique. Le W3C
recommande XML pour exprimer des langages de balisages spécifiques
(exemples : XHTML, SVG, XSLT).
</Paragraphe>
<Paragraphe> Son objectif initial est de faciliter l'échange automatisé de
contenus entre systèmes d'informations hétérogènes, notamment, sur
Internet. XML est un sous-ensemble de SGML dont il retient plusieurs
principes dont : la structure d'un document XML est définissable et validable
par un schéma, un document XML est entièrement transformable dans un
autre document XML.
</Paragraphe>
5 </Section>
</Article>
Structure physique: exemple
<Article>
<Titre police="Times" taille="24" position="centré" format="gras"/>
<Auteur police="Times" taille="20" position="centré" format="italique"/>
<Section numero="1" police="Times" taille="18" position="centré"
format=" gras "/>
<Paragraphe police="Times" taille="18" position="justifié"/>
</Article>
6
W3C
 W3C: World Wide Web Consortium
 Fondé en 1994 par Tim Berners-Lee avec l’aide du
MIT/LCS, DARPA, et la INRIA-commission Européenne
 Consortium international dispatché sur plusieurs sites et
géré par:
– MIT/LCS aux US
– INRIA puis ERCIM en Europe
– Keio University au Japon / université Beihang en Chine
 452 membres: e.g. IBM, Microsoft, Oracle…
 Objectifs: accroître le potentiel et l’utilisation du Web
– Leitmotiv: Un seul web partout et pour tous
– Production de standards et de normes
7 – Définition de techniques, langages, architectures pour l’échange
de l’information sur le Web
Chronologie des langages pour le
traitement des documents
 SGML: Standard Generalized Markup Language

– Norme internationale ISO 8879
– 1986, révisée en 1988 et 1994
– Méta-langage général
 HTML: HyperText Markup Language
– Standard W3C pour le formatage des documents sur le
Web
– 1991, 1995, 01/1997, 12/1997, 2008
 XML: eXtensible Markup Language
– Standard W3C
– Méta-langage simplifié compatible SGML
8
SGML
 Un méta-langage de balisage de documents
– Lisible par l’être humain
– Traitable par une machine
– Permet de définir des langages de balisage
 Implique la notion de validité d’un document
 Séparation du fond et de la forme
– Structure logique identifiée par des balises insérées dans le document
– Mise en page définie en dehors dans des feuilles de style
– Possibilité de multiplier les présentations selon le support de présentation
 Support des traitements sur le contenu sans prise en compte de la
forme
 Format de stockage et d’échange normalisé
 Faiblesse principale:
– Lourdeur et complexité de mise en œuvre
9
HTML
 Standard W3C comme format pour les documents à

travers le Web
 S’intéresse principalement à l’aspect présentation
– Balises standardisées pour la mise en forme
 Standard reconnu par tous les navigateurs Web
 Faiblesses:
– Normalisation des différentes balises
– Mélange des structures logique et physique
– Difficulté à trouver l’information et à la traiter
10
Introduction aux bases
d’XML
11
eXtensible Markup Language
Qu’est-ce que c’est?
 XML: un langage textuel d’échange et de stockage

de documents basé sur le balisage
– Langage de description générique
 Développé par XML Working Group dirigé par le
W3C depuis 1996
 Plus simple que SGML
 Plus ouvert et rigoureux que HTML
 XML 1.0, recommandation officielle du W3C depuis
le 10 Février 1998
– V1.1: 2004
 Devenu le standard dominant pour les échanges de
12 données à travers le Web
Qu’est-ce que ça doit faire?
 Specification du 10 février 1998: “Its goal is to enable

generic SGML to be served, received, and processed on
the web in the way that is now possible with HTML”.
 Objectifs principaux fixés par le W3C
– Il doit être facile d’éditer et de lire des documents XML
– XML est destiné à être utilisé sans difficulté sur le Web
– XML doit pouvoir être utilisé dans une grande variétés
d’applications
– XML doit être compatible avec SGML et HTML
– L’exploitation de programmes pour le traitement de documents
XML doit être aisée
– Les documents XML doivent être lisibles et compréhensibles par
13 l’homme
– La conception de XML doit être formelle et concise
Pourquoi c’est si bien?
 Séparation de la structure et de la
présentation
 Plus simple que SGML
 Idéal pour l’échange de données
 Compréhensible par l’homme et les
machines
 Utilisable entre machines hétérogènes
14
XML vs HTML
 Comme c’est le cas pour HTML,
– les données sont identifiées grâce à des tags (identifiants
entre "crochets angulaires" <…>)
– Collectivement, les tags sont désignés par le terme
balisage (Markup)
 Contrairement à HTML,
– les tags identifient des données au lieu de spécifier
comment les présenter.
– e.g. les tags HTML spécifient quelque chose comme:
afficher cette donnée en gras:
<b> quelque chose en gras </b>
– Les tags XML agissent comme un champs dans un
programme. Ils associent un label qui identifie une donnée:
15 <message>Ceci est mon message </message>

Concepts XML
 Balise ou tag ou label
 Élément de données
 Attribut
16
Les balises
 Les balises permettent de structurer les données

 De la même manière que pour les champs et les
attributs d’un objet, les noms des balises sont libres
du moment qu’ils ont un sens pour l’application qui
va les utiliser
 Évidemment, pour des systèmes impliquant
plusieurs applications, il est nécessaire de se mettre
d’accord sur les noms des balises pour partager les
données XML
17
Les éléments de données
 Exemple pour un système d’échange de message:

<message>
<to>destinataire@ehtp.ac.ma</to>
<from>moi@ehtp.ac.ma</from>
<subject> XML est un langage très sympa </subject>
<text> XML est très utile pour ….</text>
</message>
 Chaque balise de début possède une balise de fin qui lui correspond
 L’information entre les deux tags identifie un élément de la donnée XML
 A part le tag racine, tous les autres tags sont complètement contenus à l’intérieur
d’un autre tag.
 On obtient une structuration hiérarchique des données
 Comme pour HTML, les espaces blancs sont ignorés. L’auteur est libre de formater
les données pour plus de lisibilité
 Contrairement à HTML, la recherche de données est facilitée grâce à leur
structuration
– Les tags XML identifient le contenu et non la présentation.
– e.g. rechercher les message avec "toto" comme destinataire
18
Les attributs
 Les tags peuvent contenir des attributs

– Informations additionnelles incluses comme une partie intégrante du tag à
l’intérieur des crochets
 Exemple:
<message to="destinataire@ehtp.ac.ma"
from="moi@ehtp.ac.ma"
subject="XML est un langage très sympa" >
</message>
 Les tags to, from et subject sont maintenant des attributs. Cet exemple est
équivalent au précédent.
 Comme pour HTML,
– Les noms des attributs sont suivis par le signe égal
– Les attributs sont séparés par des espaces blancs
 Contrairement à HTML,
– les virgules entre les attributs ne sont pas ignorées. Si elles sont présentes elles
19 génèrent une erreur
Les tags vides
 Dans certains cas, il est pertinent d’avoir un tag sans contenu.

 Ce type de tag est appelé tag vide
 Un tag vide est terminé par "/>" au lieu de ">"
 Exemple:
<important/>
</message>
 Ceci permet de coder <important/> au lieu de coder
<important> </important>
20
Les commentaires
 Les commentaires sont codés de la même manière

que pour HTML
– Contenues entre <!- - et -->
– Exemple:
<!- - ceci est un commentaire - ->
<important/>
</message>
21
Le prolog
 Un fichier XML
– Un prolog
– Un corps
 Un fichier XML commence toujours par un prolog
 Le prolog minimal contient une déclaration qui identifie le

document comme un document XML:
– <?xml version="1.0"?>
 La déclaration peut contenir des informations

additionnelles
22 – <?xml version="1.0" encoding="ISO-88596-1" standalone="yes"?>
Les attributs du prolog
 La déclaration du prolog peut contenir les attributs suivants:

– version: identifie la version de l’XML utilisée. C’est un attribut obligatoire
– encoding: identifie l’ensemble des caractères utilisés pour encoder les données.
 Par défaut, c’est le 8-bit Unicode: UTF-8
 ISO-8859-1 correspond à Latin-1 de l’ensemble des caractères pour l’Europe de
l’ouest.
– standalone: spécifie si oui ou non, le document référence une entité externe ou
une spécification externe de types de données.
 S’il n’y a pas de référence externe, le mettre à "yes"
 Le prolog peut aussi contenir des définitions d’entités et des spécifications
qui précisent quels tags sont valides dans le document.
– Ces deux aspects peuvent être déclarés dans un Document Type Definition
(DTD)
– Il peut être directement défini dans le prolog ou en utilisant un pointeur sur un
fichier externe de spécification
 En général, le minimum c’est la version XML, mais c’est aussi une bonne
idée d’inclure l’encoding
23
Les instructions de traitement
 Un fichier XML peut aussi contenir des instructions de traitement qui

sont sensées spécifier des commandes à l’application qui traite les
données XML
 Possèdent le format suivant: <?Cible Traitements?>
– "Cible" pourrait correspondre au nom de l’application qui est susceptible
de réaliser le traitement
– "Traitements" est une chaîne de caractères qui pourrait englober
l’information et les commandes à exécuter par l’application
 Dans un fichier XML, on peut définir plusieurs instructions de
traitement pour différentes applications (parfois même pour faire la
même chose de manières différentes)
 La cible "xml" est réservée en majuscules et en minuscules.
– Du point de vue syntaxique, la déclaration est aussi une instruction de
traitement.
– Du point de vue sémantique, ce n’est pas le cas
24
Atouts d’XML
25
Les atouts d’XML (1)
 XML est un langage textuel

– XML n’est pas un format binaire
– Il est possible de créer et éditer un fichier XML
avec pratiquement tout, de l’éditeur de texte
standard à un environnement de développement
complexe
26
 XML permet l’identification des données

– XML s’intéresse au type et à la structure des
données et non à leur présentation
– Les tags permettent d’identifier les informations
pertinentes et de séparer les données en
différentes parties
 Faciliter la recherche ciblée d’informations
27
 Facilitation des traitements:

– L’aspect régulier et consistent des notations rend
facile l’implémentation de programmes pour traiter
les données
– XML est un standard neutre par rapport aux
vendeurs, choix libre concernant les parsers XML
 XML adopte la structuration hiérarchique
– la structure hiérarchique permet un accès et un
parcours plus efficace des données
28
Utilisations du langage
XML
29
Traitement classique des données
 XML est devenu LA représentation dominante pour les

données sur le Web
 C’est la base pour l’envoie et la récupération de données
pour les applications distribuées Client-Serveur
 C’est une réponse pour toutes sortes de transactions du
moment que les deux parties se mettent d’accord sur le
balisage à adopter.
– un effort considérable pour la définition de standards à base de
XML
– des mécanismes pour la traduction des tags telles que
 RDF (Ressource Description Framework) pour définir des meta-tags
 XSL (eXtensible Stylesheet Language) pour traduire des tags XML en
d’autres tags XML
30
Programmation dirigée par les
documents
 Une des utilisations principales d’XML est de construire des

documents qui décrivent la structure d’une application ou d’une
partie de l’application.
– Le document contient des références à des interfaces utilisateur et à des
composants logiciels qui sont assemblés pour créer une partie de
l’application "on-the-fly" via de la génération de code.
 Configurer les éléments du middleware: containers, serveur,

services de support…
 Combiner une utilisation d’XML et du langage Java est une

bonne option permettant la portabilité de l’application.
31
Construisons un
document XML
32
Un simple fichier XML
 Nous utilisons un exemple simple de

présentation par slides
 Nous pouvons utiliser n’importe quel éditeur
(e.g. Bloc-notes, vi, emacs…)
 Créer un fichier presentation.xml
33
La déclaration
 Coder le déclaration qui identifie le fichier comme un fichier
XML:
– <?xml version='1.0' encoding='utf-8'?>
– Cette ligne identifie le document comme un document XML
conforme à la version 1.0
– Elle spécifie qu’elle utilise le schéma 8-bit Unicode pour
l’encodage
– Le document n’est pas spécifié comme étant standalone, le parser
peut prendre en compte des références à des documents externes
 Ajouter un commentaire:
– Par défaut, les commentaires sont ignorés par les parseurs
– <?xml version='1.0' encoding='ISO-8859-1'?>

34
L’élément racine
 Après la déclaration, chaque document XML définit exactement
un seul élément appelé élément racine (root element)
 Tous les autres éléments sont contenus dans l’élément racine

<presentation>
</presentation>
– Les noms des tags sont sensibles à la case (case sensitive), le tag
de fin doit exactement correspondre au tag de début.
35
Introduction des attributs
 Une présentation possède certaines propriétés. Il est
plutôt naturel de les définir comme des attributs plutôt
que comme des sous éléments

<presentation
titre= "Ma presentation"
date= "aujourd hui"
auteur= "votre serviteur"
>
</presentation>
– Pour les noms des attributs, il est possible d’utiliser toute combinaison
de chiffres et de lettres en plus de -, _, :, et du point
– Les attributs sont toujours entre guillemets, et ne sont jamais séparés
par des virgules (comme HTML)
36
Ajout d’un élément imbriqué
 Les données XML sont structurés de manière hiérarchique. Un élément
donné peut être contenu dans un autre élément
 Définissons maintenant l’élément slide contenu dans l’élément racine
presentation.
<presentation
date= "aujourd’hui"
>

<slide type="all">
<titre> XML, les bases </titre>
</slide>
</presentation>
37
Ajouter du texte du style HTML
 XML, permet de définir des tags et de leur associer les noms de manière
libre
 Il est donc possible d’utiliser des tags HTML dans un fichier XML
<presentation
>
<slide type="all">
</slide>

<slide type="all">
<titre> Plan du cours </titre><br/>
<item> <em> Introduction aux bases </em> </item><br/>
38 <item> <em> Construisons un document XML </em> </item><br/> </slide>
</presentation>
Les caractères spéciaux
 Dans XML, une entité est une structure XML ou tout
simplement du texte qui possède un nom.
 Référencer une entité a pour effet de bord de
l’insérer dans le document à la place de la référence
– Un nom d’entité est référencé de la façon suivante:
&nomEntité;
 Il existe des entités prédéfinies pour les caractères
spéciaux.
 Il est aussi possible de définir de nouvelles entités
(voir la partie DTD)
39
Les entités prédéfinies
– <?xml version='1.0' encoding=' ISO-8859-1'?>

 Caractère Référence
<presentation
date= "aujourd’hui" & &
> < <
<slide type="all"> > >
</slide> " "
<slide type="all"> ‘ '
<titre> <Plan du cours> </titre>
<item> <em> Introduction aux bases </em> </item>
<item> <em> " Construisons un document XML " </em>
</item>
40 </slide>
</presentation>
Les références de caractères
 Il est possible de référencer un caractère par sa valeur Unicode
(137 468 caractères pour la version 4.1)
 Dans ce cas le nom de l’entité référencée est # suivi de la
valeur Unicode (en décimal)
– Utiliser la forme &#ValeurUnicode;
– e.g. -A-
– est interprété comme -A-
 Les valeurs Unicode sont publiées sur
http://www.unicode.org/charts
– Elles sont exprimées en Hexadecimal (il faut faire la conversion en
décimal avant de les utiliser)
41
Exemple d’utilisation des valeurs
unicode
<?xml version='1.0' encoding='utf-8'?>

<presentation
auteur= "votre serviteur" >
<slide type="all">
</slide>
<slide type="all">
<item> <em> -A- Introduction aux bases </em> </item>
<item> <em> -B- " Construisons un document XML "
</em> </item>
42 </slide>
</presentation>
Insertion de zones texte dans un
document XML
 Dans le cas d’insertion de gros blocs de texte avec

plusieurs caractères spéciaux, utiliser le références
d’entités devient très lourd
 XML offre un moyen pour insérer le texte tel quel
– Utiliser des sections CDATA
 Les espaces blancs deviennent significatifs
 Les caractères spéciaux ne sont pas interprétés comme du
code XML
– Une section texte commence par <![CDATA[
– Elle se termine par ]]>
43
Exemple de section texte
– <?xml version=‘1.0 encoding=‘utf-8’?>
<presentation
>
<slide type="all">
</slide>
<slide type="all">
<item> <em> A- Introduction aux bases </em> </item>
<item> <em> B- " Construisons un document XML " </em> </item>
<item><![CDATA[Un petit croquis: coin gauche ----- < Milieu> -----
coin droit
]]>
</item>
</slide> </presentation>
44
Exercice
45
Énoncé
 Structurer les informations contenues dans le texte suivant:
Une bouteille d’eau Cristaline de 150cl contient par litre 71mg d’ions positifs clacium, et
5,5mg d’ions positifs magnésium. On y trouve également des ions négatifs comme des
chlorures à 20 mg par litre et des nitrates avec 1mg par litre. Elle est recueillie à St-Cyr la
source, dans le département du loiret. Son code barre est 3270800 et son PH est de 7,45.
Comme la bouteille est sale, quelques matériaux comme du Fer s’y trouvent en
suspension.
Une seconde bouteille d’eau Cristaline a été recueillie à la source d’Aurèle dans les Alpes
Maritimes. La concentration en ions de calcium est de 98 mg/l, et en ions magnésium de 4
mg/l. Il y a 3,6 mg/l d’ions de chlorure et 2mg/l de nitrates, pour un PH de 7,4. Le code
barre de cette bouteille de 50 cl est 3266006.
Une bouteille de même contenance est de marque Volvic, a été puisée à Volvic bien connu
pour ses sources donnant un PH neutre de 7. Elle comprend 11,5 mg/l d’ions calcium,
8.0mg/l d’ions magnésium, 13,5mg/l d’ions chlorure et 6,3mg/l d’ions nitrates. Elle contient
également des particules de silice. Son code barre est 33045798. En fait, Volvic est dans le
46 Puy-de-Dôme
Une solution
<?xml version="1.0" encoding="ISO-8859-1" ?>
<eau>
<bouteille>
<marque>Cristaline</marque>
<composition>
<ion type="positif">calcium 71mg/l</ion>
<ion type="positif">magnésium 5,5mg/l</ion>
<ion type="negatif">chlorure 20mg/l</ion>
<ion type="negatif">nitrate 1mg/l</ion>
<autre type="metal">fer</autre>
</composition>
<source>
<ville>St-Cyr la Source</ville>
<departement>Loiret</departement>
</source>
<code_barre> 3270800 </code_barre>
<contenance unit="cl">150</contenance>
<ph>7,45</ph>
</bouteille> ….
47
Modélisation des
documents:
Les DTDs
48
Une DTD,
Ça sert à quoi?
 Une DTD (Document Type Definition) permet de

définir son propre langage basé sur XML (d’où la
notion de meta-langage)
 Elle spécifie
– Le vocabulaire du langage:
 Les balises
 Les éléments
 Les attributs
– La grammaire du langage
 Les imbrications correctes des éléments
49
Le concept de validité d’un document
XML
 Un document bien formé possède les

caractéristiques suivantes
– Le document possède un élément racine unique
– Un attribut est unique dans son élément
– Les balises doivent être correctement imbriquées
– Les éléments vides peuvent utiliser une notation spécifique
– Les guillemets sont obligatoires pour associer une valeur à
un attribut
 Un document valide est un document:
– Bien formé
– Conforme à la DTD qui lui est associée
50
Exemples,
Qu’est-ce que vous en pensez?
<?xml version="1.0" encoding="iso-8859-1"?>

<titre>Exemple1</titre>
<sous-titre>Je le pense pas bon</sous-titre>
<texte> Je pense car …</texte>

<Exercice>
<evaluateurs nom="etudiant1" nom="etudiant2" nom="etudiant3" />
</Exercice>

<Exercice>
<evaluateurs>
<evaluateur nom="etudiant1"/>
<evaluateur nom="etudiant2"/>
<evaluateur nom="etudiant3" />
51 </Evaluateurs>
</Exercice>
Déclaration d’éléments simples dans
une DTD
 Déclaration sous la forme:

– <!ELEMENT balise (sa définition)>
– Le paramètre "sa définition" correspond à
 Un type de données prédéfini
 Ou à un élément de données composé constitué lui-
même d’éléments
– Les types prédéfinis
 ANY: l’élément peut contenir tout types de données
 EMPTY: l’élément ne contient pas données
 #PCDATA: l’élément contient une chaîne de caractère
– Exemple: <(!ELEMENT Institution (#PCDATA)>
– <Institution> EHTP </Institution>
52
Déclaration d’éléments composés
 Le contenu d’une balise est défini par une

combinaison de séquences et de choix d’éléments
 Syntaxe utilisant des opérateurs de composition:

Opérateur Action Exemple
+ L’élément doit être présent au minimum une fois E+
* L’élément peut être présent plusieurs fois E*
? L’élément est facultatif E?
| Un des deux éléments doit être présent (pas les deux) E1 | E2
, Le premier élément doit être présent et doit être suivi par le deuxième E1,E2
() Les parenthèses permettent de regrouper des compositions d’éléments (E1 I E2)*
53 afin de leur appliquer d’autres opérateurs
Exemple
 <!ELEMENT personne(nom,prenom+,tel?,adresse)>
<!ELEMENT nom(#PCDATA)>
<!ELEMENT prenom(#PCDATA)>
<!ELEMENT tel(#PCDATA)>
<!ELEMENT adresse (ANY)>
 <personne>
<nom> guennoun </nom>
<prenom> mohammed </prenom>
<prenom> karim </prenom>
<tel>06 48 62 ** **</tel>
<adresse>
<numéro> 1</numéro>
<rue> ****</rue>
<ville> Casablanca </ville>
</adresse>
54 </personne>
Déclaration d’attributs
 Déclaration sous la forme:
– <!ATTLIST balise attribut type mode>
– Balise: fait référence à l’élément auquel est rattaché l’attribut
– Attribut: correspond au nom de l’attribut déclaré
– Type: correspond au type de données associées à l’attribut
 CDATA: chaîne de caractères entre guillemets
 Liste de valeurs ‘(v1|v2|v3)’: énumération
 ID et IDREF: clé et référence à clé
– mode précise le caractère obligatoire ou non de l’attribut
 #REQUIRED: la valeur de l’attribut doit être spécifiée dans le
document
 #IMPLIED: La valeur n’a pas besoin d’être spécifiée. Si elle ne l’ai
pas, généralement l’application utilise une valeur par défaut
 #FIXED "uneValeur" : La valeur de l’attribut est fixée à cette valeur
pour tout le document
55
Exemple
<!ELEMENT auteur (#PCDATA) >

<!ELEMENT editeur (#PCDATA) >
<!ATTLIST auteur
genre (Masculin | Feminin ) #REQUIRED
ville CDATA #IMPLIED>
<!ATTLIST editeur
ville CDATA #FIXED "Casablanca">
56
Exemple de DTD
<!ELEMENT DOCUMENT(PERSONNE*)>
<!ELEMENT PERSONNE (#PCDATA)>
<!ATTLIST PERSONNE PNUM ID #REQUIRED>
<!ATTLIST PERSONNE MERE IDREF #IMPLIED>
<!ATTLIST PERSONNE PERE IDREF #IMPLIED>
57
DTD interne
 Spécifiée en utilisant la déclaration:
<!DOCTYPE nomDeLaDTD [ déclarations ]>
 Exemple:
<?xml version="1.0" standalone="yes"?>
<!DOCTYPE PERSONNES [
<!ELEMENT DOCUMENT(PERSONNE*)>
<!ELEMENT PERSONNE (#PCDATA)>
<!ATTLIST PERSONNE PNUM ID #REQUIRED>
<!ATTLIST PERSONNE MERE IDREF #IMPLIED>
<!ATTLIST PERSONNE PERE IDREF #IMPLIED> ]>
<PERSONNES>
<PERSONNE PNUM = "P1">Fatima</PERSONNE>
<PERSONNE PNUM = "P2">Ali</PERSONNE>
<PERSONNE PNUM = "P3" MERE="P1" PERE="P2">Adam</PERSONNE>
<PERSONNE PNUM = "P4" MERE="P1" PERE="P2">Rime</PERSONNE>
</PERSONNES>
58
DTD externe (arrêt)
 Modèle pour plusieurs documents

– partage des balises, attributs et structures
 Définition locale ou externe

– Locale: <!DOCTYPE doc SYSTEM "doc.dtd">
– Externe: <!DOCTYPE doc PUBLIC
"www.myweb.com/doc.dtd">
 Exemple de document
<?xml version="1.0" standalone="no"?>
59 <!DOCTYPE modeles SYSTEM "modeles.dtd">
Encore un petit exercice
 On se propose de définir un format XML de stockage
d’un catalogue de films sur DVD.
 Le catalogue comprend un ensemble de fiches de
films
 Chaque fiche comprend:
– Un numéro unique
– Le titre du film
– Sa date de sortie
– Un ou plusieurs réalisateurs
– Les acteurs principaux
– Le genre du film (comédie, horreur, action, aventure) (en
option)
– Un commentaire optionnel qui présente brièvement
60 l’histoire du film
– Un lien éventuel vers le site du film
Insuffisances des DTD
 Pas de types de données à part du texte

(#PCDATA)
 Expression de cardinalités limitée
– ‘?’, ‘*’ et ‘+’
 Syntaxe spécifique (pas XML)
– difficile à interpréter
– difficile à traduire en schéma objets
 Alternative:
61 – XML-schema du W3C
Les schémas XML
62
Schéma XML
 Un schéma d'un document définit:

– les éléments possibles dans le document
– les attributs associés à ces éléments
– la structure du document et les types de données
 Le schéma est spécifié en XML
– pas de nouveau langage
– balisage de déclaration
– utilise un espace de nom xs:
 Présente de nombreux avantages
– types de données personnalisés
– extensibilité par extension et restriction
– analysable par un parseur XML standard
63
Objectifs
 Reprendre les acquis des DTD

– Plus riche et complet que les DTD
 Permettre de typer les données
– Éléments simples et complexes
– Attributs simples
 Permettre de définir des contraintes
– Existence obligatoire ou optionnelle
– Domaines de valeurs, cardinalités,
– ...
 Respecter la vision XML
– Syntaxe XML
64
Les éléments du schéma
 La base d’un schéma XML:

– l’élément de données
 Un élément peut avoir un type:
– Simple: une balise qui ne contient aucun attribut et dans laquelle
aucune autre balise n'est imbriquée.
– Complexe s’il contient des sous éléments ou s’il comporte un
attribut
 Les sous éléments peuvent être déclarés:
– xs:all tous les éléments doivent exister (peu importe l’ordre)
– xs:choice un des éléments doit exister
– xs:sequence tous les éléments doivent exister dans l’ordre spécifié
65
Les types considérés par les
schémas XML
 Les schémas distinguent plusieurs types :

– Types simples (#PCDATA ou feuille de l'arbre)
 Types de base ou primitifs (entier, chaîne, ...)
 Types simples définis :
– par restriction d'un type simple,
– Types complexes (nœuds de l'arbre) définis

 par construction,
 par restriction d'un type complexe,
 par extension
66
Les types simples
 string  date
– La vie est belle! – 1999-05-31
 byte  ID
– 1, 126 – "A212"
 integer  IDREF
– -126789, -1, 0, 1, 126789 – "A212"
 positiveInteger  IDREFS
– 1, 126789 – "A212" "B213"
 negativeInteger  anyURI
– -126789, -1 – http://www.example.com/e1.html#5
 int  language
– 1, 126789675
– en-GB, en-US, fr-FR
 unsignedInt  dateTime
– 0, 1267896754
– 1999-05-31T13:20:00.000
 boolean
 …
– true, false, 1, 0
Exemple: <xs:element name="NomBalise" type="xs:TypeSimple" />

67
Les types simples par restriction
 Un type simple peut provenir de la restriction d'un

type de base
 <xs:simpleType name="poids">
<xs:restriction base="xs:int">
<xs:minInclusive value='100'/>
</xs:restriction>
</xs:simpleType>
 Ou d’un autre type simple:
 <xs:simpleType name="poids2">
<xs:restriction base="poids">
<xs:maxInclusive value='200'/>
</xs:restriction>
68
</xs:simpleType>
Les facettes
 Les facettes sont des restrictions de types simples:

 <xs:minInclusive value='valeur'/>
 <xs:minExclusive value='valeur'/>
 <xs:maxInclusive value='valeur'/>
 <xs:maxExclusive value='valeur'/>
 Une énumération est possible
<xs:restriction base="xs:string">
<xs:enumeration value='rouge'/>
<xs:enumeration value='noir'/>
<xs:enumeration value='bleu'/>
</xs:restriction>
69
Les types complexes
 Définition d'objets complexes
– <sequence> : collection ordonnée d'éléments typés
– <all> : collection non ordonnée d'éléments typés
– <choice>: choix entre éléments typés
 Exemple
<xs:element name="Film">
<xs:complexType>
<xs:sequence>
<xs:element name="titre" type="xs:string"/>
<xs:element name="réalisateur" type="xs:string"/>
<xs:element name="DateSortie" type="xs:date"/>
<xs:element name="nombreEntrées" type="xs:int"/>
</xs:sequence>
</xs:complexType>
70 </xs:element>
Le nombre d’occurences
 Dans un schéma, il est aussi possible de

contraindre le nombre d’occurrences d’un
élément dans un autre
– La syntaxe: minOccurs/maxOccurs
– Exemple:
<xs:element name="catalogueFilms">
<xs:complexType>
<xs:sequence>
<xs:element name="Film" minOccurs="1" maxOccurs="unbounded
</xs:sequence>
</xs:complexType>
71 </xs:element>
Déclaration des attributs
 Pour les types simples:

– Extension du type simple par l’attribut
<xs:complexType>
<xs:extension base="xs:string">
<xs:attribute name="referenceInterne" type="xs:positiveInteger"/>
</xs:extension>
</xs:complexType>
 La déclaration suivante est conforme à ce

schéma:
72 – <titreFilm referenceInterne="12345"> Pulp Fiction</titreFilm>
Déclaration des attributs
 Pour les éléments à contenu complexe

– Définition à l’intérieur de la balise xs:complexType
<xs:element name="sousTitrage" minOccurs="0" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="auteur" type="xs:string" minOccurs="1" maxOccurs= "unbounded"/>
</xs:sequence>
<xs:attribute name="langue" use="required" type="xs:string"/>
<xs:attribute name="date" use="optional" type="xs:date"/>
</xs:complexType>
</xs:element>
 La déclaration suivante est conforme à ce schéma

<sousTitrage langue="francais">
<auteur> La société francaise de traduction </auteur>
73 </sousTitrage>
Fichier de stockage d’un schéma
XML
 Comme tout fichier XML

– Présence du prolog
– Une balise racine
 Sinon:
– Extension: xsd
– Balise racine imposée:
 <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 Pour référencer un schéma xml, il faut le faire au niveau de la
balise racine
– <racine xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="chemin_vers_fichier.xsd"> </racine>
74
Schéma Vs DTD
 Les DTD définissent la grammaire des

documents
 Elles sont de plus en plus souvent remplacées
par des schémas
– Typage plus rigoureux (autre que du texte #PCDATA)
– Cardinalité plus expressive (minOccurs/maxOccurs)
– Syntaxe XML
 + facile à interpréter
 + facile à transformer en Objets
75
Le même exercice
 On se propose de définir un format XML de stockage
d’un catalogue de films sur DVD.
 Le catalogue comprend un ensemble de fiches de
films
 Chaque fiche comprend:
– Un numéro unique
– Le titre du film
– Sa date de sortie
– Un ou plusieurs réalisateurs
– Le genre du film (comédie, horreur, action, aventure) (en
option)
– Un commentaire optionnel qui présente brièvement
l’histoire du film
76 – Un lien éventuel vers le site du film
Programmation XML
77
Bridging the gap,
XML et l’orienté-objet
 Comment résoudre le problème de la distance entre

XML et les programmes objets?
 Les services sont souvent programmés en langage
objet: Java, C++, C#,
– Pour les échanges à base de messages XML,
 Les traiter et les analyser (parser)
 Les traduire en objets
 JAXP: Java Api for Xml Processing
– Traitement des données XML par des
applications codées en Java
78
JAXP: SAX, DOM, XSLT
 Trois technologies s’offrent à nous pour analyser, traiter

et transformer les documents XML :
– SAX, une API événementielle qui lit de manière séquentielle (du
début à la fin) un document XML et exécute des méthodes
correspondant aux différents éléments du document
– DOM, une API basée sur une modélisation objet des documents
XML avec des classes et des méthodes permettant le parcours et
la manipulation des arbres XML
– XSLT, une norme W3C basée sur XML, décrivant une
transformation par le biais de règles appliquées aux différents
nœuds de l’arbre XML.
79
L’API JAXP
 JAXP
– https://docs.oracle.com/javase/8/docs/technotes/guides/xml/jaxp/index.html
– Couche d’abstraction de SAX, DOM et XSLT indépendante de l’implémentation
– XML et JAVA = un couple parfait
 SAX (Simple API for XML)
– Développement communautaire
 DOM (Document Object Model)
– Recommandation W3C, http://www.w3.org/DOM/
 Transform, basé sur XPATH et XSLT
– Recommandations W3C, http://www.w3.org/TR/xpath/ et
http://www.w3.org/TR/xslt
80
L’API JAXP
 Les APIs principales JAXP sont définies

dans le package javax.xml.parsers
 Ce package contient les classes usines:
– SAXParserFactory: produit des parsers SAX
– DocumentBuilderFactory: produit des
constructeurs de document
– TransformerFactory: produit des transformateurs
XSLT
81
Les différents Packages
 Les API SAX, DOM et transform sont définies avec les

librairies suivantes:
– javax.xml.parsers: l’API JAXP
 Définit une interface commune à tout les vendeurs de parseurs SAX,
DOM, et transform
– org.w3c.dom:
 Définit la classe ‘Document’ (DOM) et les classes de ses composants
– org.xml.sax:
 Définit l’API SAX basique
– javax.xml.transform:
 Définit les APIs pour XSLT (transformations génériques ou avec
feuilles de style)
82
Le parseur SAX
83
L’API SAX
 Modèle simplifié d'événements
 Types d'événement :
– début et fin de document ;
– début et fin d'éléments ;
– attributs, texte, …
 Parcours séquentiel des éléments du document
 Mécanisme généralement utilisé par les servlets et les
programmes qui échangent des documents XML sur un réseau
– Plus rapide
– Moins gourmant en mémoire (traitement en flux, pas de représentation
interne des données comme pour DOM)
84
Fonctionnement de l’API basée
événements
start document
start element: bouteille
start element: marque
<?xml version="1.0"?>
characters: Cristaline
<bouteille> ……
<marque>Cristaline</marque> end element: marque
<source> St-Cyr la Source </source> start element: source
</bouteille> characters: St-Cyr la source
……
end element: source
end element: bouteille
end document
85
La manufacture de parseurs SAX
 JAXP offre une manufacture pour la création de

parseurs SAX
– Classe SAXParserFactory dans le package javax.xml.parsers
– La méthode statique newInstance permet d’en créer une
instance
 SAXParserFactory fact= SAXParserFactory.newInstance();
 La manufacture permet de créer des instances du
parseur SAX
– SAXParser SP = fact.newSAXParser();
86
Le parseur SAX
 Traite un fichier XML en faisant appel à la

méthode ‘parse’
 SP.parse(fichier,handler)
– fichier: le fichier xml à parser
– handler: la classe qui implémente les traitements
des événements de parcours du fichier en
héritant de l’interface ContentHandler
87
L’interface ContentHandler
 L’API SAX intègre l’interface ContentHandler

permettant de
– Parcourir le document séquentiellement
– Lever des événements d’analyse
 Début / Fin du documents
 Début / Fin d’éléments
 Zones textes
– Exécuter une méthode de traitement, pour
chaque événement
88
Méthodes de traitement
 La façon la plus simple d’implémenter l’interface

ContentHandler est d’hériter de la classe
DefaultHandler
 La classe DefaultHandler
– Fait partie du package org.xml.sax.helpers
– Définit les méthodes de traitement
 startDocument / endDocument
 startElement / endElement
 Characters …
– Les traitements correspondent à ne rien faire (les méthodes
sont vides)
89
Méthodes de traitement: début et fin
de documents
 Les méthodes de traitement principales sont déclarés

dans la classe DefaultHandler avec les signatures
suivantes:
– public void startDocument()
 Réception de la notification du début du document
 Le parsseur SAX exécute cette méthode une seul fois avant toutes
les autres
 Lève l’exception : SAXException
– public void endDocument()
 Réception de la notification de fin de document
 La dernière méthode exécutée par le parseur
 Lève l’exception SAXException
90
Méthodes de traitement: début et fin
d’éléments
– public void startElement(String uri, String localName, String qName,

Attributes atts)
 Reçoit la notification du début d’un élément
 Invoquée par le parseur au début de chaque élément
 Les paramètres de la méthode
– uri: la URI de l’espace de nommage, chaîne vide si aucun n’est spécifié
– localName: nom local
– qName: nom qualifié
– atts: les attributs attachés aux éléments
 Lève l’exception SAXException
– public void endElement(java.lang.String uri, java.lang.String localName,
java.lang.String qName)
 Reçoit la notification de la fin d’un élément
 Même sémantique des paramètres que pour startElement
91
Méthodes de traitement: parcours de
la liste des attributs.
 Pour le parcours des attributs d’un élément, la classe

Attributes offre les méthodes
– int getLength(): renvoie un entier (de type int) indiquant le nombre
des attributs de l’élément
– String getLocalName(int i):
 Renvoie le nom (de type String) d’un attribut local.
 Renvoie "" si l’attribut n’est pas local
– String getQName(int i):
 Renvoie le nom d’un attribut qualifié
 Renvoie "" si l’attribut n’est pas qualifié
– String getValue(int i):
 Renvoie la valeur de l’attribut (de type String)
92
Méthodes de traitement: les zones
de texte
 Pour le traitement des zones de texte, la classe

DefaultHandler offre la méthode characters:
– public void characters(char[] c, int start, int length)
 Reçoit la notification d’une chaîne de caractères
 Le parseur l’appelle pour renvoyer un morceau d’une chaîne de
caractères
 Possibilité de récupérer la valeur de la partie renvoyée en String
en faisant un appel
– String s = new String(c, start, length);
 Si besoin d’avoir la chaîne complète, il est nécessaire de
concaténer les morceaux envoyés par le parseur
93
Méthode de traitement des
instructions
 public void processingInstruction (String target,
String data)
– Reçoit la notification d’une instruction de traitement (<?cible
Traitement?>
– target: la chaîne correspondant à la cible
– Traitement : la chaîne correspondant aux traitements
– Exécutée à chaque rencontre d’une instruction de
traitement
– La ligne de déclaration xml est ignorée
– Lève l’exception SAXException
94
Faisons le ensemble
95
Le squelette du parseur
 Créer un fichier Echo.java

– Un méthode main qui prendra en argument le
nom du fichier XML sur la ligne de commande
public class Echo

{
public static void main(String argv[ ])
{
}
96
Les déclaration des ‘import’
 Importer les packages

import java.io.*;
// utilisé pour l’affichage du résultat
import org.xml.sax.*;
// définit les interfaces du parseur SAX
import org.xml.sax.helpers.DefaultHandler;
// utilisé pour définir le traitement des événements, par héritage
import javax.xml.parsers.SAXParserFactory;
// classe permettant de créer l’instance du parser
import javax.xml.parsers.ParserConfigurationException;
//Exception levée par la Factory si échec de création de l’instance du parseur
import javax.xml.parsers.SAXParser;
// Le type de l’instance créée par la factory
public class Echo
97 {….
Traitement de la ligne de commande
 Le fichier XML sera passé en commande, dans argv[0]. Introduire

le code suivant dans le main:
public static void main(String argv[])

{
if (argv.length != 1) {
System.err.println("entrer le nom du fichier en ligne de commande!");
System.exit(1);
}
try {
// Parsing du document XML
}
catch (Exception e) {
}
98 }
L’interface ContentHandler
 Interface avec les méthodes suivantes exécutées en réponse au

événement d’analyse:
– startDocument,
– endDocument,
– startElement,
– endElement,
– Characters
 La façon la plus simple d’implémenter cette interface est d’hériter de la
classe DefaultHandler
– Package: org.xml.sax.helpers
– toutes les méthodes sont vides
public class Echo extends DefaultHandler
{
...
99 }
Création de l’instance du parseur
{
System.err.println("entrer le nom du fichier en ligne de commande!");
System.exit(1);
}
// Création d’une instance la Factory
SAXParserFactory factory = SAXParserFactory.newInstance();
try {
// Parsing du document XML
// Création de l’instance parser

SAXParser saxParser = factory.newSAXParser();
// Initialisation du handler des événements

DefaultHandler handler = new Echo();
//Appeler l’analyse sur le fichier passé en commande

saxParser.parse( new File(argv[0]), handler );
10 } catch (Throwable t) {….
Traitement des événements de
parsing : début et fin des doc
public void startDocument() throws SAXException

{
//afficher le prolog du document
System.out.println("<?xml version='1.0' encoding='UTF-8'?>");
}
public void endDocument() throws SAXException

{
// rien à faire
}
….
10
parsing : début des éléments
public void startElement(String namespaceURI, String nsName, String qName,

Attributes attrs)
throws SAXException
{
String ElementName = nsName; // Le nom de l’élément
if (ElementName.equals("")) ElementName = qName; // pas d’espace de nommage
System.out.print("<"+ElementName);
int n=attrs.getLength() ;
if (n!= 0) {
for (int i = 0; i < n; i++) {
String aName = attrs.getLocalName(i); // Récupérer le nom de l’attribut
if (aName.equals("")) aName = attrs.getQName(i);
System.out.print(" ");
System.out.print(aName+"=\""+attrs.getValue(i)+"\"");
}
}
10 System.out.println(">");
}
parsing : fin des éléments
public void endElement(String namespaceURI,

String nsName, String qName
)
throws SAXException
{
String ElementName = nsName;
if (ElementName.equals("")) ElementName = qName;
System.out.println("</"+ElementName+">");
}
...
10
Traitement des caractères (arrêt)
public class Echo extends DefaultHandler

{
String text="";
public void endElement(...) …
public void characters(char buf[ ], int offset, int len)

throws SAXException
{
String s = new String(buf, offset, len);
text=text+s;
}
...
10
Afficher le contenu d’une balise à la
fin
 Après mise dans le buffer des caractères

contenus dans la balise
public void endElement(...)
throws SAXException
{
System.out.println(text);
text="";
String eName = sName; // element name
...
}
10
Afficher le contenu partiel de la
balise mère
 Exemple:
<bouteille>
Cette bouteille possède les éléments suivants
<marque>Cristaline</marque>…
 Il est nécessaire de vider le contenu du
buffer au début aussi
public void startElement(...)
throws SAXException
{
System.out.println(text);
text="";
String eName = sName; // element name
10 ...
}
Traitement des instructions
 Ajouter une instruction de traitement à votre fichier

xml
– <?InstructionDeTraitement echo?>
 Dans le code, implémenter la méthode
processingInstruction
public void processingInstruction(String target, String data) throws
SAXException
{
System.out.println("voici mon instruction de connexion");
System.out.println("target: "+target);
System.out.println("data: "+data);
10 }
Exécution
 Comme n’importe quelle application Java,

 Compiler la classe Echo.java
– javac Echo.java
 L’exécuter en donnant un fichier xml en ligne
de commande
– java Echo Bouteilles.xml
10
Quelques remarques
 Le parseur vérifie l’aspect bien formé du document. Il

lève des exceptions dans le cas contraire
– Introduire des erreurs de type document mal formé
– Remarquer le traitement séquentiel du document
 Les tags vides de type <balise/> sont affichés sous
la forme <balise></balise>
– Ajouter une balise vide
10
Traitements spécifiques
 Modifier le code des méthodes de traitement du

parseur SAX pour:
– Afficher exclusivement les marques des bouteilles
– Afficher les marques et les sources des bouteilles (sous la
forme: ville, departement)
– Afficher la marque de la bouteille qui possède le plus haut
niveau de magnésium ainsi que la valeur correspondante
– Afficher la marque qui possède le plus bas niveau de nitrate
– Afficher la valeur moyenne des niveaux de magnésium et de
nitrate pour toutes les bouteilles référencées dans le document
XML
11 – Selon l’instruction de traitement du document (tout, ou
marque), afficher tout le document ou seulement les marques.
Document Object Model
L’API DOM
11
DOM: Document Object Model
 Standard W3C fait pour HTML et XML

 Structure d'objets pour représenter un document
– Résultat d'un "parser"
– Produit par construction
 Interface objet pour naviguer dans un document
– Orientée objet
– Peut être utilisée en:
 Java, C++
 C#, VB
 PHP
11
Utilisation de DOM
 A partir d’un document XML, un Document

XML
parseur DOM permet de générer
un objet structuré en arbre
représentant le document Parseur
DOM
 À Travers l’API DOM, l’application
peut parcourir et agir sur ce
document Arbre DOM
API DOM
Application
11
Transformation d’un document
XML en un objet DOM
 L’API DOM permet

– De parser un document xml afin de générer le
DOM qui le représente
– Manipuler l’objet obtenu en agissant sur les
nœuds de l’arbre DOM
 créer,
 modifier,
 supprimer,
 réarranger
11
Structure de l’objet DOM
Document
<?xml version="1.0" ?> Inst1,T C bouteille

<?instr1 T?>

<bouteille type="bouteille d'eau" >
<marque>Cristaline</marque>
type, bouteille marque source
<source> St-Cyr la Source </source> d’eau
</bouteille>
Cristaline St-Cyr..
11
Déclaration d’un DOM
 La classe org.w3c.dom.Document
correspond à un objet DOM
 Un objet Document peut être
– Obtenu comme résultat du parsing d’un fichier
xml
– Construit en utilisant l’API dom
11
La manufacture de parseurs DOM
parseurs DOM
– DocumentBuilderFactory dans le package javax.xml.parsers
– La méthode newInstance permet d’en créer une instance
 DocumentBuilderFactory fact=
DocumentBuilderFactory.newInstance();
 La manufacture permet de créer des instances du
parseur DOM
– DocumentBuilder builder = fact.newDocumentBuilder();
11
Le parseur DOM
 Traite un fichier XML en faisant appel à la

méthode ‘parse’
 builder.parse(fichier)
– fichier: le fichier xml à parser
– Renvoie, en retour, un objet de type
org.w3c.dom.Document
11
L’interface Document
 Hérite de l’interface Node

 Représente le document parsé
 Donne accès
– Aux commentaires
– Aux instructions de traitement
– au nœud racine du document XML ou HTML
 A travers le nœud racine, il est possible
d’accéder aux autres nœuds de l’arbre DOM
11
L’interface mère: Node
 L’interface élémentaire pour les DOM

 Représente un nœud dans l’arbre de données d’un document XML
 Offre des méthodes pour
– Récupérer les valeurs du nœud ainsi que les attributs éventuels du nœuds
– Parcourir ses descendants
– Modifier l’arborescence
 Un nœud, possède le attributs:
– nodeType ( short getNodeType() )
– nodeName ( String getNodeName() )
– nodeValue ( String getNodeValue() )
– attributes ( NamedNodeMap getAttributes() )
12
L’interface mère Node: Le
type du noeud
 Une méthode permet de renvoyer le code représentant le type du

nœuds
– public short getNodeType()
 Un Node peut posséder les types suivants:
– public static final short ELEMENT_NODE 1
– public static final short ATTRIBUTE_NODE 2
– public static final short TEXT_NODE 3
– public static final short CDATA_SECTION_NODE 4
– public static final short ENTITY_REFERENCE_NODE 5
– public static final short ENTITY_NODE 6
– public static final short PROCESSING_INSTRUCTION_NODE 7
– public static final short COMMENT_NODE 8
– public static final short DOCUMENT_NODE 9
– public static final short DOCUMENT_TYPE_NODE 10
– public static final short DOCUMENT_FRAGMENT_NODE 11
12
Contenu des attributs par type de
noeud
Interface nodeName nodeValue Attributes

Attr nom de l’attribut Valeur de l’attribut null
CDATASection "#cdata-section" Contenu de la section null
Comment "#comment" contenu du null

commentaire
Document "#document" null null

Element Le nom du tag null NamedNodeMap
ProcessingInstruction Cible données null
Text "#text" contenu du nœud null

12 texte
Méthode de parcours de l’arbre:
ascendant et descendants
 Obtenir le père du nœud:

– public Node getParentNode()
– Renvoie null si le nœud n’a pas de père (e.g. document)
 Obtenir les fils d’un nœud:
– public NodeList getChildNodes()
– Renvoie la liste vide si le nœud n’a pas de fils
– Parcours en utilisant getLength et item
 Obtenir le premier fils du nœud
– public Node getFirstChild()
– Renvoie null si pas de fils
 Obtenir le dernier fils du nœud
– public Node getLastChild()
– null si pas de fils
12
Parcours de l’arbre: les frères
 Obtenir le grand frère (le précédent)

– public Node getPreviousSibling()
– Renvoie null si le nœud est le premier des fils
 Obtenir le frère suivant
– public Node getNextSibling()
– Renvoie null sui le nœud est le dernier des fils
 Cela permet de parcourir le DOM de plusieurs manières
– Une liste de fils
– Le premier fils, puis ces petits frères
– Le dernier fils puis ses grands frères
12
Modification de l’arbre (1/2)
 Tester si un nœud possède des fils

– public boolean hasChildNodes()
 Introduction d’un nouveau fils
– Création d’un élément: createElement(String tagName)
– public Node insertBefore(Node newChild, Node refChild)
– newChild doit être crée dans le document
– Si, refChild vaut null, le nœud est inséré à la fin
– Si, newChild est déjà dans le document, il est d’abord
supprimé
12
Modification de l’arbre: (2/2)
 Remplacement d’un fils

– public Node replaceChild(Node newChild, Node oldChild)
– Si newChild est dans le document, il est d’abord supprimé
 Introduction d’un fils à la fin

– public Node appendChild(Node newChild)
 Suppression d’un fils

– public Node removeChild(Node oldChild)
12
Interface pour les Attributs
 Les attributs sont aussi des Node

 Pour un Node de type Element
– NamedNodeMap getAttributes(), permet de renvoyer la liste
des attributs
 L’interface NamedNodeMap offre les méthodes
– int getLength(), pour récupérer le nombre des attributs
– Node item(int i), pour récupérer le ième attributs
– String getNodeName(), pour récupérer le nom de l’attribut
– String getNodeValue(), pour récupérer sa valeur
12
Démonstration
12
Squelette du programme
public class DomEcho {

{
System.out.println("passer le nom du fichier");
System.exit(1);
}
}// main
}// DomEcho
12
Les imports
 Les APIs JAXP
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.FactoryConfigurationError;
 Les exceptions
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import java.io.IOException;
 La définition w3c
import org.w3c.dom.Node;
import org.w3c.dom.Document;
import org.w3c.dom.DOMException;
 Lecture du fichier XML
import java.io.File;
13
Déclaration du DOM
public class DomEcho

{
static Document document;
{
….
13
Instanciation de la manufacture
 Création d’une instance de la manufacture de parseur

DOM:
{
...
}
DocumentBuilderFactory factory =
try {
…
13
Création du parseur
 A partir de la manufacture, on crée le parseur

 Le DOM est obtenu en faisant appel à la
méthode parse
try {
DocumentBuilder builder = factory.newDocumentBuilder();
document = builder.parse( new File(argv[0]) );
}
catch(Exception e)
{
System.out.println("erreur de parsing");
13 }
Exécution
 Compiler la classe EchoDom.java

– javac EchoDom.java
de commande
– java EchoDom bouteilles.xml
 Vous avez généré votre premier DOM!
13
Affichage du tag racine
 La méthode getDocumentElement() permet de

renvoyer l’élément racine d’un document xml (de
type org.w3c.dom.Element)
 La méthode getTagName() permet d’extraire le
nom de la balise d’un élément
 Rajouter le code:
Element e =document.getDocumentElement();
System.out.println(e.getTagName());
}
13
Exécution
 Compiler la classe EchoDom.java

de commande
13
Traitement d’un commentaire
 Un commentaire est un Node de type COMMENT_NODE

– getNodeName renvoie #comment
– getNodeValue renvoie le commentaire associé
 Introduire la méthode:
public static void traiterCommentaire(Node n)
{
if(n.getNodeType()!=Node.COMMENT_NODE)
{
System.out.println("la valeur de Type: "+n.getNodeType());
System.out.println("Le noeud ne correspond pas à un commentaire");
System.exit(1);
}
System.out.println("commentaire: "+n.getNodeValue());
13 }
Traitement des instructions
 Une instruction est un Node de type PROCESSING_INSTRUCTION_NODE

– getNodeName renvoie la cible
– getNodeValue renvoie les données
public static void traiterInstruction(Node n)
{
if(n.getNodeType()!=Node.PROCESSING_INSTRUCTION_NODE)
{
System.out.println("Le noeud ne correspond pas à une instruction");
System.exit(1);
}
System.out.println("Instruction :"+n.getNodeName()+ " "+n.getNodeValue());
13 }
Traitement d’une balise
 Une balise est un Node de type ELEMENT_NODE

– getNodeName renvoie le nom de la balise
– getNodeValue renvoie null
public static void traiterElement(Node n)
{
if(n.getNodeType()!=Node.ELEMENT_NODE)
{
System.out.println("Le noeud ne correspond pas à un element");
System.exit(1);
}
System.out.print("balise: ");
13 System.out.println(n.getNodeName());
Traitement d’un nœud texte
 Le texte contenu dans une balise est un Node de type TEXT_NODE

– getNodeName renvoie #text
– getNodeValue renvoie la chaine de caractères correspondant au texte
public static void traiterText(Node n)
{
if(n.getNodeType()!=Node.TEXT_NODE)
{
System.out.println("Le noeud ne correspond pas à du texte");
System.exit(1);
}
System.out.print("+ Text: "+n.getNodeValue());
14 }
Traitement des attributs (1/2)
 Les attributs d’un nœud (forcément de type

ELEMENT_NODE) sont récupérés via la
méthode:
– NamedNodeMap getAttributes();
 Un attribut est un Node de type
ATTRIBUTE_NODE
– getNodeName renvoie le nom de l’attribut
– getNodeValue renvoie sa valeur
14
Traitement des attributs (2/2)
public static void traiterListAttributs(Node n)
{
NamedNodeMap NNM=n.getAttributes();
Node m;
int l=NNM.getLength();
for (int i=0;i<l;i++)
{
m=NNM.item(i);
System.out.print("\n Attribut: "+m.getNodeName()+" = "+m.getNodeValue());
}
System.out.println("");
}
14
Traitement d’un nœud de l’arbre (1/2)
public static void traiterNoeud(Node n)
{
switch(n.getNodeType()) {
case Node.TEXT_NODE:
traiterText(n);
break;
case Node.COMMENT_NODE:
traiterCommentaire(n);
break;
case Node.PROCESSING_INSTRUCTION_NODE:
14 traiterInstruction(n);
Traitement d’un nœud de l’arbre (2/2)
case Node.ELEMENT_NODE:
traiterElement(n);
if(n.hasAttributes())
{
traiterListAttributs(n);
}
NodeList NL=n.getChildNodes();
for(int i=0;i<NL.getLength();i++)
{
traiterNoeud(NL.item(i));
}
break;
default: System.out.println("Type de nœud non pris en compte");
}
}
14
Traitement du document
 Le document est un Node de type DOCUMENT_NODE

– getNodeName renvoie #document
– getNodeValue renvoie null
 Donne accès à l’arborescence complète du dom
public static void traiterDocument(Node n)
{
NodeList NL=n.getChildNodes();
{
}
14 }
Parcours et affichage du DOM

{ ….
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
try {DocumentBuilder builder =factory.newDocumentBuilder();
//Element e =document.getDocumentElement();
//System.out.println(e.getTagName());
traiterDocument(document);
}
catch(Exception e)
{
System.out.println("erreur de parsing");
}
14
Exécution
 Recompiler la classe EchoDom.java

de commande
14
Exemple: Modification
de l’arbre DOM (1/2)
 Modifier l’arbre de dom

 Mettre le premier fils de l’élément racine en dernier
 Utiliser les méthodes
– getDocumentElement() pour récupérer la balise racine
– getFirstChild() pour récuprer le premier fils
– appendChild(Node) pour introduire un dernier fils
 Quand un nœud est déplacé tous ces fils sont
déplacés avec lui
14
Exemple:
Modification de l’arbre DOM (2/2)
 Modifier la méthode traiterDocument:

public static void traiterDocument(Document d)
{
Node n=d.getDocumentElement();
n.appendChild(n.getFirstChild());
NodeList NL=d.getChildNodes();
{
}
}
14  Recompiler et exécuter
A vous de jouer!
 Modifier le code pour:
– Afficher exclusivement les marques des bouteilles
– Afficher les marques et les sources des bouteilles (sous la forme:
ville, departement)
– Afficher la marque de la bouteille qui possède le plus haut niveau
de magnésium ainsi que la valeur correspondante
– Afficher la marque qui possède le plus bas niveau de nitrate
– Afficher la valeur moyenne des niveaux de magnésium et de
nitrate pour toutes les bouteilles référencées dans le document
XML
– Transformer le DOM pour trier les bouteilles par ordre croissant de
teneur en calcium
15
Algorithme de tri par selection
procedure triSelection(entier tab[ ])
variables i, k,posmin,tmp: entiers
pour (i de 0 à N-2 en incrémentant de 1) faire
/* recherche du numéro du minimum */
posmin <- i;
Pour (k de i+1 à N-1 en incrémentant de 1) faire
Si (tab[k] < tab[posmin]) alors posmin <- k;
finSi
finPour
/* échange des valeurs entre la case courante et le minimum */
tmp <- tab[i];
tab[i] <- tab[posmin];
tab[posmin] <- tmp;
finPour
15
L’API Transformer de JAXP
XPATH et XSLT
15
Plan
 Introduction du package javax.xml.transform

 Exemple: Transformations d’un DOM vers un
fichier XML
 XPATH
 XSLT
 Transformations à base de règles XSLT
15
Introduction au package
javax.xml.transform
15
Le package JAXP pour la
transformation
 Le package pour la transformation dans

JAXP:
– javax.xml.transform: package définissant
 La classe factory pour la génération des
transformateurs
 La classe des transformateurs
15
La manufacture des transformateurs

parseurs transformateurs
– TransformerFactory dans le package javax.xml.transform
– La méthode newInstance permet d’en créer une instance
 TransformerFactory fact=
TransformerFactory.newInstance();
 La manufacture permet de créer des instances de
transformateurs
– Transformer trans = fact.newTransformer();
– Transformer trans = fact.newTransformer(Source s);
15
Les transformateurs
 Transforment un arbre source vers un arbre

résultat en faisant appel à la méthode
transform
 trans.transform(Source in, Result out )
– in: l’élement à analyser de type Source
– out: l’élément résultant de la transformation de
type Result
– Renvoie void
15
Les packages Source et Result
 javax.xml.transform.dom: package définissant les classes

DOMSource et DOMResult permettant de transformer et
de générer des DOM
 javax.xml.transform.sax: package définissant les classes
SAXSource et SAXResult permettant d’utiliser un parser
SAX comme source ou de générer des événements SAX
en sortie pour un parser SAX
 javax.xml.transform.stream: package définissant les
classes StreamSource et StreamResult permettant
d’utiliser des fichiers comme source et sortie d’un
transformateur
15
L’interface Source
 Permet de définir l’arbre source à

transformer
 L’interface source est implémentée par les
classes suivantes:
– DOMSource: l’arbre source est un DOM
– SAXSource: l’arbre source est un SAX
– StreamSource: l’arbre source est un fichier
quelconque
15
La classe DOMSource
 DOMSource:
– Permet de définir un DOM comme source de la
transformation
– Constructeurs:
 DOMSource()
 DOMSource(Node n)
– Méthodes principales
 Node getNode()
 Void setNode(Node n)
16
La classe SAXSource
 SAXSource:
– Permet de définir un SAX comme source de la
transformation
– Constructeurs:
 SAXSource()
 SAXSource(InputSource IS)
 InputSource getInputSource()
 void setInputSource(InputSource IS)
16
La classe StreamSource
 StreamSource:
– Permet de définir un fichier comme source de la
transformation
– Constructeurs:
 StreamSource()
 StreamSource(File f)
 StreamSource(InputStream IS)
 InputStream getInputStream()
 Void setInputStream(InputStream IS)
16
L’interface Result
 Permet de définir l’arbre résultant de la

transformation
 L’interface Result est implémentée par les
classes suivantes
– DOMResult: l’arbre résultant est un DOM
– SAXResult: l’arbre résultant est un SAX
– StreamResult: l’arbre résultant est un fichier
quelconque
16
La classe DOMResult
 DOMResult:
– Permet de définir un DOM comme résultat de la
transformation
– Constructeurs:
 DOMResult()
 DOMResult(Node n)
 Node getNode()
 Void setNode(Node n)
16
La classe SAXResult
 SAXResult:
– Permet de définir un parseur SAX comme résultat
de la transformation
– Constructeurs:
 SAXResult()
 SAXResult(ContentHandler CH)
 ContentHandler getHandler()
 void setHandler(ContentHandler CH)
16
La classe StreamResult
 StreamResult:
– Permet de définir un fichier comme résultat de la
transformation
– Constructeurs:
 StreamResult()
 StreamResult(File f)
 StreamResult(OutputStream OS)
 OutputStream getOutputStream()
 Void setOutputStream(OutputStream OS)
16
Un programme simple:
Transformer un DOM pour
générer un fichier XML
16
Du DOM vers l’XML
 La méthode transform prend en paramètre

plusieurs types de sources et de résultats
 Une des utilisations utiles correspond à
transformer un DOM en un fichier XML pour
en afficher le contenu
 Dans ce cas
– Source correspondra à un type DOMSource
– Result correspondra à un type StreamResult
16
Squelette du programme
 Reprenons la classe DOMEcho en sa

première version
 Cette version permettait de générer un objet
DOM à partir d’un fichier XML
 Maintenant essayons de générer un fichier
XML avec le contenu de l’objet DOM obtenu
16
Rappelez-vous le premier code la
classe DOM Echo
 Les imports:
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.FactoryConfigurationError;
import org.xml.sax.*;
import org.w3c.dom.*;
import java.io.File;
import java.io.IOException;
17
Les imports
 Ajouter les imports pour le transformateur, le

type source et le type résultat:
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
17
Le code de la classe EchoDOM
public class EchoDOM{
{
System.err.println("passer nom du fichier XML en ligne de commande");
System.exit(1);
}
try {
DocumentBuilder builder =factory.newDocumentBuilder();
document = builder.parse( new File(argv[0]) );}
catch(Exception e){
System.out.println(e.getMessage());
System.exit(2); }}}
17
La classe Transform_DOM_XML (1/2)
public class Transform_DOM_XML{

{
System.err.println("passer le nom des fichiers source et résultat en ligne de
commande");
System.exit(1);
}
try {
17
La classe Transform_DOM_XML (2/2)
.......
// transformation du DOM
TransformerFactory TFactory = TransformerFactory.newInstance();
Transformer transformer = TFactory.newTransformer();
DOMSource source = new DOMSource(document);
StreamResult result = new StreamResult(new File(argv[1]));
transformer.transform(source, result);
}
catch(Exception e)
{
System.exit(2);
}}}
17
Exécution
 Compiler la classe Transform_DOM_XML

– javac Transform_DOM_XML.java
 Exécuter
– java Transform_DOM_XML bouteilles.xml
Resultat.xml
 Si tout va bien, bouteilles.xml et Resultat.xml
ont le même contenu
17
Transformer une branche d’un DOM
 Le constructeur de DOMSource prend en

paramètre un objet de type Node
– Node n;
– DOMSource DOMS= new DOMSource(n);
 Il est possible de transformer une branche
d’un DOM
 Permet de trier l’information contenu dans un
DOM
17
Reprenons la classe
Transform_DOM_XML
.......
// transformation du DOM
TransformerFactory TFactory = TransformerFactory.newInstance();
Transformer transformer = TFactory.newTransformer();
}
catch(Exception e)
{
System.exit(2);
}}}
17
Faisons une selection sur la
première bouteille
17
Exécution
 Compiler la classe Transform_FirstNode_XML

– javac Transform_FirstNode_XML.java
 Exécuter
– java Transform_FirstNode_XML bouteilles.xml
Resultat.xml
 Maintenant, Resultat.xml contient
exclusivement les éléments de la première
bouteille
17
Transformer et les
feuilles de style
18
La fonction transform avec une
feuille de style
 Précédemment, nous utilisions le

transformateur pour passer d’un
représentation à une autre (e.g. d’un DOM
vers un fichier XML) de manière générique
 Nous allons utiliser une feuille de style pour
spécifier les actions de transformation
18
La suite…
 Nous allons introduire dans la suite

– La recommandation XPATH
– La recommandation XSLT
 XSLT utilisant XPATH pour la navigation et la
sélection des nœuds d’un document XML,
nous allons commencer par introduire
XPATH
18
XPATH
18
XPATH (XML Path Language)
 XPATH est une recommandation W3C

 Utilise la représentation arborescente d’un
document XML
 Permet de
– Naviguer à travers ces nœuds
– Sélectionner des nœuds spécifiques en se basant
sur des critères de sélection
18
Les expression XPATH (1/3)
 Une expression XPATH est un patron

(pattern) permettant de sélectionner un
ensemble de nœuds XML
 XSLT utilise ces patrons pour appliquer les
transformations
18
Les expressions XPATH (2/3)
 Chaque expression est exprimée par rapport à un nœud

contexte
 Les étapes de localisation sont réalisées par rapport à ce
nœud
 Deux notations sont définies pour XPATH
– Syntaxe abréviée (Abbreviated syntaxe)
 Plus compacte, plus intuitive:
 /B1/B2/B3
– Syntaxe complète (full syntaxe)
 Plus verbeuse, plus complète:
 /child::B1/child::B2/child::B3
18
Les expressions XPATH (3/3)
 Afin d’affiner la sélection des nœuds XML

appartenant à ce chemin, XPATH permet de définir
des expressions avec des contraintes et des critères
de sélection
 Les expressions XPATH peuvent combiner:
– Des jokers (wildcards)
– Des opérateurs
– Des fonctions
18
Les nœuds XPATH
 XPATH prend en compte sept types de nœuds

– La racine
– Les éléments
– Le texte
– Les attributs
– Les commentaires
– Les instructions de traitement
– Les espaces de nommage
18
Eléments du chemin XPATH
 Pour la notation abréviée on peut retrouver les

éléments de chemin suivants:
– Le slash (/) constitue l’élément de séparation dans les
chemins
– Un chemin absolu commençant par la racine du
document, commence par un /
– Un chemin relatif commençant à partir d’un nœud
donné peut commencer par n’importe quoi
– “..” correspond au parent du nœud courant
– “.” correspond au nœud courant
18
Les attributs
 Les attributs sont spécifiés en utilisant la

syntaxe:
– balise1/@nomAttribut
– Exemple: /BOUTEILLES/bouteille/@couleur
19
Indexation et critères de sélection
 « [ ] » est utilisé pour

– Indexer les éléments
– Spécifier un critère de sélection
– Exemples
 /BOUTEILLES/bouteille[2]
 /BOUTEILLES/bouteille[@couleur="sans"]
– Possibilité de combiner les deux, exemples
 /BOUTEILLES/bouteille[@couleur="sans"][2]
19
Les jokers
 Les jokers considérés par XPATH

– « * » permettant de sélectionner tous les nœuds
éléments (tous les nœuds sauf les attributs et le texte)
– node() permettant de sélectionner tous les nœuds y
compris les attributs et le texte
– « @* » permettant de sélectionner tous les attributs
– Exemples
 /BOUTEILLES/*/marque
 /BOUTEILLES/*/*
19
Spécification de chemins avec
niveau d’imbrication indéterminé
 XPATH permet de spécifier des chemins

sans donner le niveau de hiérarchie pour
atteindre les nœuds
 « // » correspond à un niveau de hiérarchie
indéterminé
 Exemple
– /BOUTEILLES//ville
19
Types XPATH
 XPATH prend en compte les types suivants:

– Les ensembles de nœuds
– Les chaînes de caractères
– Les booléens
– Les valeurs numériques
19
Opérateurs XPATH
 XPATH prend en compte les opérateurs suivants:

– Opérateur de choix : « | »
 Exemple: /*//calcium|magnesium
– Les opérateurs or et and sur les booléens
 Exemple /BOUTEILLES/bouteille[@couleur="sans" or
@odeur="sans"]
– Les opérateurs « = » et « != »
– Les opérateurs <, >, <=, >=, +, -, *, div, mod sur les nombres
 Les parenthèses peuvent être utilisées pour éviter les
problèmes de précédence
19
Le texte
 Dans XPATH, le texte contenu dans un élément
(String-value) est la concaténation de tout le contenu
texte des balises filles
 Exemple:
– Pour le nœud
<source> La source:
<ville>St-Cyr la Source</ville>
<departement>Loiret</departement>
</source>
– Le String-value de source correspond à la chaîne de
caractères: La source:St-Cyr la SourceLoiret
19
Les fonctions XPATH
 La fonction text() permet d’obtenir le contenu texte d’un

nœud
– /BOUTEILLES//source/text()
 XPATH propose des fonctions de position
– last() permet d’indiquer le dernier élément
 /BOUTEILLES//source[last()]
– position() permet de renvoyer la position d’un élément
 /BOUTEILLES//source[position()<3]
– Count(b1) permet de renvoyer le nombre de fils portant le nom
b1
 /BOUTEILLES//source[count(ville)=1]
19
Les fonctions pour les chaînes de
caractères
 XPATH propose les fonctions suivantes

– concat(string, string, ...)
– starts-with(string1, string2)
– substring-before(string1, string2)
– substring-after(string1, string2)
– substring(string, idx)
– substring(string, idx, len)
– string-length(string)
19
Les fonctions booléennes
 not(exp1): renvoie la négation de l’expression

exp1
 true(): retourne vrai
 false(): retourne faux
 lang(langue)retourne vrai si la langue (définit
par l’attribut xml:lang correspond.
– Exemple : lang("fr") renvoie true pour le nœud
<bouteille xml:lang="fr">
19
Les fonctions numériques
 XPATH propose les fonctions numériques

– http://www.w3.org/TR/xpath-functions/#numeric-
functions
– sum(…)
– avg(…)
– abs(N): retourne la valeur absolue de N.
– round(r): retourne l’entier le plus proche de r.
20
Les fonctions de conversion
 Permet de transformer une donnée d’un type à un

autre
– string(...): retourne la valeur string d’un nombre, un booléen
ou un ensemble de nœuds
– boolean(...): retourne la valeur booléenne d’un nombre, un
string ou un ensemble de nœuds. (un nombre non nul, un
string ou un ensemble de nœuds non vides renvoient true
– number(...): retourne la valeur numérique d’un booléen (1
pour true et 0 pour false),
20
XSLT
20
eXtensible Stylesheet Language
Transformation
 XSLT, une recommandation W3C basée sur

XML
 Décrit une transformation par le biais de
règles appliquées à des nœuds particuliers
de l’arbre XML.
 Utilise XPATH pour la navigation et la
sélection des nœuds d’un document XML
20
Fonctionnement d’une
transformation XSLT (1/2)
 Une transformation XSLT est exprimée comme un
document XML
 Ce document contient des éléments appartenant à
l’espace de nom spécifique défini par le W3C
 Une transformation exprimée en XSLT décrit les règles
pour transformer un arbre source en un arbre résultat
 La transformation est obtenue en associant des motifs à
des modèles
– Les motifs sont appliqués aux éléments de l'arbre source
– Le modèle est instancié pour créer une partie de l'arbre résultat
20
Fonctionnement d’une
transformation XSLT (1/2)
 L'arbre résultat est distinct de l'arbre source

 La structure de l'arbre résultat peut être
complètement différente de la structure de
l'arbre source
 Pendant la construction de l'arbre résultat,
– des éléments de l'arbre source peuvent être filtrés
et réordonnés
– des structures arbitraires peuvent être ajoutées
20
XSLT et XPATH
 XSLT utilise le langage d'expression défini

par XPATH pour sélectionner les éléments à
traiter, les traitements conditionnels et la
génération de texte.
20
L’espace de nom XSLT
 Les processeurs XSLT doivent utiliser le mécanisme

des espaces de noms pour reconnaître les éléments et
les attributs de cet espace de noms
 L'URI de l'espace de noms XSLT est :
http://www.w3.org/1999/XSL/Transform
 Utilise le préfixe xsl: pour référencer les éléments de
l'espace de noms XSLT
 Liste des éléments de cet espace:
http://xmlfr.org/w3c/TR/xslt/#element-syntax-summary
20
Les templates XSLT
 Un template XSLT est un ensemble

d’instructions de formatage appliquées à des
nœuds sélectionnés par des expressions
XPATH
 Syntaxe:
<xsl:template match="un chemin XPATH">

Texte à générer…
</xsl:template>
20
Démonstration
20
Exemple didactique
 Expérimentons la méthode transform avec une feuille de

style
 Ceci permet de transformer un fichier XML en un fichier
XML, HTML, ou texte
 A la création de l’instance transformer, nous allons lui
passer une feuille de style pour le traitement des différentes
balises
 Exemple didactique: prendre notre document XML
bouteilles et générer un fichier HTML permettant d’afficher
et de présenter convenablement les informations
pertinentes
21
La fonction transform avec une
feuille de style
 Précédemment, nous utilisions le

transformateur pour passer d’un
représentation à une autre (e.g. d’un DOM
vers un fichier XML) de manière générique
 Nous allons utiliser une feuille de style pour
spécifier les actions de transformation
21
La feuille de style (1/2)
 Une feuille de style (extension xsl) est un document

XML
 Le nœud racine est xsl:stylesheet avec les attributs
obligatoires
– xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
– Version="1.0"
 Une balise <xsl:outputmethode="typeSortie"> définit
le type de document généré
– xml (par défaut), html, ou text
21
La feuille de style (2/2)
 Une feuille de style contient un ensemble de

templates à appliquer sur les différents nœuds
du document à analyser:
<xsl:template match="un chemin XPATH">
Texte à insérer
</xsl:template>
 Pour toutes les balises non capturées par un
template, le string-value correspondant est
générée
21
Une première feuille de style
 Dans un fichier nommé Style.xsl, introduire le

code suivant:
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">
</xsl:stylesheet>
 C’est la feuille de style minimale
21
Reprenons le code de la classe
Transform_DOM_XML
 A partir de cette classe, mettre à jour le code

pour définir la classe TransformXSLT
…
import javax.xml.transform.stream.StreamSource;
public class TransformXSLT{
{
if (argv.length != 3)
{System.err.println("passer aussi la feuille de style en ligne de
commande");
System.exit(1);}
21
Génération du transformer
DocumentBuilderFactory factory =
try{
File style=new File(argv[0]);
File XML=new File(argv[1]);
document = builder.parse(XML);
StreamSource styleSource= new StreamSource(style);
TransformerFactory tFactory = TransformerFactory.newInstance();
// passer la feuille de style xslt comme argument du constructeur
Transformer transformer = tFactory.newTransformer(styleSource);
21
Transformation en utilisant la feuille
de style
…
}
catch(Exception e)
{
System.exit(2);
}
}// fin main
}//fin class
21
Exécution
 Compiler la classe TransformXSLT

– javac TransformXSLT.java
 Exécuter le code
– java TransformXSLT Style.xsl bouteilles.xml
Sortie.html
 Ouvrir le fichier Sortie.html avec un browser
 Nous retrouvons le String-value du document
– Une concaténation de tout le texte contenu dans la
balise racine et dans ces balises filles
21
Un premier template
 Dans la feuille de style Style.xsl, introduire le

template de traitement du nœud racine pour
obtenir un fichier html
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet….>
<xsl:template match="/">
<html> <body>
<xsl:apply-templates/>
</body> </html>
</xsl:template>
21 </xsl:stylesheet>
Un deuxième template
 Ajouter un deuxième template pour le nœud

<BOUTEILLES>:
…
<xsl:template match="/BOUTEILLES">
<h1 align="center"> Mes Bouteilles </h1>
</xsl:template>
…
 Ré-exécuter le code de TransformXSLT avec
la nouvelle feuille de style
22
Un troisième template
 Ajouter le traitement pour les balises

<bouteille>
<xsl:template match="/BOUTEILLES/bouteille">
<h2>Une bouteille d'eau</h2>
<h3>
</h3>
</xsl:template>
22
Traitement de la balise marque
 Utiliser le « // » pour éviter de donner tout le

chemin:
<xsl:template match="//marque">
<h4> elle est de marque:
</h4>
</xsl:template>
22
Afficher la composition sous forme
d’items
<xsl:template match="//composition">
<h4> Ma bouteille se compose de:
<h5>
<ul>
</ul>
</h5>
</h4>
</xsl:template>
22
Afficher les items
<xsl:template match="//calcium">
<li>
mg/l de calcium
</li>
</xsl:template>
 Introduire les templates équivalents pour les
balises: magnesium, chlorure, et nitrate
22
Pour ne pas afficher le contenu
d’une balise
 Ne rien faire! :
<xsl:template match="//source">
On veut pas afficher la source <br/>
</xsl:template>
<xsl:template match="//ville|//departement">
</xsl:template>
22
Ignorer le reste d’un document
 Introduire le template vide avec le joker « * »:
<xsl:template match="*">
</xsl:template>
22
Réordonner l’information
 Exemple, analyser la composition avant la

marque
<xsl:template match="/BOUTEILLES/bouteille">
<h2>Une bouteille d'eau</h2>
<h3>
<xsl:apply-templates select="text()|composition"/>
<xsl:apply-templates select="marque"/>
</h3>
</xsl:template>
22
A vous de jouer!
 Ecrire de feuilles de style pour générer un fichier comprenant:
– Exclusivement les marques des bouteilles
– Les marques et les sources des bouteilles (sous la forme: ville,
departement)
– Les marques ainsi que les valeurs correspondantes de calcium
– La marque de la bouteille qui possède le plus haut niveau de
magnésium ainsi que la valeur correspondante
– La marque qui possède le plus bas niveau de nitrate
22
Merci de votre attention
22

Slides XML

Transféré par

Informations du document

Titre original

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

Slides XML

Transféré par

Droits d'auteur :

Formats disponibles

Le Méta-Langage XML

Mohammed Karim GUENNOUN

 ISO TC-46: un document est un "ensemble formé par un

 SGML: Standard Generalized Markup Language

 Standard W3C comme format pour les documents à

 XML: un langage textuel d’échange et de stockage

 Specification du 10 février 1998: “Its goal is to enable

15 <message>Ceci est mon message </message>

 Balise ou tag ou label

 Les balises permettent de structurer les données

 Exemple pour un système d’échange de message:

 Les tags peuvent contenir des attributs

 Dans certains cas, il est pertinent d’avoir un tag sans contenu.

 Les commentaires sont codés de la même manière

 Un fichier XML commence toujours par un prolog

 Le prolog minimal contient une déclaration qui identifie le

 La déclaration peut contenir des informations

 La déclaration du prolog peut contenir les attributs suivants:

 Un fichier XML peut aussi contenir des instructions de traitement qui

 XML est un langage textuel

 XML permet l’identification des données

 Facilitation des traitements:

 XML est devenu LA représentation dominante pour les

 Une des utilisations principales d’XML est de construire des

 Configurer les éléments du middleware: containers, serveur,

 Combiner une utilisation d’XML et du langage Java est une

 Nous utilisons un exemple simple de

– <?xml version='1.0' encoding=' ISO-8859-1'?>

<?xml version='1.0' encoding='utf-8'?>

 Dans le cas d’insertion de gros blocs de texte avec

 Une DTD (Document Type Definition) permet de

 Un document bien formé possède les

<?xml version="1.0" encoding="iso-8859-1"?>

<?xml version="1.0" encoding="iso-8859-1"?>

<?xml version="1.0" encoding="iso-8859-1"?>

 Déclaration sous la forme:

 Le contenu d’une balise est défini par une

 Syntaxe utilisant des opérateurs de composition:

<!ELEMENT auteur (#PCDATA) >

<!ELEMENT PERSONNE (#PCDATA)>

<!ATTLIST PERSONNE PNUM ID #REQUIRED>

<!ATTLIST PERSONNE MERE IDREF #IMPLIED>

<!ATTLIST PERSONNE PERE IDREF #IMPLIED>

 Modèle pour plusieurs documents

 Définition locale ou externe

 Pas de types de données à part du texte

 Un schéma d'un document définit:

 Reprendre les acquis des DTD

 La base d’un schéma XML:

 Les schémas distinguent plusieurs types :

– Types complexes (nœuds de l'arbre) définis

Exemple: <xs:element name="NomBalise" type="xs:TypeSimple" />

 Un type simple peut provenir de la restriction d'un

 Les facettes sont des restrictions de types simples:

 Dans un schéma, il est aussi possible de

 Pour les types simples:

 La déclaration suivante est conforme à ce

 Pour les éléments à contenu complexe

 La déclaration suivante est conforme à ce schéma

 Comme tout fichier XML

 Les DTD définissent la grammaire des

 Comment résoudre le problème de la distance entre

 Trois technologies s’offrent à nous pour analyser, traiter