Retour à la table des matières

Votre premier document XML

ATTENTION : Tutorial en cours d'écriture ! N'hésiter pas à nous signaler toute erreur ou suggestion.

Nous allons, dans ce chapitre, étudier notre premier document XML. L'objectif étant de voir comment ce dernier est constitué : en effet, un document XML est constitué de plusieurs fichiers et notamment, un fichier de données, un fichier de validation et une feuille de styles.

L'exemple que nous allons étudier est réellement utilisé sur notre site professionnel : Infini Software. Une telle société présente des informations bien précisent : des plans de formation.

Il a donc été nécessaire pour nous de trouver une technologie qui nous permette de facilement présenter ces plans de cours, tout en garantissant que nous puissions changer la mise en page de ces plans de cours sans forcément devoir retoucher l'intégralité des plans de cours. XML s'est donc imposé à nous, et nous avons, à partir de ce dernier, définit notre propre langage de présentation de plan de cours : appelons le FML (Formation Markup Language).

Pour pouvoir poursuivre la lecture de ce chapitre, je vous convie à télécharger le fichier zip suivant : il contient tous les fichiers dont nous allons parler dans la suite de ce chapitre. Notez que ce mini projet à été mit en oeuvre via l'outil XmlSpy que vous pouvez aussi télécharger à partir de l'adresse suivante : http://www.xmlspy.com. Cet outil est à mon sens l'un des meilleurs du moment en terme d'édition de documents XML. Sachez aussi que pour l'heure, seul Internet Explorer 5.5 (ou supérieur) permet de correctement visualiser des documents XML.

Présentation du langage FML

Un plan de formation est quelque chose d'un peu complexe. En effet, une formation durera un certain nombre de jours - il faut un certain nombre de pré-requis pour suivre une formation - il faut connaître les objectifs à atteindre durant la formation. De plus le plan de la formation définit les différents chapitres qui vont être étudiés.

Utiliser un langage de balisage est une bonne chose dans notre cas. Cela permettra de structurer les données qui constituent le plan de cours. Mais une question apparaît : quels tags utiliser ? En fait XML ne spécifie aucun tag. C'est à vous de définir votre propre langage. Dit autrement, XML fournit une syntaxe mais c'est à vous de définir une grammaire. Nous reviendrons sur cet aspect ultérieurement dans ce chapitre, mais nous pouvons dès à présent choisir les noms des tags que nous allons utiliser.

L'exemple suivant vous montre un extrait d'un fichier de données utilisant notre langage FML. Il s'agit d'un plan de cours (partiel), mais il peut bien entendu y avoir autant d'autres fichiers que nécessaire. Quelques explications suivent cet exemple.

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml:stylesheet type="text/xsl" href="Formation.xsl" ?>
<!DOCTYPE FORMATION SYSTEM "Formation.dtd">
<FORMATION>
    <TITRE>Visual Basic 6.0 (Niv 1 - Fr)</TITRE>
    <DUREE>5</DUREE>
    <PREREQUIS>
	Une expérience de la programmation est vivement conseillée.
    </PREREQUIS>
    <OBJECTIF>
	Etre capable de programmer des applications en utilisant
        le langage et l'environnement Visual Basic Enterprise.
    </OBJECTIF>
    <CONTENU>
        <CHAPITRE>
	    <TITRE>
		Introduction au développement d'applications
		à l'aide de Visual Basic 6.0
	    </TITRE>
	    <SECTION>Fonctionnalités de Visual Basic</SECTION>
	    <SECTION>Éditions de Visual Basic</SECTION>
	    <!-- La suite du chapitre -->
        </CHAPITRE>
	<CHAPITRE>
            <TITRE>Visual Basic - Notions fondamentales </TITRE>
	    <SECTION>Introduction aux objets</SECTION>
	    <!-- La suite du chapitre -->	    
	</CHAPITRE>
        <!-- Les autres chapitres -->
    </CONTENU>
    <ANIMATEUR>Dominique LIARD</ANIMATEUR>
    <ANIMATEUR>Alexia RAMAIOLI</ANIMATEUR>
</FORMATION>

Comme vous pouvez le voir, tous les noms de tags sont en français. C'est donc clair, ce n'est pas du prédefini (sans quoi ça aurait certainement été écrit en anglais). C'est moi qui ai décidé d'appeler ainsi mes tags. Une formation (tag FORMATION) est donc constituée d'un titre (tag TITRE), puis d'une durée (tag DUREE), et ainsi de suite.

Si vous regardez attentivement les premières lignes du fichier de données, vous constaterez qu'il se lie à deux autres fichiers : "formation.dtd" et "formation.xsl". Ils servent, respectivement, à définir la grammaire (comment correctement utiliser les tags) de notre langage et à permettre une mise en page d'un fichier de données. Revenons plus en détails sur chacun de ces fichiers.

Mise en oeuvre et intérêt d'une grammaire

Pour définir un langage balisé, il ne suffit pas de simplement choisir quelques noms de tags ! En effet, si l'on considère le langage HTML (à titre d'exemple), un tag <TD> (Table Data) ne peut pas s'utiliser n'importe ou. Une cellule de données TD doit être contenue dans une ligne de tableau <TR> (Table Row) qui doit elle même être contenue dans un tag <TABLE>. Il y a bien une grammaire HTML.

Définition de la grammaire FML

Pour vos langages, il doit en être de même. Pour ce faire, deux principaux mécanismes vous sont offerts. Le premier (historiquement parlant) consiste à définir une DTD (Document Type Definition). Le second consiste à utiliser un schema (un fichier XML de définition de grammaire). Dans notre exemple, étant donnée sa simplicité, c'est une DTD qui est utilisée. Le tableau suivant vous montre le contenu de cette DTD.

<!ELEMENT FORMATION (TITRE, DUREE, PREREQUIS, OBJECTIF, CONTENU, ANIMATEUR+)>
<!ELEMENT CONTENU (CHAPITRE)*>
<!ELEMENT CHAPITRE (TITRE, SECTION*)>

<!ELEMENT TITRE (#PCDATA)>
<!ELEMENT DUREE (#PCDATA)>
<!ELEMENT PREREQUIS (#PCDATA)>
<!ELEMENT OBJECTIF (#PCDATA)>
<!ELEMENT SECTION (#PCDATA)>
<!ELEMENT ANIMATEUR (#PCDATA)>

Notre langage FML définit neuf tags. En conséquence, notre DTD contient au moins neuf lignes. Ici, une ligne par tag. Pour les six dernières règles, elles indiquent que ces tags ne peuvent que contenir des données textuelles (#PCDATA - Parsed Character Data). Les trois autres sont un peu plus complexes.

La première définition indique ce que le tag racine (<FORMATION>) va contenir un titre (et obligatoirement un), puis une durée, un pré-requis, un objectif, un contenu et des animateurs (un ou plus). Mais le contenu est lui même composé. Il peut contenir un nombre quelconque de chapitre (0 ou plus). Un chapitre étant constitué d'un titre et d'autant de sections que nécessaire.

Validation d'un fichier de données

Vous pouvez utiliser des outils de validation, pour vérifier qu'un document de données et bien conforme à la grammaire (DTD ou Schema) du langage. Sous environnement Windows, Microsoft fournit des outils de validation : personnellement, j'utilise un outil nommé "xmlint.exe".

Le tableau suivant vous affiche quelques résultats obtenus par l'outil "xmlint.exe". Le premier test de validation à été effectué avec un fichier de données en accord avec la DTD : rien ne s'affiche. Le deuxième test à été effectué en permuttant les tags <TITRE> et <DUREE> dans le fichier de données : l'outil n'arrive donc pas à valider le fichier et affiche un message d'erreur. Enfin, le troisième test à été lancé en supprimant du fichier de données le tag <CONTENU> : encore une fois, la validation ne peut aboutir. Analyser bien les messages d'erreurs affichés par l'outil.

C:\Documents and Settings\Administrator\Desktop\FmlSample>dir
 Volume in drive C has no label.
 Volume Serial Number is 38DF-5396

 Directory of C:\Documents and Settings\Administrator\Desktop\FmlSample

22/12/2002  17:18    <DIR>          .
22/12/2002  17:18    <DIR>          ..
27/03/2001  03:32               534 Formation.css
22/12/2002  21:43               333 Formation.dtd
24/05/2002  05:53               731 Formation.spp
22/12/2002  18:08             2 351 Formation.xsl
22/12/2002  17:33    <DIR>          Images
16/12/2002  01:18            17 094 V-Basic1.html
22/12/2002  20:35             7 508 V-Basic1.xml
16/12/2002  01:18            11 154 V-Basic2.html
22/05/2002  03:59             4 357 V-Basic2.xml
26/03/2001  11:54               100 XmlToHtml.bat
               9 File(s)         44 162 bytes
               3 Dir(s)   7 405 457 408 bytes free

C:\Documents and Settings\Administrator\Desktop\FmlSample>xmlint V-Basic1.xml
V-Basic1.xml

C:\Documents and Settings\Administrator\Desktop\FmlSample>xmlint V-Basic1.xml
V-Basic1.xml
        Element content is invalid according to the DTD/Schema.
Expecting: TITRE.
        URL: file:///C:/Documents%20and%20Settings/Administrator/Desktop/FmlSamp
le/V-Basic1.xml
        Line 00005:  <DUREE>5</DUREE>
        Pos  00009: --------^

C:\Documents and Settings\Administrator\Desktop\FmlSample>xmlint V-Basic1.xml
V-Basic1.xml
        Element content is invalid according to the DTD/Schema.
Expecting: OBJECTIF.
        URL: file:///C:/Documents%20and%20Settings/Administrator/Desktop/FmlSamp
le/V-Basic1.xml
        Line 00010:  <CONTENU>
        Pos  00011: ----------^

C:\Documents and Settings\Administrator\Desktop\FmlSample>

Notez pour le moment, que la validation de la grammaire n'est pas une étape obligatoire pour pouvoir présenter un document. Nous reviendrons ultérieurement, dans les chapitres suivants, sur cette notion de grammaire XML. Nous étudierons en détails comment écrire une DTD, mais aussi comment écrire un schema.

Mise en page d'un plan de cours

Il vous faut bien comprendre une chose : les tags dont nous avons parlé dans FML on été choisis par nos soins. Comment le navigateur pourrait t'il les connaître ? Tout comme il nous a fallut spécifier qu'elles étaient les règles d'imbrications des tags, il va nous falloir définir comment chaque tag va se présenter.

Aspects généraux

Si nous ne spécifions rien, le navigateur ne saura pas quoi faire. Par défaut, Internet Explorer se contente simplement d'afficher le fichier XML en question. Pour testez la chose, il vous suffit simplement de supprimer la deuxième ligne du fichier de données XML (celle qui lie la feuille de style XSL) et d'afficher ce document dans le navigateur. La capture d'écran suivante vous montre le résultat.

Il est clair que si on laisse les choses ainsi, nous risquons de ne pas remporter un franc succès. Il est préférable d'ajouter une feuille de style. Pour ce faire, il suffit d'ajouter la ligne suivante dans le prologue (en deuxième ligne dans la partie supérieure) des fichiers XML.

<?xml:stylesheet type="text/xsl" href="Formation.xsl" ?>

Cette ligne d'affectation de feuille de styles contient principalement deux parties. La première indique le langage de feuille de style utilisé. En effet, vous avez deux langages potentiellement utilisables avec XML : CSS (Cascading StyleSheet) et XSL (eXtensible Stylesheet Language). Dans notre exemple, c'est une feuille de style XSL qui est utilisée. La deuxième information à fournir est la localisation du fichier de style (href signifiant Hypertext REFerence). La capture d'écran suivante montre le même fichier que précédemment, mais auquel on a appliqué une feuille de styles.

Introduction aux feuilles de styles XSL

Si l'on regarde bien les possibilités d'affichage d'un navigateur, on peut dire qu'elles se limitent aux possibilités inhérentes au HTML. Cela est suffisant au mécansime XSL pour pouvoir présenter un document XML

L'acronyme XSL signifie eXtensible Stylesheet Language. Il est vrai que si l'on cherche à comprendre comment fonctionne XSL, on a du mal à comprendre le qualificatif de Stylesheet (feuille de styles). En effet, on peut plus comparer XSL au pré-processeur du langage C qu'à un mécanisme de feuilles de styles.

Pour s'en convraincre, regardons de plus près comment XSL fonctionne. En fait on parle du moteur de transformation XSL (le véritable nom de la recommandation du W3C étant XSLT). Ce moteur est un outil qui prend en entrée deux fichiers (un fichier de données XML et un fichier de règles XSL) et qui en sortie, aprés de multiples transformations, renvoie un autre fichier XML. Le diagramme suivant schématise ce fonctionnement.

Le fichier de règles XSL est constitué de différentes règles. Dans le cas le plus simpliste, chaque règle correspond à un nom de tags dans le fichier de données d'entrées. A titre d'exemple, voici un extrait de la feuille de style qui montre comment afficher les différents chapitres et leurs contenus. Les couleurs utilisées permettent, ici, de mettre en évidence ce qui correspond au fichier de données d'entrée et ce qui correspond à celui de sortie.

<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
    <xsl:output encoding="ISO-8859-1"/>

    <!-- Toutes les autres règles de la feuille de styles -->

    <xsl:template match="CHAPITRE">
	<H2><xsl:value-of select="./TITRE"/></H2>
	<UL>
	    <xsl:apply-templates select="./SECTION"/>
	</UL>
    </xsl:template>
	
    <xsl:template match="SECTION">
	<LI><xsl:value-of select="."/></LI>
    </xsl:template>

</xsl:stylesheet>
Légende
	Rouge : permet de filtrer les tags du fichier d'entrée
                pour lesquels la règle s'applique.

	Bleu (clair) : permet, pour le tag considéré, de dire ce
                qu'on lui associe dans le fichier de sortie.

Comme vous l'avez constaté, en sortie, le moteur de transformation XSL produit du HTML que le navigateur saura afficher. Mais comprenez bien que la génération de tag HTML n'est pas une obligation, vous pouvez utiliser le moteur de transformation pour passer d'un langage XML à un autre langage XML. Vous renviendrons dans les chapitres ultérieurs, plus dans le détail sur XSL.

Où opérer la transformation ?

Dans le cadre du Web, il vous faut choisir ou réaliser l'application de la feuille de style (la transformation XSL). Deux possibilités s'offrent à vous : soit c'est le navigateur qui réalise l'opération, soit c'est le serveur Web. Dans les deux cas, il y a des avantages et des inconvénients.

Application coté navigateur

L'application de la feuille de styles (dit autrement, la génération du fichier de sortie) est un processus qui peut prendre un certain temps. Réaliser cette transformation par l'intermédiaire du navigateur amènne donc à sérieusement réduire l'activité du serveur web.

Tant que cela est possible, préferrez faire travailler le navigateur dans le sens ou les traitements sont répartis. La principale problèmatique réside dans le fait que les navigateurs ne supporte pas tous les technologies XML. Essayez d'afficher un document XML dans un Netscape : vous serez surpris. Et oui, il ne sais pas réaliser l'application de la feuille de styles.

Par défaut, l'application de la XSL est malgré tout faite par le navigateur, dès lors que vous avez ajouté le tag <?xml:stylesheet ... ?> dans votre document.

Application coté serveur

La seconde altérnative consiste à appliquer la feuille de style sur le serveur Web. Ainsi, vous n'avez qu'à garantir que le serveur Web sache prendre en charge les technologies XML, les différents clients ne recevant alors plus que du HTML. Deux sous alternatives sont alors à prendre en compte : soit le fichier à un contenu statique, soit chaque requête HTTP peut ammener à recevoir des données différentes.

Si le contenu des documents ne change pas, ce qui est d'ailleurs le cas avec nos plans de cours, vous pouvez alors faire l'application une fois pour toute est stoker les fichiers HTML sur le serveur Web. Si vous regardez dans le fichier ZIP, vous y trouverez un fichier "XmlToHtml.bat". Il utilise l'outil msxsl.exe (fournit par Microsoft) pour générer le fichier HTML à partir du fichier XML de données.

Si au contraire le contenu d'un flux de données XML peut changer d'une requête HTTP à une autre (par exemple, par ce qu'il est généré à partir d'une base de données), il faut alors garantir que la transformation sera réalisée à chaque requête. Pour ce faire, vous pouvez utiliser un mécanisme de génération de page Web dynamique (PHP, ASP.NET, Servlets, JSP, JSF, ...). L'exemple suivant vous montre un code ASP.NET réalisant la transformation.

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Data.SqlClient;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using System.Xml;
using System.Xml.Xsl;


namespace CaddieVirtuel {
    public class Caddie : System.Web.UI.Page {
        protected System.Data.SqlClient.SqlConnection sqlConnection1;
        protected System.Data.SqlClient.SqlCommand sqlCommand1;
	protected System.Data.SqlClient.SqlDataReader reader;	

        private void Page_Load(object sender, System.EventArgs e) {	
	    /* Ouverture de la connexion à la base de données */
	    this.sqlConnection1.Open();
	    this.sqlCommand1.Parameters["@id"].Value = this.Request.QueryString["id"];
	    this.reader = this.sqlCommand1.ExecuteReader();

	    /* Génération de la réponse HTTP. Vous avez le choix pour
	     * où appliquer la feuille de style XSL */
            this.applyServerSide();

	    /* Fermeture de la connexion à la base de données */
	    this.reader.Close();
	    this.sqlConnection1.Close();

            /* On termine la réponse HTTP */
	    this.Response.End();
        }

        public void applyServerSide() {
	    this.Response.ContentType = "text/html";
		
	    String xml = "<?xml version='1.0' encoding='ISO-8859-1' ?>";
	    while(this.reader.Read()) {
	        xml += "<Article>";
		xml += "    <IdArticle>" + reader.GetInt32(0) + "</IdArticle>";
		xml += "    <Designation>" + reader.GetString(1) + "</Designation>";
		xml += "    <Marque>" + reader.GetString(2) + "</Marque>";
		xml += "    <PrixUnitaire>" + reader.GetDouble(3) + "</PrixUnitaire>";
		xml += "</Article>";
	    }

	    XslTransform xslt = new XslTransform();     
	    xslt.Load(this.Server.MapPath(".") + "\\" + "Domi.xsl");

	    XmlDocument doc = new XmlDocument();
	    doc.LoadXml(xml);

	    xslt.Transform(doc, null, this.Response.Output);
	}
	
	public void applyClientSide() {
	    this.Response.ContentType = "text/xml";

	    while(this.reader.Read()) {
		Response.Write("<?xml version='1.0' encoding='ISO-8859-1' ?>");
		Response.Write("<?xml:stylesheet type='text/xsl' href='Domi.xsl' ?>");
		Response.Write("<Article>");
		Response.Write("    <IdArticle>" + reader.GetInt32(0));
                Response.Write("    </IdArticle>");
		Response.Write("    <Designation>" + reader.GetString(1));
                Response.Write("    </Designation>");
		Response.Write("    <Marque>" + reader.GetString(2) + "</Marque>");
		Response.Write("    <PrixUnitaire>" + reader.GetDouble(3));
                Response.Write("    </PrixUnitaire>");
		Response.Write("</Article>");
	    }
	}

        Web Form Designer generated code
    }
}

Dans ces deux sous cas, notez aussi qu'un autre inconvénients peut être signalé, comparé à une transformation coté navigateur. Un flux de données XML prend généralement moins de place qu'un flux HTML. En effet, les données XML sont décorellées de tous aspects visuels : il a donc moins de texte à transférer par le réseaux.

Conclusion

Nous avons donc, dans ce chapitre, étudié notre premier langage XML. En effet, le différentes recommandations du W3C, estampillées du mot XML, permettent de définir un langage de balisage adapté à vos besoins.

Pour ce faire, il vous faut définir une grammaire, spécifiant comment correctement utiliser les tags de votre langages. Des outils de validations de grammaire vous sont même fournis. Deux sous langages vous permettent de définir une grammaire : une DTD (Document Type Definition) ou un Schema (qui est lui même une grammaire XML bien définie).

Accessoirement, vous pouvez adjoindre une feuille de styles à votre langage, cela vous permettant de présenter vos données. Encore une fois, deux langages sont utilisables : CSS (Cascading StyleSheet) et XSL (eXtensible Stylesheet Language). Ce dernier (lui aussi est basé sur une grammaire XML déterminée) étant bien plus puissant que CSS.

Dans le chapitre suivant mous allons nous intéresser de plus prés non pas à la définition d'un grammaire XML, mais sur la syntaxe XML. En effet, la recommandation XML, à proprement parler, définit uniquement les aspects de syntaxe pour que vos fichiers de données soient "bien formés".

Retour à la table des matières