FAQ Java XML - Arts Vivants en Vaucluse

Transcription

FAQ Java XML
Date de publication : 12/10/2006
Dernière mise à jour : 17/05/2009
Cette faq a été réalisée à partir des questions fréquemment posées sur les forums de
http://www.developpez.com et de l'expérience personnelle des auteurs.
Nous tenons à souligner que cette faq ne garantit en aucun cas que les informations
qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est
humaine. Cette faq ne prétend pas non plus être complète. Si vous trouvez une erreur,
ou que vous souhaitez nous aider en devenant rédacteur, lisez Comment participer à
cette faq ?.
Sur ce, nous vous souhaitons une bonne lecture.
L'équipe Java
Ont contribué à cette FAQ :
bazinou - iubito - Clément Cunin - Johann Heymes - Ronan
Le Gallo - Christophe Ludet - Jean-Baptiste Bugeaud Grégory Danelon - Sébastien Meric - Romain Guy - PierreYves Varoux - Ioan Calapodescu - bahamouth - duj - braim
- bulbo - Ricky81 - L'équipe Java - Debernad - jcarre
- Seigne David - cyberzoide - xavlours - christopheJ willowII - Nourdine Falola - laffreuxthomas - adiGuba -
FAQ Java XML
1.
2.
3.
4.
5.
6.
Informations générales (5) .........................................................................................................................................................4
Généralités (11) ......................................................................................................................................................................... 7
SAX (6) ....................................................................................................................................................................................13
DOM (11) ................................................................................................................................................................................ 20
XSLT (9) ..................................................................................................................................................................................29
XPath (12) ................................................................................................................................................................................37
-3Les 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 © 2006 Developpez LLC : Tous droits réservés Developpez LLC.
FAQ Java XML
Sommaire > Informations générales
Comment bien utiliser cette faq ?
Auteurs : L'équipe Java ,
Le but :
Cette faq a été conçue pour être la plus simple possible d'utilisation. Elle tente d'apporter des réponses simples et
complètes aux questions auxquelles sont confrontés tous les débutants (et les autres).
L'organisation :
Les questions sont organisées par thème, les thèmes pouvant eux-même contenir des sous-thèmes. Lorsqu'une question
porte sur plusieurs thèmes, celle-ci est insérée dans chacun des thèmes rendant la recherche plus facile.
Les réponses :
Les réponses contiennent des explications et des codes sources. Certaines sont complétées de fichier à télécharger
contenant un programme de démonstration. Ces programmes sont volontairement très simples afin qu'il soit aisé de
localiser le code intéressant. Les réponses peuvent également être complétées de liens vers d'autres réponses, vers la
documentation en ligne de Sun ou vers un autre site en rapport.
Nouveautés et mises à jour :
Lors de l'ajout ou de la modification d'une question/réponse, un indicateur est placé à coté du titre de la question.
Cet indicateur reste visible pour une durée de 15 jours afin de vous permettre de voir rapidement les modifications
apportées.
J'espère que cette faq pourra répondre à vos questions. N'hésitez pas à nous faire part de tous commentaires/remarques/
critiques.
lien : Comment participer à cette faq ?
Comment participer à cette faq ?
Cette faq est ouverte à toute collaboration. Pour éviter la multiplication des versions, il serait préférable que toutes
collaborations soient transmises aux administrateurs de la faq.
Plusieurs compétences sont actuellement recherchées pour améliorer cette faq :
Rédacteur :
Bien évidemment, toute nouvelle question/réponse est la bienvenue.
Web designer :
Toute personne capable de faire une meilleure mise en page, une feuille de style ou de belles images...
Correcteur :
FAQ Java XML
Malgré nos efforts, des fautes d'orthographe ou de grammaire peuvent subsister. Merci de contacter les administrateurs
si vous en débusquez une... Idem pour les liens erronés.
lien : Quels sont les droits de reproduction de cette FAQ ?
Quels sont les droits de reproduction de cette FAQ ?
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 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 peut 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.
Où trouver d'autres sources d'information ?
•
•
•
•
•
•
Les cours et didacticiels de www.developpez.com
Les forums de la section Java de www.developpez.com
La FAQ Struts
La Javadoc : toutes les informations utiles sur les classes, leurs méthodes ... à toujours avoir sous la main.
Les didacticiels de Sun
La FAQ de JGuru, beaucoup plus complète que celle-ci ...
Remerciements
Un grand merci à tous ceux qui ont pris de leur temps pour la réalisation de cette FAQ.
Aux rédacteurs :
Remerciements tout d'abord à tous ceux qui ont rédigé les questions et les réponses.
Clément Cunin, Johann Heymes, Nicolas Cuny, Ronan Le Gallo, Christophe Ludet, Jean-Baptiste Bugeaud, Sebastien
Andreo, Grégory Danelon, Sébastien Meric, Romain Guy, Pierre-Yves Varoux, Ioan, bahamouth, duj, Braim, bulbo,
Ricky81, Debernad, jcarre, David Seigne, xavlours, christopheJ, willowII, Nourdine Falola, laffreuxthomas.
Aux correcteurs :
FAQ Java XML
Remerciements également aux personnes qui ont relu les textes pour supprimer un maximum de fautes de français.
Nicolas Cuny, Jonathan Muller, Etienne Bar, Bestiol, Ukyuu.
Aux visiteurs :
Remerciements enfin à tous ceux qui ont consulté cette FAQ, et qui, par leurs remarques, nous ont aidé à la
perfectionner.
Et pour finir, un merci tout spécial à Clément Cunin, qui est à l'origine de cette FAQ, à cyberzoide pour notre logo et
ses conseils avisés et à tous les membres de l'équipe qui nous ont fourni outils et logiciels nécessaires pour la réalisation
de ce document.
FAQ Java XML
Sommaire > Généralités
Comment manipuler du XML avec Java ?
Auteurs : 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.
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 n'est pas la seule API disponible pour travailler avec XML. Pour plus d'informations sur les autres API
disponibles regardez : Quelles autres API existent pour travailler avec XML ?.
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 ?
Qu'est-ce que JAXP ?
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).
FAQ Java XML
Pour savoir ce que sont SAX, DOM, XSLT et savoir quand et comment les utiliser regardez : Que sont les API SAX,
DOM et XSLT ?.
lien : Que sont les API SAX, DOM et XSLT ?
Que sont les API SAX, DOM et XSLT ?
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 ?
Quelles autres fonctionnalités sont accessibles avec JAXP ?
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 :
•
•
•
•
•
•
•
•
•
SAX 2.0.2 : http://www.saxproject.org/
XML 1.1 : http://www.w3.org/TR/xml11/
XML 1.0 : http://www.w3.org/TR/REC-xml
XInclude : http://www.w3.org/TR/xinclude/
DOM Level 3 Core : http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407
DOM Level 3 Load and Save : http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407
W3C XML Schema : http://www.w3.org/TR/xmlschema-1/
XSLT 1.0 : http://www.w3.org/TR/1999/REC-xslt-19991116
XPath 1.0 : http://www.w3.org/TR/xpath
FAQ Java XML
Pour des détails sur les autres versions de JAXP, vous pouvez regarder les liens ci-dessous.
lien : Quels sont les rapports entre les versions de JAXP et celles des spécifications XML ?
lien : Quels sont les parseurs XML et processeurs XSLT utilisés par JAXP RI ?
Quels sont les rapports entre les versions de JAXP et celles des spécifications XML ?
Voici les différentes versions des spécifications XML supportées par JAXP RI (Reference Implementation) 1.2 et 1.3.
Versions
JAXP RI 1.3
(présent dans le
JDK 1.5)
JAXP RI 1.2
(présent dans le
JDK 1.4)
XML
1.1/1.0
SAX
SAX 2.0.2
DOM
DOM 3.0
XSLT
XSLT 1.0
XPath
XPath 1.0
1.0
SAX 2.0.0
DOM 2.0
XSLT 1.0
-/-
Pour les anciennes versions de JAXP, vous pouvez trouver de plus amples informations à partir du site de sun : http://
java.sun.com/xml/jaxp/index.jsp
Pour connaître les versions des parseurs et processeurs utilisés par JAXP RI, regardez : Quels sont les parseurs XML
et processeurs XSLT utilisés par JAXP RI ?
lien : Quels sont les parseurs XML et processeurs XSLT utilisés par JAXP RI ?
Je n'ai pas le dernier JDK. Comment faire pour avoir accès à toutes les fonctionnalités de JAXP ?
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.
Quels sont les parseurs XML et processeurs XSLT utilisés par JAXP RI ?
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
JAXP RI 1.3
JAXP RI 1.2
JAXP RI 1.1
Parseur XML
Xerces 2.6.2
Xerces 2.3.0
Crimson
Processeur XSLT
XSLTC (basé sur Xalan 2.6.0)
XSLTC (basé sur Xalan 2.4.1)
XSLTC
FAQ Java XML
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 ?
Comment changer le parseur XML ou le processeur XSLT ?
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.
Comment chercher une DTD dans le CLASSPATH (SAX et DOM) ?
Auteurs : 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 :
- 10 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
FAQ Java XML
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());
Ou trouver plus d'informations sur le format XML ?
Si vous désirez plus d'informations sur le standard XML et ses applications, je vous invite à parcourir ces liens :
•
Cours et tutoriels XML
FAQ Java XML
•
•
•
Forum d'entraide XML
Les meilleurs livres sur XML
Site officiel du W3C
Quelles autres API existent pour travailler avec XML ?
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.
FAQ Java XML
Sommaire > SAX
Comment fonctionne l'API SAX ?
Architecture d'une application utilisant SAX :
Source image : J2EE 1.4 Tutorial
Pour commencer, l'application récupère un parseur (javax.xml.parsers.SAXParser) à partir d'une fabrique de parseurs
(javax.xml.parsers.SAXParserFactory).
Ce parseur parcourt le document XML grâce à un lecteur (org.xml.sax.XMLReader). Ce dernier contient plusieurs
gestionnaires (ou handlers). Ce sont ces différents gestionnaires qui sont chargés du traitement des "événements" lors
du parsing. Voici les quatre principaux types de handlers (interfaces du package org.xml.sax) :
•
•
•
•
Gestionnaire de Contenu : Le ContentHandler est chargé des événements comme le début ou la fin du document,
l'ouverture ou a fermeture de balises ou encore la lecture de caractères.
Gestionnaire d'Erreurs : Le ErrorHandler va traiter les trois types d'erreurs possibles lors du parsing : les erreurs
simples, les erreurs fatales et les warnings.
Gestionnaire de DTD : Le DTDHandler (Document Type Definition) gère les événements relatifs aux DTD.
Gestionnaire d'entités externes : L'EntityResolver est chargé de gérer les entités externes, en fournissant une
InputSource adéquate.
Doit-on implémenter les quatre types de handlers ?
Non, ce n'est pas nécessaire. Il faut utiliser la classe DefaultHandler du package org.xml.sax.helpers.
FAQ Java XML
Le fonctionnement de cette classe peut être comparé à celui des adapters pour les listeners (AWT et Swing). C'est à dire
que cette classe propose une implémentation par défaut des quatres types de gestionnaires.
Vous avez simplement besoin d'étendre cette classe afin d'implémenter les méthodes qui vous sont utiles. Pour un
exemple, regardez : Comment parser un XML avec SAX ?.
Vous pouvez aussi regarder du côté de la classe org.xml.sax.ext.DefaultHandler2, qui propose en plus des quatre handlers
de base une implémentation par défaut de DeclHandler, EntityResolver2 et LexicalHandler. Ces trois gestionnaires sont
des extensions pour SAX2.
lien : Comment parser un XML avec SAX ?
Comment créer un parseur avec SAX ?
Voici un exemple de création de parseur SAX utilisant un DefaultHandler.
import
import
import
import
org.xml.sax.*;
org.xml.sax.helpers.*;
javax.xml.parsers.*;
java.io.*;
public class ExempleSAX {
public static void main(String[] args){
try{
// création d'une fabrique de parseurs SAX
SAXParserFactory fabrique = SAXParserFactory.newInstance();
// création d'un parseur SAX
SAXParser parseur = fabrique.newSAXParser();
// lecture d'un fichier XML avec un DefaultHandler
File fichier = new File("./ExempleSAX.xml");
DefaultHandler gestionnaire = new DefaultHandler();
parseur.parse(fichier, gestionnaire);
}catch(ParserConfigurationException pce){
System.out.println("Erreur de configuration du parseur");
System.out.println("Lors de l'appel à newSAXParser()");
}catch(SAXException se){
System.out.println("Erreur de parsing");
System.out.println("Lors de l'appel à parse()");
}catch(IOException ioe){
System.out.println("Erreur d'entrée/sortie");
System.out.println("Lors de l'appel à parse()");
}
}
}
Ce code ne fait "rien", dans le sens que vous n'aurez aucun effet visible lors de son exécution. Cet exemple met juste en
évidence l'obtention du parseur et les types d'exception susceptibles d'être levées. Pour un exemple d'implémentation
de DefaultHandler regardez : Comment parser un XML avec SAX ?.
Voici quelques propriétés du parseur (SAXParser) que vous pouvez spécifier à la fabrique (SAXParserFactory) :
•
setValidating(boolean) : indique si les parseurs produits par la fabrique doivent valider la DTD. Par défaut, cette
valeur est false.
FAQ Java XML
•
•
•
setSchema(Schema) : indique que les parseurs produits par la fabrique doivent valider le document XML selon
un schéma XML W3C.
setFeature(String, boolean) : permet d'indiquer une propriété particulière pour les parseurs produits par la
fabrique. Pour une liste de ces propriétés, regardez le lien ci-dessous.
setNamespaceAware(boolean) : indique si les parseurs, produits par la fabrique, supportent les espaces de
nommage XML.
Pour finir, vous pouvez configurer encore plus profondément votre parseur avec la méthode setProperty(String, Object)
de la classe SAXParser.
Pour une liste des features et properties, vous pouvez regarder la description du package org.xml.sax.
Pour un exemple simple (affichage sur la sortie standard du XML) téléchargez le fichier ci-dessous.
Pour un exemple plus complet, regardez : Comment parser un XML avec SAX ?.
lien : Comment parser un XML avec SAX ?
ExempleSAX.zip
Comment parser un XML avec SAX ?
Imaginons le fichier XML suivant, qui représente un "annuaire" :
Annuaire XML
<annuaire>
<personne id="0">
<nom>nom0</nom>
<prenom>prenom0</prenom>
<adresse>adresse0</adresse>
</personne>
<personne id="1">
<nom>nom1</nom>
<prenom>prenom1</prenom>
<adresse>adresse1</adresse>
</personne>
</annuaire>
Voici un simple JavaBean Personne nous permettant de représenter une entrée dans cet annuaire :
Personne
public class Personne{
private int id;
private String nom, prenom, adresse;
public Personne(){}
public
public
public
public
int getId(){return id;}
String getNom(){return nom;}
String getPrenom(){return prenom;}
String getAdresse(){return adresse;}
public
public
public
public
void
void
void
void
setId(int id){this.id = id;}
setNom(String nom){this.nom = nom;}
setPrenom(String prenom){this.prenom = prenom;}
setAdresse(String adresse){this.adresse = adresse;}
FAQ Java XML
Personne
public String toString(){
return new StringBuffer("Nom : ").append(nom).append(", ")
.append("Prenom : ").append(prenom).append(", ")
.append("Adresse : ").append(adresse)
.toString();
}
}
Finalement, voici le DefaultHandler nous permettant le parsing du XML. Le parsing va simplement récupérer une List
de Personne.
PersonneHandler
public class PersonneHandler extends DefaultHandler{
//résultats de notre parsing
private List<Personne> annuaire;
private Personne personne;
//flags nous indiquant la position du parseur
private boolean inAnnuaire, inPersonne, inNom, inPrenom, inAdresse;
//buffer nous permettant de récupérer les données
private StringBuffer buffer;
// simple constructeur
public PersonneHandler(){
super();
}
//détection d'ouverture de balise
public void startElement(String uri, String localName,
String qName, Attributes attributes) throws SAXException{
if(qName.equals("annuaire")){
annuaire = new LinkedList<Personne>();
inAnnuaire = true;
}else if(qName.equals("personne")){
personne = new Personne();
try{
int id = Integer.parseInt(attributes.getValue("id"));
personne.setId(id);
}catch(Exception e){
//erreur, le contenu de id n'est pas un entier
throw new SAXException(e);
}
inPersonne = true;
}else {
buffer = new StringBuffer();
if(qName.equals("nom")){
inNom = true;
}else if(qName.equals("prenom")){
inPrenom = true;
}else if(qName.equals("adresse")){
inAdresse = true;
}else{
//erreur, on peut lever une exception
throw new SAXException("Balise "+qName+" inconnue.");
}
}
}
//détection fin de balise
public void endElement(String uri, String localName, String qName)
throws SAXException{
if(qName.equals("annuaire")){
inAnnuaire = false;
}else if(qName.equals("personne")){
annuaire.add(personne);
personne = null;
FAQ Java XML
PersonneHandler
inPersonne = false;
}else if(qName.equals("nom")){
personne.setNom(buffer.toString());
buffer = null;
inNom = false;
}else if(qName.equals("prenom")){
personne.setPrenom(buffer.toString());
buffer = null;
inPrenom = false;
}else if(qName.equals("adresse")){
personne.setAdresse(buffer.toString());
buffer = null;
inAdresse = false;
}else{
//erreur, on peut lever une exception
throw new SAXException("Balise "+qName+" inconnue.");
}
}
//détection de caractères
public void characters(char[] ch,int start, int length)
throws SAXException{
String lecture = new String(ch,start,length);
if(buffer != null) buffer.append(lecture);
}
//début du parsing
public void startDocument() throws SAXException {
System.out.println("Début du parsing");
}
//fin du parsing
public void endDocument() throws SAXException {
System.out.println("Fin du parsing");
System.out.println("Resultats du parsing");
for(Personne p : annuaire){
System.out.println(p);
}
}
}
L'utilisation de ces trois éléments se fait simplement comme ceci :
SAXParserFactory fabrique = SAXParserFactory.newInstance();
SAXParser parseur = fabrique.newSAXParser();
File fichier = new File("./ExempleSAX.xml");
DefaultHandler gestionnaire = new PersonneHandler();
parseur.parse(fichier, gestionnaire);
Il existe des API plus avancées que SAX pour lier des fichiers XML et des Object Java. L'exemple ci-dessus sert juste
de démonstration.
PersonneHandler.zip
Comment gérer les erreurs durant le parsing ?
Au niveau du document XML, il existe deux types d'erreurs possibles.
•
Le document peut être non valide. Dans ce cas, le document n'obéit pas à la DTD ou au schéma qu'on lui a imposé.
FAQ Java XML
•
Le document peut être mal formé. Dans ce cas, il y a simplement une erreur par rapport au standard XML lui
même. Par exemple, des balises mal fermées ou se chevauchant.
Par contre, au niveau du parseur SAX, il existe trois niveaux d'erreurs. Ces trois niveaux d'erreurs sont représentées
au niveau du Gestionnaire d'Erreurs (ErrorHandler) :
•
•
•
Erreur fatale (fatalError(SAXParseException exception) throws SAXException) : Cette erreur ne peut être
récupérée. C'est le cas par exemple pour un document mal formé. Après ce type d'erreur, le parseur SAX arrête
son travail.
Erreur (error(SAXParseException exception) throws SAXException) : Cette erreur peut être récupérée, c'est à dire
que le parseur SAX peut continuer à traiter le reste du document XML. Ce genre d'erreur peut se produire lors
d'une violation d'une contrainte imposée par la DTD ou le schéma.
Warning (warning(SAXParseException exception) throws SAXException) : C'est un simple avertissement. Après
celà, le parseur SAX continue le parsing du document.
Pour plus d'information sur ces erreurs, vous pouvez regarder XML 1.0 W3C Recommendation. Par défaut (cf.
DefautHandler), seules les erreurs fatales sont "traitées".
Voici un exemple d'implémentation de ErrorHandler. Cet exemple détaille sur la sortie standard les erreurs simples et
warnings et lève une SAXException pour les erreurs fatales :
protected String message(SAXParseException e){
String message = "Message : "+e.getMessage()+"\n";
message += "Ligne "+e.getLineNumber()+", colonne "+e.getColumnNumber()+"\n";
message += "Public id : "+e.getPublicId()+"\n";
message += "System id : "+e.getSystemId();
return message;
}
protected void printSAXException(SAXParseException e){
System.out.println(message(e));
if(e.getException() != null){
e.getException().printStackTrace();
}
}
public void warning(SAXParseException exception) throws SAXException{
System.out.println("*** Warning ***");
printSAXException(exception);
}
public void error(SAXParseException exception) throws SAXException{
System.out.println("*** Erreur ***");
}
public void fatalError(SAXParseException exception) throws SAXException{
String message = "*** Erreur fatale ***\n";
message += message(exception);
SAXException se = new SAXException(message, exception);
throw se;
}
FAQ Java XML
Pour un exemple d'utilisation, téléchargez le fichier ci-dessous.
ExempleErrorHandlerSAX.zip
Ou trouver plus d'informations sur SAX ?
Pour de plus amples informations sur SAX, vous pouvez regarder l'excellent tutoriel de Sébatien Méric : Lecture d'un
flux XML via SAX.
Vous pouvez avoir d'autres informations sur l'utilisation de SAX, en anglais cette fois ci, dans le J2EE 1.4 Tutorial.
lien :
Cours Java - Lecture d'un flux XML via SAX
lien :
J2EE 1.4 Tutorial
FAQ Java XML
Sommaire > DOM
Comment fonctionne l'API DOM ?
Architecture d'une application utilisant DOM :
Pour commencer, l'application récupère un constructeur de documents (javax.xml.parsers.DocumentBuilder) à partir
d'une fabrique de constructeurs (javax.xml.parsers.DocumentBuilderFactory).
C'est ce constructeur de documents qui va construire le DOM ou document (org.w3c.Document) à partir de la source
XML.
Le Document est la représentation, sous forme d'arbre "d'objets", des données contenues dans le XML.
DOM reste une API de "bas niveau". Si vous voulez travailler de manière plus orientée objet, avec des arbres XML,
regardez du côté de jdom et dom4j (cf. Quelles autres API existent pour travailler avec XML ?).
Pour un exemple pratique d'utilisation, regardez : Comment ouvrir un fichier XML avec DOM ? .
lien : Comment ouvrir un fichier XML avec DOM ?
lien : Quelles autres API existent pour travailler avec XML ?
Comment ouvrir un fichier XML avec DOM ?
Voici un exemple, qui montre comment ouvrir un fichier XML avec l'API DOM :
FAQ Java XML
import
import
import
import
javax.xml.parsers.*;
org.w3c.dom.*;
org.xml.sax.*;
java.io.*;
public class ExempleDOM{
public static void main(String[] args){
try{
// création d'une fabrique de documents
DocumentBuilderFactory fabrique = DocumentBuilderFactory.newInstance();
// création d'un constructeur de documents
DocumentBuilder constructeur = fabrique.newDocumentBuilder();
// lecture du contenu d'un fichier XML avec DOM
File xml = new File("ExempleDOM.xml");
Document document = constructeur.parse(xml);
//traitement du document
//voir ExempleDOM.zip
}catch(ParserConfigurationException pce){
System.out.println("Erreur de configuration du parseur DOM");
System.out.println("lors de l'appel à fabrique.newDocumentBuilder();");
}catch(SAXException se){
System.out.println("Erreur lors du parsing du document");
System.out.println("lors de l'appel à construteur.parse(xml)");
System.out.println("Erreur d'entrée/sortie");
System.out.println("lors de l'appel à construteur.parse(xml)");
}
}
}
La configuration de la fabrique est quasiment identique à celle d'une fabrique de parseur SAX. Regardez : Comment
créer un parseur avec SAX ?.
Pour voir comment parcourir votre document, regardez : Comment parcourir l'arborescence d'un DOM ?
Vous pouvez télécharger un exemple simple (affichage sur la sortie standard du DOM) ci-dessous.
lien : Comment parcourir l'arborescence d'un DOM ?
ExempleDOM.zip
Comment gérer les erreurs durant la création d'un DOM ?
Tout comme pour SAX, on peut gérer les erreurs lors de la construction d'un Document grâce à un ErrorHandler.
Par exemple :
public class GestionnaireDErreurs implements ErrorHandler{
protected String message(SAXParseException e){
String message = "Message : "+e.getMessage()+"\n";
message += "Ligne "+e.getLineNumber()+", colonne "+e.getColumnNumber()+"\n";
message += "Public id : "+e.getPublicId()+"\n";
message += "System id : "+e.getSystemId();
return message;
}
protected void printSAXException(SAXParseException e){
FAQ Java XML
System.out.println(message(e));
if(e.getException() != null){
e.getException().printStackTrace();
}
}
public void warning(SAXParseException exception) throws SAXException{
System.out.println("*** Warning ***");
}
public void error(SAXParseException exception) throws SAXException{
System.out.println("*** Erreur ***");
}
public void fatalError(SAXParseException exception) throws SAXException{
String message = "*** Erreur fatale ***\n";
message += message(exception);
SAXException se = new SAXException(message, exception);
throw se;
}
}
Exemple d'utilisation :
// création d'une fabrique de documents
// création et configuration du constructeur de documents
constructeurs.setErrorHandler(new GestionnaireDErreurs());
Document document = constructeur.parse(new File("ExempleDOM.xml"));
lien : Comment gérer les erreurs durant le parsing ?
Quelles informations peut on récupérer sur un DOM ?
Vous pouvez obtenir de nombreuses informations sur un document XML à partir d'une instance de
org.w3c.dom.Document.
Voici un exemple récupérant, à partir d'un Document, des informations générales, des informations sur le type de
document et sur la configuration DOM :
public static void printDOMInfos(Document document){
System.out.println("INFORMATIONS GENERALES");
String uri = document.getDocumentURI();
System.out.println("URI = "+uri);
String xVersion = document.getXmlVersion();
System.out.println("Version XML = "+xVersion);
String xEncoding = document.getXmlEncoding();
System.out.println("XML encoding = "+xEncoding);
String iEncoding = document.getInputEncoding();
System.out.println("Input encoding = "+iEncoding);
boolean standalone = document.getXmlStandalone();
System.out.println("XML standalone = "+standalone);
FAQ Java XML
boolean strictError = document.getStrictErrorChecking();
System.out.println("Strict error checking = "+strictError+"\n");
System.out.println("DOCTYPE");
printDoctype(document.getDoctype());
System.out.println("CONFIGURATION");
printDOMConfiguration(document.getDomConfig());
}
Pour le détail des méthodes printDoctype et printDOMConfiguration, téléchargez le fichier ci-dessous.
InfosDOM.zip
Quels sont les différents types de nodes ?
Avant de commencer à parcourir un arbre DOM et à en extraire les données, il est nécessaire de bien comprendre
sa structure. Il est notamment nécessaire de bien faire la distinction entre les différents types de nodes. Une erreur
couramment commise est le fait de confondre Node et Element.
•
•
Node (org.w3c.dom.Node) : Un Node (ou noeud) est l'unité de base de l'arbre. Cela peut être du texte, un
élément, une portion CDATA ou encore une instruction. Pour connaître le type d'un Node utilisez la méthode
getNodeType().
Element (org.w3c.dom.Element) : L'interface Element définit un élément au sens XML (XHTML ou HTML). Un
élément est constitué d'un tag, d'attributs et d'un contenu (autres nodes et éléments).
Voici les différents types de nodes et le résultat des méthodes capables d'en découvrir le contenu.
FAQ Java XML
Interface
(org.w3c.dom)
Attr
getNodeType() getNodeName() getNodeValue()
(short)
(String)
(String)
ATTRIBUTE_NODE
Le nom de
La valeur de
l'attribut.
l'attribut.
CDATASection CDATA_SECTION_NODE
"#cdata-section" Le contenu de la
section CDATA.
Comment
COMMENT_NODE
"#comment"
Le contenu du
commentaire.
Document
DOCUMENT_NODE
"#document"
null
DocumentFragment
DOCUMENT_FRAGMENT_NODE
"#documentnull
fragment"
DocumentType DOCUMENT_TYPE_NODE
Le nom du type. null
Element
ELEMENT_NODELe nom du tag. null
Entity
ENTITY_NODE Le nom de
null
l'entité.
EntityReference ENTITY_REFERENCE_NODE
Le nom
null
de l'entité
réferencée.
Notation
NOTATION_NODE
Le nom de la
null
notation.
ProcessingInstruction
PROCESSING_INSTRUCTION_NODE
La cible de
Les données de
l'instruction.
l'instruction.
Text
TEXT_NODE
"#text"
Le texte en luimême.
getAttributes()
(NamedNodeMap)
null
null
null
null
null
null
Les attributs de
l'élément.
null
null
null
null
null
Si vous voulez récupérer le texte contenu dans un node (et dans l'ensemble de ses enfants), utilisez la méthode
getTextContent().
Pour éviter toute ambiguité lors de l'utilisation d'Element, préférez les méthodes spécifiques de cette interface (cf.
Comment accèder au contenu et aux attributs d'un Element ?).
lien : Comment parcourir l'arborescence d'un DOM ?
lien : Comment accèder au contenu et aux attributs d'un Element ?
Comment parcourir l'arborescence d'un DOM ?
La première chose à faire pour commencer à parcourir votre arbre DOM est de récupérer la racine.
Document document = ...;
Element racine = document.getDocumentElement();
A partir de cette racine, vous pouvez parcourir l'enseble du document. Voici les méthodes à utiliser :
Méthodes de l'interface Node
•
•
•
getChildNodes : retourne une NodeList contenant l'ensemble des nodes enfants.
getFirstChild : retourne le premier Node enfant.
getLastChild : retourne le dernier Node enfant.
FAQ Java XML
•
•
•
getNextSibling : retourne la prochaine occurrence du Node.
getParentNode : retourne le noeud parent du Node.
getPreviousSibling: retourne la précédente occurrence du Node.
Méthodes de l'interface Element
•
getElementsByTagName : retourne une NodeList contenant les éléments enfants dont le tag correspond au nom
passé en paramètre (* pour renvoyer tous les éléments).
getElementsByTagNameNS : même chose que getElementByTagName, avec prise en compte des namespace.
•
Comment accèder au contenu et aux attributs d'un Element ?
Pour accèder au contenu et aux attributs d'un Element, on peut utiliser les méthodes getTextContent et
getAttributesByTagName.
Voici un exemple, dans lequel on extrait d'un XHTML les liens et leurs propriétés :
public static List<Element> getLinks(String xhtmlUrl) throws Exception{
List<Element< liens = new ArrayList<Element>();
InputStream stream = null;
try{
fabrique.setValidating(true);
URL url = new URL(xhtmlUrl);
stream = url.openStream();
Document document = constructeur.parse(stream);
Element racine = document.getDocumentElement();
String tag = "a";
NodeList liste = racine.getElementsByTagName(tag);
for(int i=0; i<liste.getLength(); i++){
Element e = (Element)liste.item(i);
if(e.hasAttribute("href"))liens.add(e);
}
throw e;
}finally{
try{stream.close();}catch(Exception e){}
return liens;
}
}
String url = "http://www.w3.org/";
List<Element> liens = getLinks(url);
for(Element lien : liens){
String href = lien.getAttribute("href");
String texte = lien.getTextContent();
texte = (texte!=null)?texte:href;
System.out.println("Lien "+texte+" pointe sur "+href);
}
FAQ Java XML
Vous pouvez télécharger cet exemple ci-dessous.
Pour avoir plus d'informations sur un Element (ou un attribut) définit par un schéma, utilisez la méthode
getSchemaTypeInfo().
LiensXHTML.zip
Comment connaitre le nombre d'enfants d'un Element ?
Cela dépend de ce que vous entendez par "enfant". Comme toujours, il faut bien faire la différence entre Node et
Element.
Nombre d'enfants de type Node
Element e = ...;
NodeList enfants = e.getChildNodes();
int nombreDeNoeudsEnfants = enfants.getLength();
Nombre d'enfants de type Element
Element e = ...;
NodeList enfants = e.getElementsByTagName("*");
int nombreDElementsEnfants = enfants.getLength();
Cela méritait d'être souligné car l'erreur (la confusion entre Node et Element) est souvent commise.
Ces méthodes sont relativement limitées. Pour des opérations plus complexes, regardez du côté de XPath : Qu'est ce
que XPath ? Pourquoi l'utiliser ?.
lien : Qu'est ce que XPath ? Pourquoi l'utiliser ?
Comment modifier un DOM (document, nodes et éléments) ?
L'API DOM fournit avec les classes Document, Node et ses dérivées (Element, par exemple) tout un ensemble de
méthodes permettant la modification du document. Voici, en résumé, les méthodes disponibles pour Document, Node
et Element :
Méthodes de Document
•
•
•
•
•
adoptNode(Node source) : importe le noeud passé en paramètre. Si ce noeud appartient déjà à une arborescence,
il en est supprimé. Le méthode retourne le noeud adopté ou null si l'opération échoue.
importNode(Node importedNode, boolean deep) : importe, dans le document, le noeud passé en argument et ses
enfants (si deep vaut true). Le noeud ainsi importé n'a pas de parent. Le noeud ainsi importé, contrairement à
adoptNode, est une simple copie. Le noeud est retourné comme résultat.
renameNode(Node n, String namespaceURI, String qualifiedName) : renomme le noeud passé en paramètre et
retourne ce dernier. Attention, seuls les nodes de type item et Attr peuvent être ainsi renommés.
setDocumentURI(String documentURI) : remplace l'URI du document.
setXmlStandalone(boolean xmlStandalone) : définit si le XML est "standalone" ou non.
FAQ Java XML
•
•
setXmlVersion(String xmlVersion) : définit la version du XML ("1.0" par défaut).
normalizeDocument() : cette méthode valide les modifications apportées au DOM. Voir aussi la méthode
normalize() de l'interface Node.
Méthodes de Node
•
•
•
•
•
•
•
appendChild(Node newChild) : ajoute le noeud passé en paramètre à la fin des autres enfants du node. cette
méthode retourne le noeud ajouté.
insertBefore(Node newChild, Node refChild) : insère "newChild" avant "refChild" et retourne "newChild".
removeChild(Node oldChild) : supprimme le noeud passé en paramètre et le retourne.
replaceChild(Node newChild, Node oldChild) : remplace oldChild par newChild et retourne oldChild.
setNodeValue(String nodeValue) : met "nodeValue" comme valeur pour le noeud. Voir Quels sont les différents
types de nodes ? pour connaître les valeurs possibles.
setPrefix(String prefix) : met "prefix" comme nouveau préfixe du noeud.
setTextContent(String textContent) : met "textContent" comme contenu du noeud. Attention, ceci supprimme
l'ensemble des noeuds enfants.
Méthodes de Element
•
•
•
removeAttribute(String name) : supprimme l'attribut nommé.
setAttribute(String name, String value) : crée un nouvel attribut (ou modifie la valeur de l'attribut si il existe déjà).
setIdAttribute(String name, boolean isId) : crée un nouvel attribut de type ID (ou modifie la valeur de l'attribut
si il existe déjà).
Ces trois méthodes ont toutes des variantes. Les méthodes XXXNode permettent notamment de retourner l'instance
de Attr modifiée ou supprimmée.
Pour un exemple d'utilisation de quelques une de ces méthodes, regardez Comment créer un DOM de toutes pièces?.
Ces méthodes ne modifient que l'arbre en mémoire. Pour modifier la source XML, vous devez utiliser XSLT : Comment
créer ou modifier un fichier XML avec DOM et XSLT ?.
lien : Comment créer ou modifier un fichier XML avec DOM et XSLT ?
lien : Comment créer un DOM de toutes pièces?
lien : Quels sont les différents types de nodes ?
Comment créer un DOM de toutes pièces?
La classe DocumentBuilder permet de créer une nouvelle instance de Document grâce à la méthode newDocument().
Pour le reste, Document fournit un ensemble de méthodes createXXX, qui vont vous permettre de créer des nodes,
éléments, commentaires et attributs.
Voici un exemple :
// Création d'un nouveau DOM
Document document = constructeur.newDocument();
// Propriétés du DOM
document.setXmlVersion("1.0");
FAQ Java XML
document.setXmlStandalone(true);
// Création de l'arborescence du DOM
Element racine = document.createElement("annuaire");
racine.appendChild(document.createComment("Commentaire sous la racine"));
Element personne = document.createElement("personne");
personne.setAttribute("id","0");
racine.appendChild(personne);
Element nom = document.createElement("nom");
nom.setTextContent("un nom");
personne.appendChild(nom);
Element prenom = document.createElement("prenom");
prenom.setTextContent("un prénom");
personne.appendChild(prenom);
Element adresse = document.createElement("adresse");
adresse.setTextContent("une adresse");
personne.appendChild(adresse);
document.appendChild(racine);
Transformé en XML ce DOM donnerait :
<?xml version="1.0" encoding="ISO-8859-1"?>
<annuaire>

<personne id="0">
<nom>un nom</nom>
<prenom>un prénom</prenom>
<adresse>une adresse</adresse>
</personne>
</annuaire>
Pour sauvegarder ce DOM sous forme de XML, vous devrez utiliser XSLT (cf. Comment créer ou modifier un fichier
XML avec DOM et XSLT ?). Vous pouvez télécharger une exemple ci-dessous.
CreationDOM.zip
Comment convertir un XML DOM en String ?
Auteurs : willowII ,
Le bout de code suivant utilise la classe Transformer pour écrire un document DOM dans une String en passant par
un StringWriter.
Document document = ...;
DOMSource domSource = new DOMSource(document);
StringWriter writer = new StringWriter();
StreamResult result = new StreamResult(writer);
TransformerFactory tf = TransformerFactory.newInstance();
Transformer transformer = tf.newTransformer();
transformer.transform(domSource, result);
String stringResult = writer.toString();
FAQ Java XML
Sommaire > XSLT
Comment fonctionne l'API XSLT ?
Architecture d'une application utilisant XSLT :
L'application commence par récupérer un transformeur (javax.xml.transform.Transformer) à partir d'une fabrique de
transformeurs (javax.xml.transform.TransformerFactory).
C'est ce transformeur qui va être chargé de transformer une source (javax.xml.transform.Source) en résultat
(javax.xml.transform.Resultat). Par défaut, si aucune véritable transformation n'est demandée, le transformeur va
simplement copier la source dans le résultat.
La source et le résultat peuvent être respectivement un parseur SAX, un DOM, une InputSource et un ensebble
d'évènements SAX, un DOM ou une OutputSource.
Pour une configuration pratique du transformeur, regardez : Comment créer et configurer un Transformer (pour SAX
et DOM) ?
Pour des exemples, regardez : Comment créer ou modifier un fichier XML avec DOM et XSLT ? et Comment créer
ou modifier un fichier XML avec SAX et XSLT ?
lien : Comment créer et configurer un Transformer (pour SAX et DOM) ?
FAQ Java XML
lien : Comment créer ou modifier un fichier XML avec SAX et XSLT ?
Comment créer et configurer un Transformer (pour SAX et DOM) ?
Voici un exemple de création et de configuration d'un Transformer :
// création de la fabrique
TransformerFactory fabrique = TransformerFactory.newInstance();
// récupération du transformeur
Transformer transformer = fabrique.newTransformer();
/**
* pour définir une feuille de style, vous pouvez utiliser une Source comme paramètre
* File stylesheet = new File("stylesheet.xsl");
* StreamSource stylesource = new StreamSource(stylesheet);
* Transformer transformer = fabrique.newTransformer(stylesource);
*/
// configuration du transformeur
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1");
Pour configurer votre fabrique, regardez par exemple : Comment gérer les erreurs durant la transformation ? .
Pour connaître toutes les clefs disponibles pour le Transformer, regardez la classe javax.xml.transform.OutputKeys.
lien : Comment gérer les erreurs durant la transformation ?
Que sont les Templates crées par TransformerFactory?
Les fabriques de transformeurs (javax.xml.transform.TransformerFactory) peuvent construire deux types d'objets :
les Transformer et les Templates.
Une Template est un "conteneur" de Transformer. De plus, contrairement à un simple Transformer, la Template est
"thread-safe" (elle peut être utilisée par plusieurs Threads sans risque).
La création et configuration d'une Template se font de la même manière que pour un Transformer. Par exemple :
// création de la fabrique
// récupération de Templates
Templates template = fabrique.newTemplates();
/**
* pour définir une feuille de style, vous pouvez utiliser une Source comme paramètre
* File stylesheet = new File("stylesheet.xsl");
* StreamSource stylesource = new StreamSource(stylesheet);
* Templates template = fabrique.newTemplates(stylesource);
*/
// configuration du transformeur
Transformer transformer = template.getTransformer();
FAQ Java XML
lien : Comment créer et configurer un Transformer (pour SAX et DOM) ?
Comment gérer les erreurs durant la transformation ?
La gestion des erreurs se fait de la même manière que pour SAX/DOM et les ErrorHandler. On peut gérer les erreurs
durant la transformation avec un ErrorListener (javax.xml.transform). Par exemple :
import javax.xml.transform.*;
public class EcouteurDErreurs implements ErrorListener{
public void warning(TransformerException exception)
throws TransformerException{
printException(exception);
}
public void error(TransformerException exception)
}
public void fatalError(TransformerException exception)
throw exception;
}
private void printException(TransformerException exception){
String message = exception.getMessageAndLocation() ;
System.out.println(message);
}
}
Utilisation :
Transformer transformeur = ...;
transformeur.setErrorListener(new EcouteurDErreurs());
lien : Comment gérer les erreurs durant le parsing ?
lien : Comment gérer les erreurs durant la création d'un DOM ?
Comment créer ou modifier un fichier XML avec DOM et XSLT ?
Voici une méthode permettant de créer un fichier XML à partir d'un DOM :
public static void transformerXml(Document document, String fichier) {
try {
// Création de la source DOM
Source source = new DOMSource(document);
// Création du fichier de sortie
File file = new File(fichier);
Result resultat = new StreamResult(fichier);
// Configuration du transformer
FAQ Java XML
// Transformation
transformer.transform(source, resultat);
e.printStackTrace();
}
}
Vous pouvez télécharger les sources d'un exemple complet ci-dessous.
lien : Comment créer ou modifier un fichier XML avec SAX et XSLT ?
lien : Comment créer un fichier HTML à partir d'un XML ?
lien : Comment créer un fichier PDF à partir d'un XML ?
CreationDOM.zip
Comment créer ou modifier un fichier XML avec SAX et XSLT ?
Pour créer un fichier XML avec SAX et XSLT, il nous faut créer une SAXSource. Nous allons prendre l'exemple de
l'écriture dans un fichier d'un "annuaire" composé d'une List de JavaBean Personne. Voici les étapes nécessaires à sa
création de la source :
•
•
•
•
Création du bean : Personne définit un élément de l'annuaire..
Création d'une InputSource : AnnuaireSource définit la List des personnes de l'annuaire.
Création d'un XMLReader : AnnuaireReader est capable de "parser" la source pour lever des évènements SAX.
Création de la SAXSource, à partir de l'InputSource et du Reader.
Après celà la transformation se fera comme pour un arbre DOM et un fichier : avec un Transformer et un StreamResult
(pour le fichier de destination).
Personne
/**
* Voir zip
*/
AnnuaireSource
public class AnnuaireSource extends InputSource{
private List<Personne> personnes;
public AnnuaireSource(List<Personne> personnes){
super();
this.personnes = personnes;
}
public List<Personne> getPersonnes(){
return personnes;
}
// En fait, contrairement à cet exemple de nombreuses méthodes d'InputSource travaillent avec des streams.
// Cela peut vous simplifier le travail sur des fichiers XML existants.
}
AnnuaireReader
public class AnnuaireReader implements XMLReader{
private ContentHandler handler;
FAQ Java XML
AnnuaireReader
private AttributesImpl atts = new AttributesImpl();
//méthode qui vont être utilisées par le transformer
public ContentHandler getContentHandler(){
return handler;
}
public void setContentHandler(ContentHandler handler){
this.handler = handler;
}
// parsing d'une liste de personnes
public void parse(InputSource input) throws IOException,SAXException{
if(!(input instanceof AnnuaireSource)){
String m = "Le seul argument possible pour parse est une AnnuaireSource";
throw new SAXException(m);
}
if(handler == null){
throw new SAXException("Pas de ContentHandler");
}
AnnuaireSource source = (AnnuaireSource)input;
List<Personne> personnes = source.getPersonnes();
handler.startDocument();
handler.startElement("", "annuaire", "annuaire", atts);
for(Personne p : personnes){
atts.addAttribute("","id","id","",String.valueOf(p.getId()));
handler.startElement("", "personne", "personne", atts);
atts.clear();
handler.startElement("", "nom", "nom", atts);
char[] nom = p.getNom().toCharArray();
handler.characters(nom,0,nom.length);
handler.endElement("", "nom", "nom");
handler.startElement("", "prenom", "prenom", atts);
char[] prenom = p.getPrenom().toCharArray();
handler.characters(prenom,0,prenom.length);
handler.endElement("", "prenom", "prenom");
handler.startElement("", "adresse", "adresse", atts);
char[] adresse = p.getAdresse().toCharArray() ;
handler.characters(adresse,0,adresse.length);
handler.endElement("", "adresse", "adresse");
handler.endElement("", "personne", "personne");
}
handler.endElement("", "annuaire", "annuaire");
handler.endDocument();
}
public void parse(String systemId) throws IOException,SAXException{
String m = "Le seul argument possible pour parse est une AnnuaireSource";
throw new SAXException(m);
}
// autres méthodes à implémenter
}
// Création de l'annuaire
List<Personne> annuaire = new ArrayList<Personne>();
// ...
//remplissage de l'annuaire
XMLReader annuaireReader = new AnnuaireReader();
InputSource annuaireSource = new AnnuaireSource(annuaire);
FAQ Java XML
Source source = new SAXSource(annuaireReader, annuaireSource);
File file = new File("CreationSAX.xml");
Result resultat = new StreamResult(file);
// Transformation
Téléchargez le code source complet ci-dessous.
SaxXSLT.zip
Comment créer un fichier HTML à partir d'un XML ?
La création d'un document HTML avec XSLT passe par l'utilisation d'une feuille de style (XSL). Voici le code à utiliser :
public static void creerHTML(String xml, String xsl, String html) throws Exception{
DocumentBuilderFactory fabriqueD = DocumentBuilderFactory.newInstance();
DocumentBuilder constructeur = fabriqueD.newDocumentBuilder();
File fileXml = new File(xml);
Document document = constructeur.parse(fileXml);
Source source = new DOMSource(document);
File fileHtml = new File(html);
Result resultat = new StreamResult(fileHtml);
TransformerFactory fabriqueT = TransformerFactory.newInstance();
StreamSource stylesource = new StreamSource(xsl);
Transformer transformer = fabriqueT.newTransformer(stylesource);
transformer.setOutputProperty(OutputKeys.METHOD, "html");
// Transformation
}
Vous pouvez télécharger ci-dessous un exemple simple avec xml, xsl et classe de test.
FAQ Java XML
CreationHTML.zip
Comment créer un fichier PDF à partir d'un XML ?
L'API standard ne fournit pas de mécanisme pour transformer un XML en PDF. Par contre, une très bonne librairie
existe pour ca : FOP (Formatting Object Processor). Voici un exemple d'utilisation de FOP :
public static void creerPDF(String xml, String xsl, String pdf) throws Exception{
// création du résultat (pdf)
Driver driver = new Driver();
driver.setRenderer(Driver.RENDER_PDF);
driver.setOutputStream(new java.io.FileOutputStream(pdf));
Result resultat = new SAXResult(driver.getContentHandler());
// récupération de la source xml
Source source = new StreamSource(xml);
// création du transformer en fonction du xsl
Source style = new StreamSource(xsl);
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer(style);
// transformation
}
Vous pouvez télécharger un exemple complet avec xml et xsl ci dessous. Verifiez bien que la librairie FOP (et ses
dépendances) se trouve bien dans votre classpath avant de compiler/exécuter l'exemple.
CreationPDF.zip
Comment enchaîner les transformations XSLT ?
Vous pouvez très bien vouloir enchaîner les transformations XSLT. Par enchaîner, on entend appliquer plusieurs
transformations successives à un document XML. Chaque résultat de transformation devenant ainsi la source de la
prochaine. Pour vous aider à faire ceci, le package org.xml.sax vous propose la classe XMLFilter. Voici le principe :
FAQ Java XML
Source image = J2EE 1.4 Tutorial
Voici une méthode prenant en arguments un fichier XML, deux feuilles de style xsl (les transformations à enchaîner)
et un fichier html de sortie.
public static void transformer(File xml, File xsl1, File xsl2, File html) throws Exception{
// Création du reader initial
SAXParserFactory spf = SAXParserFactory.newInstance();
spf.setNamespaceAware(true);
XMLReader reader = spf.newSAXParser().getXMLReader();
// Création des filtres à appliquer au reader
SAXTransformerFactory stf = (SAXTransformerFactory)TransformerFactory.newInstance();
XMLFilter filtre1 = stf.newXMLFilter(new StreamSource(xsl1));
XMLFilter filtre2 = stf.newXMLFilter(new StreamSource(xsl2));
// On "lie" le reader aux filtres
filtre1.setParent(reader);
filtre2.setParent(filtre1);
// Création de la source : c'est le dernier filtre de la chaîne
// C'est lui qui indiquera au transformer quelles transformations à faire "avant"
// Le résultat est le fichier HTML
SAXSource source = new SAXSource(filtre2, new InputSource(new FileInputStream(xml)));
StreamResult resultat = new StreamResult(new FileOutputStream(html));
//Transformation en chaîne
Transformer transformer = stf.newTransformer();
}
Vous pouvez télécharger un exemple complet d'utilisation ci-dessous.
ChaineXSLT.zip
FAQ Java XML
Sommaire > XPath
Qu'est ce que XPath ? Pourquoi l'utiliser ?
XPath, ou XML Path Language, est un langage dont le but premier est de permettre la "sélection" de noeuds d'un
document XML. Cette "sélection" se fait grâce à un système d'adressage que l'on pourrait comparer aux URL. En
plus de cela, XPath fournit un ensemble de fonctions sur les chaînes de caractères ou encore des fonctions permettant
d'effectuer des tests.
XPath peut être utilisé en combinaison avec XSLT et XPointer. Pour découvrir toutes les possibilités de ce langage, vous
pouvez regarder la spécification du W3C à cette adresse : http://www.w3.org/TR/xpath.
Nous ne nous attarderons pas sur les complexités de ce langage. De plus, la spécification n'étant pas toujours évidente
à décoder vous pouvez regarder "Où trouver des informations et cours sur le langage XPath lui-même ?" pour de plus
amples informations.
Cette partie de la FAQ se contentera de vous fournir les bases nécessaires à l'utilisation du package javax.xml.xpath
appartenant au JDK standard depuis Java 5.0. Pour l'utilisation de XPath avec d'autres API ou l'utilisation de ce
package avec des JDK antérieurs au 5.0, vous pouvez suivre ces liens :
•
•
Je n'ai pas le dernier JDK. Comment faire pour avoir accès à toutes les fonctionnalités de JAXP ?
Comment travailler avec XPath si je n'ai pas Java 5.0 ?
lien : Où trouver des informations et cours sur le langage XPath lui-même ?
lien : Je n'ai pas le dernier JDK. Comment faire pour avoir accès à toutes les fonctionnalités de JAXP ?
lien : Comment travailler avec XPath si je n'ai pas Java 5.0 ?
Comment fonctionne le package javax.xml.xpath ?
Voici un schéma simplifié du fonctionnement du package javax.xml.xpath :
FAQ Java XML
Le principe est simple. On commence par récupérer une instance de XPath à partir d'une fabrique (XPathFactory).
Ensuite, on construit une source XML (InputSource) à partir du document XML sur lequel on veut travailler. Il ne reste
plus qu'à construire une XPathExpression à partir du XPath. Cette XPathExpression va retourner (grâce à sa méthode
evaluate()) un Object qui peut correspondre à un NodeSet, un Node, un String, un Number ou un Boolean.
Pour voir le code exécutant ces opérations regardez : Comment obtenir une XPathExpression ?
Attention : NODE, NUMBER, STRING, etc. sont des instances de QName définies comme des constantes de la classe
XPathConstants. Il ne faut pas les confondre avec des "vrais" String ou Number. Pour plus d'informations, regardez :
Que fait exactement la méthode evaluate ?.
lien : Comment obtenir une XPathExpression ?
lien : Que fait exactement la méthode evaluate ?
Comment obtenir une XPathExpression ?
Voici deux méthodes statiques montrant comment créer une instance de XPath et lui faire évaluer une XPathExpression.
Exemple avec un Document DOM :
public static void evaluerDOM(Document document, String expression, QName retour){
try{
//création du XPath
XPathFactory fabrique = XPathFactory.newInstance();
XPath xpath = fabrique.newXPath();
//évaluation de l'expression XPath
FAQ Java XML
XPathExpression exp = xpath.compile(expression);
Object resultat = exp.evaluate(document,retour);
System.out.println(resultat);
}catch(XPathExpressionException xpee){
xpee.printStackTrace();
}
}
Exemple avec une InputSource SAX :
public static void evaluerSAX(File fichier, String expression, QName retour){
try{
//création de la source
InputSource source = new InputSource(new FileInputStream(fichier));
Object resultat = exp.evaluate(source,retour);
System.out.println(resultat);
ioe.printStackTrace();
}
}
Informations supplémentaires :
On peut noter qu'on n'est pas obligé de passer par une instance de XPathExpression. En effet, la classe XPath dispose
elle aussi d'une méthode evaluate().
Ainsi, on pourrait remplacer le code de la première méthode par :
XPath xpath = XPathFactory.newInstance().newXPath();
Object resultat = xpath.evaluate(expression,document,retour);
Pour connaître tous les arguments et types de retour possibles pour la méthode evaluate() regardez : Que fait exactement
la méthode evaluate ?
Vous pouvez télécharger un exemple simple d'utilisation de ces deux méthodes ci-dessous.
lien : Que fait exactement la méthode evaluate ?
ExempleXPath.zip
Que fait exactement la méthode evaluate ?
Que ce soit dans la classe XPath ou dans XPathExpression, la méthode evaluate() a quatre variantes. Pour toutes ces
méthodes, l'argument de type String nommé expression correspond à l'expression XPath à évaluer.
FAQ Java XML
Arguments
String expression, Object item,
QName returnType
Object
Retour
String expression, Object item
String
String expression, InputSource
source, QName returnType
Object
String expression, InputSource
source
String
Description
L'argument item correspond
à un élément XML à évaluer.
Celui-ci peut être un Document,
un DocumentFragment, un
Node ou encore une NodeList
(package org.w3c.dom).
L'argument returnType doit
être une des constantes de
la classe XPathConstants :
NUMBER, STRING, BOOLEAN,
NODE ou NODESET (une
IllegalArgumentException est
levée sinon). Cet argument définit
simplement le type de l'Object
retourné par la méthode (voir
tableau ci-dessous).
Cette méthode a le même
comportement que
evaluate(expression, item,
returnType) avec returnType égal à
XPathConstants.STRING.
L'argument source correspond à
la source XML à évaluer. Celle-ci
doit être une InputSource (package
org.xml.sax). L'argument returnType
doit être une des constantes
de la classe XPathConstants :
NUMBER, STRING, BOOLEAN,
NODE ou NODESET (une
IllegalArgumentException est
levée sinon). Cet argument définit
simplement le type de l'Object
retourné par la méthode (voir
tableau ci-dessous).
Cette méthode a le même
comportement que
evaluate(expression, source,
returnType) avec returnType égal à
XPathConstants.STRING.
Les types de retour correspondent à la spécification XPath 1.0 : http://www.w3.org/TR/xpath. Voici les correspondances
entre les constantes de XPathConstants (instances de QName) et les types de retour de la méthode evaluate :
QName
XPathConstants.NODE
Type de retour
org.w3c.dom.Node
XPathConstants.NODESET
org.w3c.dom.NodeList
Description
Quand un Node est requis comme
type de retour, la méthode
evaluate() retourne une instance
de org.w3c.Node correspondant
au premier noeud satisfaisant
l'expression XPath.
Quand un NodeSet est requis
comme type de retour, la méthode
FAQ Java XML
XPathConstants.STRING
java.lang.String
XPathConstants.BOOLEAN
java.lang.Boolean
XPathConstants.NUMBER
java.lang.Double
evaluate() retourne une instance de
org.w3c.NodeList correspondant aux
noeuds sélectionnés par l'expression
XPath.
Quand un String est requis comme
type de retour la méthode evaluate()
retourne le contenu du ou des noeuds
satisfaisant l'expression XPath
(enfants compris).
Quand un Boolean est requis comme
retourne Boolean.TRUE si au
moins un noeud est sélectionné,
Boolean.FALSE sinon.
Quand un Number est requis comme
essaye de transformer le contenu du
noeud sélectionné en Double.
Pour un exemple pratique d'utilisation de chacune de ces méthodes regardez les liens ci-dessous.
•
•
•
•
•
Comment récupérer un ensemble de noeuds avec XPath ?
Comment récupérer un Node avec XPath ?
Comment récupérer un booléen à partir d'une expression XPath ?
Comment récupérer une chaîne de caractères avec XPath ?
Comment récupérer un nombre à partir d'une expression XPath ?
lien : Comment récupérer un ensemble de noeuds avec XPath ?
lien : Comment récupérer un Node avec XPath ?
lien : Comment récupérer un booléen à partir d'une expression XPath ?
lien : Comment récupérer une chaîne de caractères avec XPath ?
lien : Comment récupérer un nombre à partir d'une expression XPath ?
Comment utiliser les espaces de nommage avec XPath ?
Pour utiliser les espaces de nommage, vous pouvez utiliser la méthode setNamespaceContext(NamespaceContext) de la
classe XPath. Par exemple :
NamespaceContext namespace = new NamespaceContext(){
public String getNamespaceURI(String prefix){
if("content".equals(prefix)){
return "http://purl.org/rss/1.0/modules/content/";
}else{
return null;
}
}
public String getPrefix(String namespaceURI){
if("http://purl.org/rss/1.0/modules/content/".equals(namespaceURI)){
return "content";
}else{
return null;
}
}
public Iterator getPrefixes(String namespaceURI){
FAQ Java XML
return null;
}
};
xpath.setNamespaceContext(namespace);
Pour voir un exemple d'utilisation, regardez : Comment récupérer une chaîne de caractères avec XPath ?
lien : Comment récupérer une chaîne de caractères avec XPath ?
Comment récupérer un ensemble de noeuds avec XPath ?
Voici un exemple permettant de récupérer un NodeSet (org.w3c.dom.NodeList) à partir d'une expression XPath.
public static NodeList evaluer(InputStream stream, String expression){
NodeList liste = null;
try{
InputSource source = new InputSource(stream);
liste = (NodeList)exp.evaluate(source,XPathConstants.NODESET);
}
return liste;
}
On peut utiliser cette méthode pour, par exemple, récupérer l'ensemble des titres des articles publiés (RSS 2.0) sur le
blog de developpez.com.
URL url = new URL("http://blog.developpez.com/xmlsrv/rss2.php?blog=1");
String expression = "//item/title";
System.out.println("Articles disponibles sur le blog de developpez.com");
NodeList liste = evaluer(url.openStream(),expression);
if(liste != null){
for(int i=0; i&<liste.getLength(); i++){
Node node = liste.item(i);
System.out.println(node.getTextContent());
}
}
FAQ Java XML
Vous pouvez télécharger cet exemple ci-dessous.
NodeSetXPath.java
Comment récupérer un Node avec XPath ?
Voici une méthode permettant de récupérer un Node (package org.w3c.dom) avec XPath.
public static Node evaluer(InputStream stream, String expression){
Node node = null;
try{
node = (Node)exp.evaluate(source,XPathConstants.NODE);
}
return node;
}
On peut utiliser cette méthode, par exemple pour récupérer le titre du premier article publié sur le blog de
developpez.com (RSS 2.0).
String expression = "rss/channel/item/title";
Node node = evaluer(url.openStream(),expression);
System.out.println(node.getTextContent());
Vous pouvez télécharger l'exemple ci-dessous.
NodeXPath.java
Comment récupérer un booléen à partir d'une expression XPath ?
Voici une méthode permettant de récupérer un booléen (java.lang.Boolean) avec XPath.
public static Boolean evaluer(InputStream stream, String expression){
Boolean b = null;
try{
FAQ Java XML
b = (Boolean)exp.evaluate(source,XPathConstants.BOOLEAN);
}
return b;
}
Cette méthode peut être utilisée, par exemple, pour vérifier si le dernier article publié sur le blog de developpez.com
appartient à la rubrique Java.
String expression = "rss/channel/item[position()=1 and contains(./link/text(),'blog=12')]";
Boolean b = evaluer(url.openStream(),expression);
String s = "";
if(b){
s = "Le premier message du blog de developpez.com appartient à la rubrique Java";
}else{
s = "Le premier message du blog de developpez.com n'appartient pas à la rubrique Java";
}
System.out.println(s);
Cet exemple est téléchargeable ci-dessous.
BooleanXPath.java
Comment récupérer une chaîne de caractères avec XPath ?
Voici une méthode permettant de récupérer une chaîne de caractères (java.lang.String) à partir de XPath.
public static String evaluer(InputStream stream, String expression,
NamespaceContext namespace){
String string = null;
try{
if(namespace != null){
xpath.setNamespaceContext(namespace);
}
string = (String)exp.evaluate(source,XPathConstants.STRING);
}
return string;
FAQ Java XML
}
On peut utiliser cette méthode pour, par exemple, récupérer le contenu du premier article publié (RSS 2.0) sur le blog
de developpez.com. Ce contenu peut être directement affiché dans un JTextPane.
String expression = "//item/content:encoded";
NamespaceContext namespace = new NamespaceContext(){
public String getNamespaceURI(String prefix){
if("content".equals(prefix)){
return "http://purl.org/rss/1.0/modules/content/";
}else{
return null;
}
}
public String getPrefix(String namespaceURI){
if("http://purl.org/rss/1.0/modules/content/".equals(namespaceURI)){
return "content";
}else{
return null;
}
}
public Iterator getPrefixes(String namespaceURI){
return null;
}
};
String article = evaluer(url.openStream(),expression,namespace);
JTextPane pane = new JTextPane();
pane.setContentType("text/html");
pane.setPreferredSize(new Dimension(200,200));
JScrollPane scroll = new JScrollPane(pane);
JFrame frame = new JFrame();
//etc.
frame.setVisible(true);
pane.setText(article);
StringXPath.java
Comment récupérer un nombre à partir d'une expression XPath ?
Voici une méthode permettant de récupérer un nombre (java.lang.Double) à partir de XPath.
public static Double evaluer(InputStream stream, String expression){
Double number = null;
try{
FAQ Java XML
number = (Double)exp.evaluate(source,XPathConstants.NUMBER);
}
return number;
}
Cette méthode peut être utilisée pour, par exemple, compter le nombre de news concernant J2EE et publiées (RSS 2.0)
sur le blog de la rubrique Java.
String expression = "count(rss/channel/item/category[text()='3. Technologie J2EE'])";
Double number = evaluer(url.openStream(),expression);
System.out.println("Il y a "+number+" news J2EE sur le blog de la rubrique Java");
NumberXPath.java
Comment travailler avec XPath si je n'ai pas Java 5.0 ?
Depuis J2SE 5.0 (Tiger), l'API standard contient le package javax.xml.xpath, qui permet de travailler avec XPath. Plus
d'informations dans la description du package.
Pour les versions antérieures de Java, il faut regarder du côté d'autres API comme Xalan-Java 2.6.0: Package
org.apache.xpath (NB : cette API était incluse dans J2SE 1.4). On peut aussi noter l'API JDom qui permet de travailler
avec XPath.
Enfin, n'oubliez pas que vous pouvez télécharger JAXP de manière indépendante : https://jaxp.dev.java.net/
Où trouver des informations et cours sur le langage XPath lui-même ?
Pour plus d'informations sur XPath lui-même vous pouvez suivre ces liens :
•
•
•
•
•
Rubrique XML de developpez.com
Tutoriel XPath
Forum d'entraide XML, XSL, SOAP, etc.
Spécification XPath version 1.0
Spécification XPath version 2.0 (non compatible avec le JDK standard, mais avec d'autres librairies)

FAQ Java XML - Arts Vivants en Vaucluse

Transcription

Documents pareils

Libre sur Seiche Gramps : la généalogie libre

developpez.com

Webexpert 6 totalement gratuit!

Développez votre potentiel commercial

PHP et XML

classes librairires php

Hébergeurs gratuits : Nom/Adresse Publicité Fiabilité Taille Durée

GreenCircle Système de certification

Opérateur COPIER

[V6.03.127] SSNP127 - Test de la méthode de