| |
auteur :
Ioan Calapodescu | 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.
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.
|
lien : Qu'est-ce que JAXP ?
lien : Ou trouver plus d'informations sur le format XML ?
lien : Quelles autres API existent pour travailler avec XML ?
|
| |
auteur :
Ioan Calapodescu | 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).
|
lien : Que sont les API SAX, DOM et XSLT ?
|
| |
auteur :
Ioan Calapodescu | 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.
|
lien : Comment fonctionne l'API SAX ?
lien : Comment ouvrir un fichier XML avec DOM ?
|
| |
auteur :
Ioan Calapodescu | 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.
|
| |
auteur :
Ioan Calapodescu | Voici les différents parseurs XML et processeurs XSLT utilisés par JAXP RI (Reference Implementation) versions 1.3 , 1.2 et 1.1.
| Outils/versions |
Parseur XML |
Processeur XSLT |
| JAXP RI 1.3 |
Xerces 2.6.2 |
XSLTC (basé sur Xalan 2.6.0) |
| JAXP RI 1.2 |
Xerces 2.3.0 |
XSLTC (basé sur Xalan 2.4.1) |
| JAXP RI 1.1 |
Crimson |
XSLTC |
Vous pouvez changer ces outils, s'ils ne vous conviennent pas. Pour cela, vous pouvez regarder les liens ci-dessous.
|
lien : Comment changer le parseur XML ou le processeur XSLT ?
|
| |
auteur :
Ioan Calapodescu | 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 :
Exemple DOM System.setProperty("javax.xml.parsers.DocumentBuilderFactory",
"net.sf.saxon.om.DocumentBuilderFactoryImpl");
DocumentBuilderFactory dfactory =
DocumentBuilderFactory.newInstance();
Ou alors :
Exemple SAX System.setProperty("javax.xml.parsers.SAXParserFactory", "org.apache.crimson.jaxp.SAXParserFactoryImpl");
Vous pouvez aussi faire ces modifications en ligne de commande. Par exemple :
Ligne de commande java -Djavax.xml.parsers.XXXFactory=nom.complet.de.l.implementation ...
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.
|
| |
auteur :
bulbo | Cette solution utilise la spécification JAXP 1.2.
La DTD sera décrite ainsi dans le document XML:
<!DOCTYPE document SYSTEM "file:MaDtd.dtd" >
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:"))
{
return null;
}
String pathDtd = systemId.substring(5);
if (!pathDtd.startsWith("/"))
{
pathDtd = "/" + pathDtd;
}
InputStream is = getClass().getResourceAsStream(pathDtd);
if (null == is)
{
return null;
}
return new InputSource(is);
}
catch (Exception e)
{
return null;
}
}
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:
SAXParser parser =...
parser.getXMLReader().setEntityResolver(monHandler);
Pour DOM:
Pour DOM il faut qu'une classe implémente l'interface EntityResolver.
Le code de la méthode resolveEntity est exactement le même que pour SAX.
Pour spécifier au parser DOM quelle méthode utiliser:
DocumentBuilder builder = ...
builder.setEntityResolver(new MonEntityResolver());
|
| |
auteur :
Ioan Calapodescu | Si vous désirez plus d'informations sur le standard XML et ses applications, je vous invite à parcourir ces liens :
|
| |
auteur :
Ioan Calapodescu | 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.
- StAX : Streaming API for XML
- JAXB : Java Architecture for XML Binding
- JAXR : Java API for XML Registries
- JAX-RPC : Java API for XML-based RPC
- SAAJ : SOAP with Attachments API for Java
Pour l'utilisation des quatre dernières API, vous pouvez regarder le J2EE 1.4 Tutorial de Sun.
|
Consultez les autres F.A.Q's
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre intellectuelle protégée par les droits d'auteurs.
Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs :
- Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement :
"Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement".
- Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC. Aucune reproduction, ne peux en être faite sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.
|
|
|
