2h
2h
Apprendre les concepts de base de XML, quelles parties composent un document
Connaître les principales APIs Java pour XML
XML est un langage à balises ("markup language") utilisé pour transférer des données sur le web.
Chaque document XML a une structure logique et une structure physique.
Physiquement, le document se compose d'unités appelées entités.
Une entité peut contenir d'autres entités, qui sont alors incluses dans le document.
Un document commence à la « racine » ou entité document.
Logiquement, le document se compose de déclarations, d'éléments, de commentaires, d'appels de caractère et d'instructions de traitement, qui sont indiqués dans le document par du balisage explicite.
Les structures logiques et physiques doivent s'imbriquer correctement.
Les documents composés en XML obéissent tous à un certain nombres de règles pour être qualifiés de bien-formés :
· Le document doit respecter les règles de conception décrites dans la recommandation du W3C sur XML,
· Toutes les entités référencées dans le document doivent elles-mêmes être bien formées.
La suite de cette partie décrit les entités d'un document XML et les règles de conception de ce type de document.
Chaque document XML doit commencer par une balise qui indique la version de XML utilisée et éventuellement d'autres indications.
Cette balise de début de document est appelée le prologue.
Exemple :
<?xml version="1.0"?>
Les documents XML sont des fichiers textes.
Les caractères autorisés en XML sont la tabulation, le retour chariot, le retour à la ligne et les caractères Unicode et ISO/IEC 10646.
Le codage des caractères peut être effectué en UTF-8 et UTF-16.
Les caractères <, > et & ne peuvent pas être employés, sauf pour délimiter une balise. (sauf exception, voir Sections CDATA)
Si on souhaite utiliser ces caractères, il est nécessaire d'employer des références à des entités de caractère :
· & pour &
· < pour <
· > pour >
Pour employer ' et " dans une valeur d'attribut, utiliser :
· ' pour '
· " pour "
Dans un document écrit dans un langage à balise tel que XML, les données (le texte, les données binaires,…) sont structurées en utilisant des balises ("tags").
Exemple 1 :
<balise>mon texte</balise>
Exemple 2 :
<style type="text/css">
<![CDATA[@font-face{font-family:'CourierNewPSMT';src:url("data:;base64,\T1RUTwACACAAAQAAQ0ZGIE01zmEAAAAsAAAZbGNtYXADsQJ8AAAZmA…3/y//I/8f/w/+9/7H/r/+u/60AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")}@font-face{font-family:'BerlinSansFB-Reg'; }]]>
</style>
Le dernier exemple peut paraître un peu abscons mais il montre en réalité que l’on peut inclure des données binaires (images, fontes, tout a fait autre chose….) dans du XML
Encadrer les données dans des balises permet de donner du sens aux données.
Exemple :
<important>Ce texte est très important !</important>
<couleur>rouge</couleur>
Ce n’est cependant pas très satisfaisant car :
Les balises permettent aussi d'organiser les données.
Exemple :
<famille>
<pere>Charles</pere>
<mere>Diana</mere>
<enfants>
<fils>Tommy</fils>
<fils>Charlie</fils>
<fille>Magdeleine</fille>
</enfants>
</famille>
Dans XML, la structure logique constituée par les balises et les données qu'elles encapsulent (encadrent) est appelée un élément.
Les termes élément et balises ne veulent pas dire la même chose : un élément est une unité d’ information complète, et peut contenir une balise de début seule (comme la balise <br/>) ou une balise de début, une balise de fin et le contenu situé entre les 2 balises. Une balise seule est simplement la balise de fin ou de début d’un élément .
Comme on peut le remarquer la syntaxe d'un élément XML est toujours de la forme :
balise de début + contenu + balise de fin
La balise de fin reprend le nom de l'élément précédé de / (diviser).
Il y a une exception à cette règle : les éléments vides. Dans ce cas l'élément s'écrit :
<nom/>
Chaque élément XML est composé :
· d'un nom (name) obligatoire,
· d'un contenu, qui peut être vide ou (du texte et/ou des éléments XML),
· d'une liste d'attributs qui peut être vide
La recommandation sur XML indique que chaque document XML doit comporter un (et seulement un) élément racine (root element).
L'élément racine ne peut pas faire partie d'un autre élément.
Les autres éléments du document doivent être imbriqués correctement.
Mauvais exemple :
<fort><faible>texte</fort></faible>
Bon exemple :
<fort><faible>texte</faible></fort>
Un élément imbriqué dans un autre est appelé élément fils et l'élément dans lequel il est imbriqué est appelé élément père.
Dans notre exemple l'élément <fort> est le père de l'élément <faible> et l'élément <faible> est le fils de l'élément <fort>.
XML est sensible à la casse. Attention donc aux majuscules et minuscules.
Un certain nombre de caractères et de noms sont réservés.
Il est interdit d'utiliser le caractère : (deux points) dans le nom d'un élément. En effet, le caractère : sert à préfixer le nom d'un élément XML par le sous-ensemble de XML auquel il se rapporte. Cette notion est vue dans la suite du TP.
Il est interdit de créer des noms d'éléments commencant par xml, quel que soit la casse employée (XML est interdit tout comme xMl)
Un élément XML peut avoir des attributs. Un attribut spécifie une caractéristique de l'élément.
Exemple :
<paragraphe couleurfond="blanc" couleurtexte="bleu">
Il faut savoir se distinguer, au besoin par les couleurs
</paragraphe>
En XML, contrairement à HTML, tous les attributs doivent avoir une valeur.
XML veut dire eXtensible Markup Language, ce qui veut dire que l'on peut utiliser ses propres jeux de balises pour écrire un document.
XML contient un mécanisme de déclaration du type de document (DTD) qui permet de préciser le jeu de balises employé et les règles grammaticales associées.
Un document XML conforme aux règles données dans la déclaration de type de document est appelé valide.
La déclaration du type de document doit être située avant le premier élément du document.
Elle contient, ou pointe, sur des balises qui décrivent une classe de documents. Ces balises peuvent être externes ou internes au document.
Exemple de DTD externe :
<?xml version="1.0"?>
<!DOCTYPE accueil SYSTEM "bonjour.dtd">
<accueil>Bonjour!</accueil>
Exemple de DTD interne :
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE accueil [
<!ELEMENT accueil (#PCDATA)>
]>
<accueil>Bonjour!</accueil>
Si un document comporte plusieurs DTDs, les DTD internes sont lues avant les DTD externes.
Certains jeux de balises sont normalisés et nous en allons en étudier quelques uns durant cette formation : SVG, FOP, XSP, Xinclude, Xpath.
Il est ici fait référence à des DTDs, des déclarations de types de documents écrites dans la même syntaxe que celle utilisée par les DTDs de SGML.
Le sous-ensemble de XML appelé XML-Schema remplit le même rôle que les DTDs en apportant des raffinements : typage plus précis, plages de valeur pour un élément, expressions régulières, portée,…
Une bonne partie de la recommandation XML décrit les règles de conception des DTDs, mais les étudier erait trop long 'étant donné la durée de cette formation.
Il est possible de déclarer qu'un document est autonome, c'est à dire qu'il ne dépend pas d'une DTD externe.
Dans ce cas le prologue du document s''écrit :
<?xml version="1.0" standalone="yes"?>
(no est la valeur par défaut)
Cela n'empêche pas de faire référence à des entités externe dans le document (fichiers à inclure,…).
Un document XML peut être constitué de plusieurs parties, éventuellement situées dans des emplacements distincts.
Ces parties sont appelées des entités et sont définies dans les DTDs.
Un document XML possède aussi une entité appelée entité document qui sert de point de départ pour le processeur XML et qui peut contenir tout le document.
Chaque entité possède un nom utilisé pour appeler l'entité dans le document.
Les entités peuvent être ou non analysé par le document : on parle d'entités analysables (parsed entities) et non-analysables (unparsed entities).
Le contenu des entités analysables est substitué aux appels d'entité par le processeur XML lors du traitement du document.
Il y a deux types d'entités : les entitès générales et les entitès paramètres.
Les entités générales font références à un texte ou à un caractère ISO/IEC 10646 et peuvent être appelées dans le document.
Les entités analysable de texte doivent comporter une d'éclaration du type d'encodage.
Exemple :
<?xml encoding='ISO-8859-1'?>
Les appels à des entités générales analysables utilisent l'esperluette (&) et le point-virgule (;) comme délimiteurs.
Exemples d'appels de caractère et d'entité :
Tapez <touche>plus-petit-que</touche> (<) pour sauvegarder les options.
Ce document a été rédigé le &datedoc; et est classé &niveau-de-sécurité;.
Les entit'és param`ètres sont des entités utilisées uniquement à l'intérieur d'une DTD.
Les appels d'entités paramètres utilisent le symbole pour cent (%) et le point-virgule (;) comme délimiteurs.
Exemple d'appel d'entité paramètre :
<!-- déclaration de l'entité paramètre "ISOLat2"... -->
<!ENTITY % ISOLat2
SYSTEM "http://www.xml.com/iso/isolat2-xml.entities" >
<!-- ... et appel -->
%ISOLat2;
Un document XML peut contenir des instructions de traitement, qui indiquent aux applications qui lisent le document les traitements à lui appliquer.
Exemple :
<?cocoon-process type="xslt"?>
Le document peut contenir des commentaires, qui sont des balises d'un type particulier.
Un commentaire peut apparaître n'importe où dans le document en dehors d'une balise.
Exemple :
<!-- Commentaire -->
Les documents XML peuvent contenir des sections appelées CDATA.
Les sections CDATA permettent d'encapsuler du texte qui sans cela serait interprété comme une balise.
Exemple :
<!CDATA[<mabalise_a_moi>peut contenir n'importe quoi</mabalise_a_moi> parce qu'elle n'est pas lue]]>
Une section CDATA peut contenir les symboles < et &.
Il ne faut pas remplacer ces caractères par des entités (<…) dans les sections CDATA car ces parties du documents sont interprètées de manière littérale et le programme n'effectue pas la traduction des références d'entités en caractères.
Si la section CDATA doit contenir le texte ]]> il faut l'écrire ]]> sinon le programme croit atteindre la fin de la section CDATA.
Il est possible d'indiquer au programme chargé de traiter le document de préserver les espaces sur tout ou partie du document.
Pour cela utiliser l'attribut xml:space.
Exemple :
<page>
Les espaces
<texte_special xml:space="preserve">
sont préservés ici !
</texte_special>
</page>
Il est possible d'indiquer au programme chargé de traiter le document la langue d'un élément.
Pour cela utiliser l'attribut xml:lang.
Exemple :
<page>
Je parle <texte_special xml:lang="de">ein bissen Deutsch</texte_special>
</page>
Le code de langue en 2 lettres est celui défini dans le RFC 1766, "Tags for the identification of Languages".
Extensible Stylesheet Language, le langage de feuille de style extensible, regroupe en fait plusieurs sous-ensembles de XML.
Parmis ces sous-ensembles nous utiliserons :
XSL Transformations, XSLT, permet de transformer un document écrit en XML en un autre document XML
Xpath, est un langage pour adresser des parties de documents XML
Par simplicité, le terme XSL sera employé dans la suite du TP pour XSL Transformations + Xpath.
Pour réaliser les TPs, nous aurons besoin d'un programme qui permet d'appliquer une transformation XSL à un document XML (et aussi d'interprêter d'autres sous ensembles de XML).
Les programmes qui traitent des documents XML sont des processeurs XML (parsers XML).
Le système de publication XML Cocoon utilisé dans le TP utilise le parser Xerces et le moteur de transformation XSL Xalan. Tous deux sont développés en Open Source par l'Apache Software Foundation (ASF).
Tous les programmes utilisés durant le TP sont écrits en Java et sont gratuits.
Une application est généralement découpée en 3 couches distinctes :
Ces couches sont réparties entre le client et le serveur dans les applications client-serveur.
Les applications web sont un type particulier d'application client serveur.
Dans une application web, les rôles sont répartis entre le navigateur de l'utilisateur, qui assure la présentation et éventuellement quelques contrôles, et le serveur web qui assemble les informations (partie applicative) et communique avec une base de données (partie donnée).
Dans le cadre d'un architecture web, XML peut être utilisé sur chacune de ces couches.
XML est beaucoup utilisé sur la couche présentation des applications internet.
Il permet en effet d'envoyer du contenu adapté à la demande de l'utilisateur.
En permettant d'appliquer une transformation XSL en fonction du navigateur utilisé par l'utilisateur, XML permet de faire de la publication croisée sur plusieurs media (cross-media).
Cette approche est utilisé par certaines telcos pour délivrer de l'information aux navigateurs mobiles (WAP,…).
Certains ensembles de XML sont utilisés pour la publication de media enrichi (rich-media), tel que Synchronized Multimedia Integration Language (SMIL), qui permet de créer des présentations audiovisuelles interactives.
Sur la couche application, XML va permettre d'effectuer le traitement conditionnel des requêtes en fonction de la demande de l'utilisateur.
Alors que les sous-ensembles de XML pour la couche présentation sont bien normalisées, Les sous-enembles de XML pour la couche application sont bien souvent propriètaires.
Dans ce TPs on utilisera eXtensible Server Page (XSP), un ensemble de balises développé par l'ASF pour gérer la couche logique d'une application (traitement conditionnel, récupération de paramètres issus de la requête…).
Une autre alternative est d'utiliser Java Server Page version 1.2 (JSP) de Sun, qui est compatible XML.
XML peut être utilisé soit directement comme format de stockage des données (bases de données Open Source Xindice et Ozone), soit être mappé sur une base de données relationnelle, les éléments XML sont dans ce cas reconstruits à la volée lors de l'extraction des données.
Les paquetages SAX et DOM sont définis par le XML-DEV groupe et le W3C, respectivement.
Les librairies qui composent ces APIs sont :
La "Simple API" pour XML (SAX) est une méthode de lecture de XML élément par élément, baséee sur une mécanique évenementielle, avec accès en série aux éléments. Cette API permet de lire et d'écrire du XML à partir d'un entrepot de données ou du Web. Pour la programmation côté serveur et les applications à haute preformance, vous aurez besoin de bien comprendre cette approche. Mais pour la plupart des applications, une comphréhension minmum est suffisante.
L'API DOM est généralement plus facile à utiliser. Elle fournit une structure relativement proche de d'une structure d'arbre d'objets. Vous pouvez utiliser l'API DOM pour manipuler la hiérarchie d'objets applicatifs qu'il encapsule. L'API DOM est idéale pour les applications interactives car le modèle objet entier est présent en mémoire, ou il peut être accédé et manipulé par l'utilisateur.
d'un autre côté, construire le DOM demande de lire la structure XML en entier et de garder l'arbre d'objets en mémoire, ce qui consomme plus de mémoire et de CPU. Pour cette raison l'API SAX tend à être plus utilisée pour les applications côté serveur et le filtrage des données qui ne réclame pas de mise en mémoire.
Finalement, les APIs XSLT défnies dans javax.xml.transform vous permettent d'écrire des données XML dans un fichier ou de les convertir dans un autre formats. Elle peut même être utilisée en conjonction avec les APIs SAX pour transfomrer des données brutes en XML.
