Exporter (0) Imprimer
Développer tout

Le processeur XSLT

Paru le 12 juillet 2006
Sur cette page

Introduction Introduction
Un peu d'histoire Un peu d'histoire
XSLT et Internet Explorer XSLT et Internet Explorer
XSLT et le DOM (Document Object Model) XSLT et le DOM (Document Object Model)
Le processeur XSLT Le processeur XSLT
Conclusion Conclusion
Références Références

Introduction

Ce document présente les différentes manières d'utiliser les fonctionnalités de transformation (XSL et XSLT) mises à disposition des développeurs par le composant MSXML.

Un peu d'histoire

XSL (eXtensible Stylesheet Language) est un langage destiné à opérer des transformations et une mise en forme sur un document XML.

A partir de ce cahier des charges de base, le W3C a défini différentes briques composant l’architecture de XSL :

  • XPath est un langage permettant d’adresser (référencer) une partie d’un document XML,

  • XSLT est un langage permettant de transformer une partie d’un document XML en "quelque chose d’autre",

  • XSL-FO (formatting objects) applique à la transformation précédente une sémantique de mise en forme (styles)

Il s'est avéré que XSLT pouvait être utilisé dans de nombreux scénarios, dépassant le simple cadre de la mise en forme de document à destination de l'œil humain. En particulier, XSLT permet de transformer un document XML :

  • en une page web (HTML),

  • en un document texte,

  • en un autre document XML (suivant un schéma XML différent).

Un processeur XSLT est un moteur prenant en entrée un document XSLT (décrivant la transformation à effectuer) et un document XML à transformer, et produisant en sortie un flux, pouvant être utilisé en tant que nouveau document XML ou comme code source d'autres langages (HTML, texte, etc.).

Ce document a pour but de présenter les différents moyens mis à disposition des développeurs pour effectuer des transformations, en utilisant le composant MSXML.

Note sur les versions : les versions de MSXML inférieures à 2.6 (en particulier, celle livrée avec Internet Explorer 5.x et Windows 2000) implémentaient une ancienne version de XSL, telle que spécifiée par http://www.w3.org/TR/1998/WD-xsl-19981216. La version 3.0, disponible sur http://msdn.microsoft.com/downloads/default.asp?URL=/code/sample.asp?url=/msdn-files/027/000/541/msdncompositedoc.xml, implémente intégralement la recommandation XSLT (http://www.w3.org/TR/xslt), et c'est sur cette version que nous appuierons notre exposé.

XSLT et Internet Explorer

L'une des utilisations courantes de XSLT est de transformer un document XML en code HTML, destiné à être affiché par le navigateur. Internet Explorer 5.x permet d'effectuer cette transformation de manière automatique, en utilisant une "processing instruction" particulière.

D'une manière générale, une processing instruction est une information contenue dans le document XML, à destination de l'application utilisatrice. C'est-à-dire qu'elle ne fait pas partie des données XML elles-même, mais qu'elle donne des indications sur la manière d'utiliser ces données.

Dans le cas qui nous intéresse, l'application utilisatrice est Internet Explorer, et la processing instruction est du type :

<?xml-stylesheet type="text/xsl" href="matransformation.xslt"?>
</code>
		<para>Lorsque Internet Explorer navigue sur un document XML contenant 
    cette processing instruction, il télécharge la feuille de style "matransformation.xslt", 
    effectue la transformation (en utilisant le processeur XSLT) et affiche le résultat 
    de cette transformation.</para> 
    <para><formatting role="bold">document xml</formatting></para>
<code>
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="personnes.xslt"?>
<personnes>
	<personne email="dbossard">
		<nom>Bossard</nom>
		<prenom>David</prenom>
		<age>29</age>
	</personne>
	<personne email="jmartin">
		<nom>Martin</nom>
		<prenom>Jacques</prenom>
		<age>32</age>
	</personne>
</personnes>

feuille de style

<?xml version="1.0"?>

<xsl:transform version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
	<html>
		<head>
			<title>personnes</title>
		</head>
		<body>
			<xsl:apply-templates />
		</body>
	</html>
</xsl:template>

<xsl:template match="personnes">
	<table>
		<thead>
			<th>nom</th>
			<th>prenom</th>
			<th>age</th>
		</thead>
		<xsl:apply-templates />
	</table>
</xsl:template>

<xsl:template match="personne">
	<tr>
		<xsl:apply-templates />
	</tr>
</xsl:template>

<xsl:template match="nom">
	<td><xsl:value-of select="."/></td>
</xsl:template>

<xsl:template match="prenom">
	<td><xsl:value-of select="."/></td>
</xsl:template>

<xsl:template match="age">
	<td><xsl:value-of select="."/></td>
</xsl:template>

</xsl:transform>

résultat

Résultat

Cette approche présente les contraintes suivantes :

  • elle ne concerne que la transformation "XML+XSLT=HTML",

  • elle n'est disponible que pour Internet Explorer 5.x,

  • elle nécessite la navigation sur le document XML à transformer,

  • elle transforme un document XML dans son intégralité, et non pas juste une partie.

Les chapitres suivants montreront les moyens d'effectuer de manière explicite une transformation sur tout ou partie d'un document XML, en vue d'une utilisation dans un cadre plus général que le simple aspect "présentation dans un navigateur".

XSLT et le DOM (Document Object Model)

Rappel : le DOM (Document Object Model) est une recommandation du W3C, décrivant un ensemble d'interfaces permettant de manipuler un document XML par le biais d'un modèle objet. Le principe du DOM est d'appliquer à l'arborescence de nœuds du document XML une hiérarchie d'objets de différents types : IXMLDOMDocument, IXMLDOMElement, IXMLDOMAttribute, etc. ; ces interfaces de description des nœuds implémentent toutes l'interface IXMLDOMNode.

Depuis les versions 2.x de MSXML, les fonctionnalités de transformation par XSL(T) ont été intégrées au DOM, par le biais des deux méthodes suivantes :

  • IXMLDOMNode::transformNode

  • IXMLDOMNode::transformNodeToObject

Ces deux méthodes constituent des extensions, dans la mesure où elles ne sont pas décrites dans les différentes spécifications du DOM rédigées par le W3C.

Tout d'abord, il est important de noter que ces fonctionnalités sont offertes au niveau d'un nœud, quel qu'il soit, du document XML. Dans le chapitre précédent, nous avons vu comment Internet Explorer appliquait une transformation à l'intégralité d'un document XML. En fait, il utilise pour ce faire cette mécanique au niveau de l'objet DOMDocument, qui implémente l'interface IXMLDOMNode, dans la mesure où un document XML est un nœud.

transformNode est une fonction prenant en paramètre le document XML (DOMDocument) contenant la feuille de style, et renvoyant sous forme de chaîne le résultat de la transformation du noeud courant par cette feuille de style. Charge ensuite au développeur d'utiliser cette chaîne pour en faire quelque chose.

exemple

dim oXML
dim oXSL

' chargement du document XML
set oXML = WScript.CreateObject("MSXML2.DOMDocument")
oXML.async = false
oXML.load "personnes.xml"

' chargement de la feuille de style
set oXSL = WScript.CreateObject("MSXML2.DOMDocument")
oXSL.async = false
oXSL.load "personnes.xslt"

' transformation du document complet
WScript.Echo oXML.transformNode(oXSL)

' transformation du premier élément "personne"
WScript.Echo oXML.selectSingleNode("//personne"). transformNode(oXSL)

set oXSL = nothing
set oXML = nothing

La méthode transformNodeToObject prend en paramètre le document XML (DOMDocument) contenant la feuille de style ainsi qu'un objet destiné à recevoir le résultat de la transformation. Cet objet peut être un document XML (DOMDocument), une réponse ASP, ou un objet implémentant l'interface IStream. Elle permet donc en particulier d'effectuer une transformation et d'obtenir un document XML résultant de cette transformation (dans le cas où le résultat de la transformation est du code XML bien formé), ce qui est typiquement utile dans le cas de traduction de schéma : à partir d'un document XML, on obtient un autre document contenant les mêmes données, mais structurées différemment.

exemple

dim oXML
dim oXSL
dim oRes

' chargement du document XML
set oXML = WScript.CreateObject("MSXML2.DOMDocument")
oXML.async = false
oXML.load "personnes.xml"

' chargement de la feuille de style
set oXSL = WScript.CreateObject("MSXML2.DOMDocument")
oXSL.async = false
oXSL.load "personnesToEmployes.xslt"

' création du document résultat
set oRes = WScript.CreateObject("MSXML2.DOMDocument")

' chargement du document oRes avec le résultat de la transformation
oXML.transformNodeToObject oXSL, oRes

' manipulation du document résultat
WScript.Echo oRes.selectSingleNode("//employe/@adresse").nodeValue 

set oRes = nothing
set oXSL = nothing
set oXML = nothing

Ces deux méthodes, très largement utilisées, présentent le principal inconvénient de nécessiter une interprétation du document XML contenant la feuille de style (c'est-à-dire "compiler" la feuille de style en code natif) chaque fois que l'on veut effectuer la transformation ; cela peut entraîner une perte de performances, si la même transformation est à utiliser plusieurs fois sur des documents XML différents.

Le processeur XSLT

MSXML 3.0 introduit deux objets prenant en charge le mécanisme de transformations de manière indépendante à tout document à transformer. L'objet XSLTemplate est une "CoClass", instanciable par le biais du ProgID MSXML2.XSLTemplate. Cet objet a pour but de générer le code natif d'une transformation, sous la forme d'un "processeur" (interface IXSLProcessor) qui pourra être utilisé pour effectuer plusieurs fois la même transformation sans avoir à re-charger ou ré-interpréter la feuille de style à chaque fois. Cet objet template peut même être conservé en mémoire après la destruction du document XML contenant la feuille de style, ce qui permet par exemple d'utiliser la même transformation dans plusieurs pages ASP différentes.

exemple

<%@language=vbscript%%>
<%
dim oXML
dim oXSLProcessor

' chargement du document XML
set oXML = WScript.CreateObject("MSXML2.DOMDocument")
oXML.async = false
oXML.load "personnes.xml"

set oXSLProcessor = getXSLTemplate().createProcessor()
oXSLProcessor.input = oXML
oXSLProcessor.output = Reponse
oXSLProcessor.transform

set oXML = nothing
set oXSLProcessor = nothing
%>

La fonction getXSLTemplate peut être définie dans un fichier inclus comme suit :

function getXSLTemplate()
	if Application("xslTemplate") is nothing then
		dim oXSL
		dim oXSLTemplate

' chargement de la feuille de style
set oXSL = _
  Server.CreateObject("MSXML2.FreeThreadedDOMDocument")
oXSL.async = false
oXSL.load "personnes.xslt"

' création du template
set oXSLTemplate = _
  Server.CreateObject("MSXML2.XSLTemplate")
set oXSLTemplate.stylesheet = oXSL

' sauvegarde dans l'objet Application
set Application("xslTemplate") = oXSLTemplate
	end if
	set getXSLTemplate = Application("xslTemplate")
end function

NB : dans l'exemple ci-dessus, la version "free-threaded" du DOM (ProgID MSXML2.FreeThreadedDOMDocument) doit être utilisée, car le template est susceptible d'être appelé par plusieurs threads d'exécution ASP de requêtes HTTP. L'objet IXSLProcessor permet de plus d'intégrer la notion de paramètres : XSLT offre la possibilité de passer au processeur des valeurs utilisées par la transformation comme des variables globales.

exemple

oXSLProcessor.addParameter "utilisateur", _
  Request.ServerVariables("HTTP_USER")

extrait de la feuille de style

<xsl:param name="utilisateur"/%>
...
<xsl:value-of select="$utilisateur"/%>

Cette approche, en découplant XSLT du DOM permet même d'envisager, dans un avenir proche, l'utilisation des transformations XSLT avec d'autres technologies de parsing XML, comme des modèles de "pull" semblables à celui utilisé dans la plate-forme Microsoft .NET.

Conclusion

XSLT est une technologie de transformation pouvant être utilisée à de nombreuses fins (création de code HTML, traduction de schémas, etc.) et dans des architectures différentes (page web côté client, page ASP côté serveur, application Visual Basic, etc.).

Avec MSXML 3.0, les développeurs ont la possibilité de choisir différentes approches, afin de privilégier l'interactivité, la performance, la richesse de leur plate-forme clientes, tout en bénéficiant de l'implémentation des dernières recommandations du W3C relatives à XSLT. C'est en testant ces différentes approches que chacun pourra choisir celle la plus appropriée à ses contraintes ou ses besoins.

Références

Afficher:
© 2014 Microsoft