Tout d'abord, rappellons ce qu'est XML. XML (pour eXtensible Markup Language) est un langage de balisage (comme le HTML, par exemple), utilisé pour la représentation et structuration de données. Voici quelques caractéristiques de ce standard :
Extensible : au contraire du HTML, qui contient un jeu limité de balises, le XML permet la création de ses propres balises.
Méta-langage : grâce à son exstensibilité, le XML est un standard tout à fait approprié pour la création d'autres langages (XHTML, par exemple).
Portable : le XML n'est rien d'autre que du texte entre des balises.
Les questions de cette partie de la FAQ portent uniquement sur la manipulation de XML avec la technologie Java. Pour des informations plus spécifiques sur le standard XML, en lui même, regardez : Ou trouver plus d'informations sur le format XML ?
L'API Java standard pour la manipulation du format XML est JAXP (Java API for XML Processing). Cette API permet la lecture, la transformation et l'écriture de fichiers ou flux XML. C'est cette API que nous allons étudier dans la partie XML de cette FAQ.
JAXP (Java API for XML Processing) est composée de quatre packages. Cette API met à la disposition du développeur trois ensembles de fonctionnalités (la modélisation, le parsing et la transformation) regroupées en quatre packages distincts.
javax.xml.parsers : Ce package contient un ensemble d'interfaces devant être implémentées par les différents parseurs (SAX ou DOM). Ce package fournit aussi un ensemble de factory permettant l'accès aux parseurs.
org.w3c.dom : Ce package contient l'ensemble des classes et interfaces nécessaires pour travailler avec DOM (modélisation).
org.xml.sax : Ce package contient l'ensemble des classes et interfaces nécessaires pour travailler avec SAX (parsing).
javax.xml.transform : Ce package contient l'ensemble des classes et interfaces nécessaires pour travailler avec XSLT (transformation).
Les API SAX, DOM et XSLT sont les trois composantes de l'API JAXP. Voici leurs fonctionnalités et principes :
SAX : Simple API for XML travaille les documents XML de manière évenementielle.
C'est à dire que le parseur va lire (parcourir) le fichier ou flux XML et lever tout un ensemble d'événements lors de la rencontre avec un élément. Les éléments pouvant être des balises (ouvrantes ou fermantes), des portions de texte, des commentaires ou encore des instructions.
Cette API est particulièrement mise en avant pour sa rapidité de traitement. Par contre, son fonctionnement est peut-être un peu plus complexe à apréhender que celui de DOM.
Pour bien comprendre la structure et le fonctionnement de cette API regardez : Comment fonctionne l'API SAX ? .
DOM : Document Object Model, à la différence de SAX, ne va pas seulement parcourir le document XML, mais va, en plus, en fabriquer une représentation en mémoire.
Cette représentation est un arbre, que vous pourrez facilement parcourir (cf. org.w3c.dom.Document). Cet arbre représente l'organisation et le contenu du document XML. En contrepartie de sa facilité d'utilisation, DOM est plus gourmand en ressources et en temps.
Pour débuter avec DOM regardez : Comment ouvrir un fichier XML avec DOM ? .
XSLT : eXtensible Stylesheet Language for Transformations, permet la transformation des documents XML.
Les "transformations" consistent soit en une modification d'un XML avec sauvegarde des modifications, soit en une transformation en un autre type de document (HTML et PDF, par exemple).
Quelle que soit votre manière de lire votre document XML (SAX ou DOM), vous serez amené à utiliser XSLT pour sa modification.
SAX, DOM et XSLT sont les principales fonctionnalités offertes par JAXP. Mais ce ne sont pas les seules. Voici une liste plus détaillée des spécifications supportées par JAXP 1.3 :
Si vous n'avez pas le dernier JDK et que vous désirez profiter de toutes les fonctionnalités de JAXP, vous pouvez télécharger l'API séparément sur Java.NET. JAXP Reference Implementation Project : https://jaxp.dev.java.net/
N'oubliez pas que vous pouvez aussi télécharger d'autres API pour travailler avec XML. Certaines sont plus faciles, performantes ou complètes que JAXP.
Pour changer le parseur XML utilisé vous devez spécifier la variable d'environnement javax.xml.parsers.XXX, ou XXX détermine l'implémentation qui vous intéresse. Voici quelques exemples :
Pour le processeur XSLT la démarche est la même, il suffit d'indiquer au système quelle implémentation du processeur XSLT il doit utiliser.
Naturellement, vous pouvez utiliser directement les implémentations (sans passer par les factory), mais cela vous fait perdre la "portabilité" de votre code. En effet, en cas de changement de parseur ou processeur, vous devrez changer de nombreuses parties de votre code. Le plus simple reste de spécifier l'implémentation à utiliser grâce aux propriétés système.
Ainsi, lors des tests, il sera aussi possible de placer le fichier "MaDtd.dtd" dans le répertoire ou l'application sera lancée.
Pour SAX:
Dans le DefaultHandler redéfinir la méthode resolveEntity comme suit :
public InputSource resolveEntity(String publicId, String systemId) throws SAXException
{try{if (!systemId.startsWith("file:"))
{returnnull;
}
String pathDtd = systemId.substring(5);
if (!pathDtd.startsWith("/"))
{
pathDtd ="/"+ pathDtd;
}
InputStream is =getClass().getResourceAsStream(pathDtd);
if (null== is)
{returnnull;
}returnnewInputSource(is);
}catch (Exception e)
{returnnull;
}}
Lorsque cette méthode retourne null, le parser XML utilise sa méthode de recherche par défaut pour trouver la DTD. Ce qui fait que ce code n'empêche pas de trouver une DTD située ailleurs du moment que l'URL est correcte.
Pour dire au parser SAX d'utiliser cette methode resolveEntity:
JAXP n'est pas la seule API Java dédiée à XML. On peut même dire qu'il y en a beaucoup. Certaines sont très spécialisée (sur la technologie J2EE par exemple), d'autres sont plus généralistes et reprennent/consolident/améliorent les composantes de JAXP. Je vous laisse les découvrir par vous même :
JDOM : JDOM se veut une API légère, rapide et facile d'utilisation, pour travailler avec des documents XML. Son fonctionnement est "comparable" à DOM. Compatible avec SAX, DOM et JAXP.
DOM4J : API Open Source qui permet le travail avec XML, XPath et XSLT. Compatible avec SAX, DOM et JAXP.
