FaqJavaXml

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 dehttp://www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette faq ne garantit en aucun cas que les informationsqu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur esthumaine. 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

http://www.developpez.com


http://club.developpez.com/redaction/#L3

Ont contribué à cette FAQ :

bazinou - iubito - Clément Cunin - Johann Heymes - RonanLe Gallo - Christophe Ludet - Jean-Baptiste Bugeaud -

Grégory Danelon - Sébastien Meric - Romain Guy - Pierre-Yves Varoux - Ioan Calapodescu - bahamouth - duj - braim

- bulbo - Ricky81 - L'équipe Java - Debernad - jcarre- Seigne David - cyberzoide - xavlours - christopheJ -

willowII - Nourdine Falola - laffreuxthomas - adiGuba -


http://www.developpez.net/forums/profile.php?mode=viewprofile&u=83412









http://www.jext.org




















FAQ Java XML

- 3 -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 oeuvreintellectuelle 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éede 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 pagetant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2006 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.

http://java.developpez.com/faq/xml/

1. Informations générales (5) .........................................................................................................................................................42. Généralités (11) ......................................................................................................................................................................... 73. SAX (6) ....................................................................................................................................................................................134. DOM (11) ................................................................................................................................................................................ 205. XSLT (9) ..................................................................................................................................................................................296. XPath (12) ................................................................................................................................................................................37



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 etcomplè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 questionporte 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échargercontenant un programme de démonstration. Ces programmes sont volontairement très simples afin qu'il soit aisé delocaliser le code intéressant. Les réponses peuvent également être complétées de liens vers d'autres réponses, vers ladocumentation 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 modificationsapporté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 toutescollaborations 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 administrateurssi 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 lereste, 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 traduiteen français ici. Permission vous est donnée de distribuer, modifier des copies des contributions de Clément Cunin etJohann 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. Permissionvous 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 selonla 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, SebastienAndreo, 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 :




http://www.gnu.org/copyleft/fdl.html

http://c.developpez.com/faq/cpp/GFDL.html

http://www.gnu.org/copyleft/fdl.html

http://c.developpez.com/faq/cpp/GFDL.html


http://java.developpez.com/cours/

http://www.developpez.net/forums/forumdisplay.php?f=6

http://java.developpez.com/faq/struts/

http://java.sun.com/j2se/1.4/docs/api/index.html

http://java.sun.com/docs/books/tutorial/index.html

http://www.jguru.com/faq/









http://www.jext.org
















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é à laperfectionner.

Et pour finir, un merci tout spécial à Clément Cunin, qui est à l'origine de cette FAQ, à cyberzoide pour notre logo etses conseils avisés et à tous les membres de l'équipe qui nous ont fourni outils et logiciels nécessaires pour la réalisationde 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 (commele HTML, par exemple), utilisé pour la représentation et structuration de données. Voici quelques caractéristiques dece standard :

• Extensible : au contraire du HTML, qui contient un jeu limité de balises, le XML permet la création de ses propresbalises.

• Méta-langage : grâce à son exstensibilité, le XML est un standard tout à fait approprié pour la création d'autreslangages (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'informationssur le format XML ?

L'API Java standard pour la manipulation du format XML est JAXP (Java API for XML Processing). Cette API permetla lecture, la transformation et l'écriture de fichiers ou flux XML. C'est cette API que nous allons étudier dans la partieXML de cette FAQ.

JAXP n'est pas la seule API disponible pour travailler avec XML. Pour plus d'informations sur les autres APIdisponibles 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éveloppeurtrois ensembles de fonctionnalités (la modélisation, le parsing et la transformation) regroupées en quatre packagesdistincts.

• javax.xml.parsers : Ce package contient un ensemble d'interfaces devant être implémentées par les différentsparseurs (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 avecXSLT (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 lorsde la rencontre avec un élément. Les éléments pouvant être des balises (ouvrantes ou fermantes), des portions detexte, des commentaires ou encore des instructions.Cette API est particulièrement mise en avant pour sa rapidité de traitement. Par contre, son fonctionnement estpeut-ê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, enplus, 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 arbrereprésente l'organisation et le contenu du document XML. En contrepartie de sa facilité d'utilisation, DOM estplus 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 enune 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 XSLTpour 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 uneliste 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





http://www.saxproject.org/

http://www.w3.org/TR/xml11/

http://www.w3.org/TR/REC-xml

http://www.w3.org/TR/xinclude/

http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407

http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407

http://www.w3.org/TR/xmlschema-1/

http://www.w3.org/TR/1999/REC-xslt-19991116

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 XML SAX DOM XSLT XPathJAXP RI 1.3(présent dans leJDK 1.5)

1.1/1.0 SAX 2.0.2 DOM 3.0 XSLT 1.0 XPath 1.0

JAXP RI 1.2(présent dans leJDK 1.4)

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 XMLet 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 pouvezté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 Parseur XML Processeur XSLTJAXP 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




http://java.sun.com/xml/jaxp/index.jsp

http://java.sun.com/xml/jaxp/index.jsp


https://jaxp.dev.java.net/


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 XXXdé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 commandejava -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 processeurXSLT il doit utiliser.

Naturellement, vous pouvez utiliser directement les implémentations (sans passer par les factory), mais cela vous faitperdre la "portabilité" de votre code. En effet, en cas de changement de parseur ou processeur, vous devrez changerde nombreuses parties de votre code. Le plus simple reste de spécifier l'implémentation à utiliser grâce aux propriétéssystè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 :





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




http://xml.developpez.com/cours/

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èsspécialisée (sur la technologie J2EE par exemple), d'autres sont plus généralistes et reprennent/consolident/améliorentles 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 etJAXP.

• 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.



http://www.developpez.net/forums/viewforum.php?f=25

http://xml.developpez.com/livres/

http://www.w3.org/XML/


http://www.jdom.org/

http://www.dom4j.org/

http://jcp.org/en/jsr/detail?id=173

http://java.sun.com/xml/jaxb/

http://java.sun.com/xml/jaxr/index.jsp

http://java.sun.com/xml/jaxrpc/index.jsp

http://java.sun.com/xml/saaj/index.jsp

http://java.sun.com/j2ee/1.4/docs/tutorial/doc/index.html

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 plusieursgestionnaires (ou handlers). Ce sont ces différents gestionnaires qui sont chargés du traitement des "événements" lorsdu 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 erreurssimples, 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 à direque 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 unexemple, 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 handlersde base une implémentation par défaut de DeclHandler, EntityResolver2 et LexicalHandler. Ces trois gestionnaires sontdes 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 org.xml.sax.*;import org.xml.sax.helpers.*;import javax.xml.parsers.*; import 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émentationde 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, cettevaleur est false.




FAQ Java XML



• setSchema(Schema) : indique que les parseurs produits par la fabrique doivent valider le document XML selonun schéma XML W3C.

• setFeature(String, boolean) : permet d'indiquer une propriété particulière pour les parseurs produits par lafabrique. 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 denommage 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 int getId(){return id;} public String getNom(){return nom;} public String getPrenom(){return prenom;} public String getAdresse(){return adresse;} public void setId(int id){this.id = id;} public void setNom(String nom){this.nom = nom;} public void setPrenom(String prenom){this.prenom = prenom;} public void setAdresse(String adresse){this.adresse = adresse;}



http://java.sun.com/j2se/1.5.0/docs/api/org/xml/sax/package-summary.html


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 Listde 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 justede 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 luimê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éesau niveau du Gestionnaire d'Erreurs (ErrorHandler) :

• Erreur fatale (fatalError(SAXParseException exception) throws SAXException) : Cette erreur ne peut êtrerécupérée. C'est le cas par exemple pour un document mal formé. Après ce type d'erreur, le parseur SAX arrêteson travail.

• Erreur (error(SAXParseException exception) throws SAXException) : Cette erreur peut être récupérée, c'est à direque le parseur SAX peut continuer à traiter le reste du document XML. Ce genre d'erreur peut se produire lorsd'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èscelà, 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 etwarnings 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 ***"); printSAXException(exception);}public void fatalError(SAXParseException exception) throws SAXException{ String message = "*** Erreur fatale ***\n"; message += message(exception); SAXException se = new SAXException(message, exception); throw se;}



http://www.w3.org/TR/REC-xml/

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'unflux 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




http://smeric.developpez.com/java/cours/xml/sax/





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) à partird'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 sourceXML.

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 javax.xml.parsers.*; import org.w3c.dom.*; import org.xml.sax.*; import 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)"); }catch(IOException ioe){ 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 : Commentcré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 ***"); printSAXException(exception); } public void error(SAXParseException exception) throws SAXException{ System.out.println("*** Erreur ***"); printSAXException(exception); } 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 documentsDocumentBuilderFactory fabrique = DocumentBuilderFactory.newInstance();

// création et configuration du constructeur de documentsDocumentBuilder constructeur = fabrique.newDocumentBuilder();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 deorg.w3c.dom.Document.

Voici un exemple récupérant, à partir d'un Document, des informations générales, des informations sur le type dedocument 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 comprendresa structure. Il est notamment nécessaire de bien faire la distinction entre les différents types de nodes. Une erreurcouramment 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éthodegetNodeType().

• 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)

getNodeType()(short)

getNodeName()(String)

getNodeValue()(String)

getAttributes()(NamedNodeMap)

Attr ATTRIBUTE_NODELe nom del'attribut.

La valeur del'attribut.

null

CDATASection CDATA_SECTION_NODE"#cdata-section" Le contenu de lasection CDATA.

null

Comment COMMENT_NODE"#comment" Le contenu ducommentaire.

null

Document DOCUMENT_NODE"#document" null nullDocumentFragmentDOCUMENT_FRAGMENT_NODE"#document-

fragment"null null

DocumentType DOCUMENT_TYPE_NODELe nom du type. null nullElement ELEMENT_NODELe nom du tag. null Les attributs de

l'élément.Entity ENTITY_NODE Le nom de

l'entité.null null

EntityReference ENTITY_REFERENCE_NODELe nomde l'entitéréferencée.

null null

Notation NOTATION_NODELe nom de lanotation.

null null

ProcessingInstructionPROCESSING_INSTRUCTION_NODELa cible del'instruction.

Les données del'instruction.

null

Text TEXT_NODE "#text" Le texte en lui-même.

null

Si vous voulez récupérer le texte contenu dans un node (et dans l'ensemble de ses enfants), utilisez la méthodegetTextContent().

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 nompassé 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 etgetAttributesByTagName.

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{ DocumentBuilderFactory fabrique = DocumentBuilderFactory.newInstance(); fabrique.setValidating(true); DocumentBuilder constructeur = fabrique.newDocumentBuilder(); 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); } }catch(Exception 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éthodegetSchemaTypeInfo().

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 etElement.

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 ceque 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 deméthodes permettant la modification du document. Voici, en résumé, les méthodes disponibles pour Document, Nodeet 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 sesenfants (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 etretourne 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. cettemé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'instancede 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 : Commentcré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 DOMDocumentBuilderFactory fabrique = DocumentBuilderFactory.newInstance();DocumentBuilder constructeur = fabrique.newDocumentBuilder();Document document = constructeur.newDocument();

// Propriétés du DOMdocument.setXmlVersion("1.0");




FAQ Java XML



document.setXmlStandalone(true);

// Création de l'arborescence du DOMElement 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 fichierXML avec DOM et XSLT ?). Vous pouvez télécharger une exemple ci-dessous.

lien : Comment créer ou modifier un fichier XML avec DOM et XSLT ?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 parun 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 detransformeurs (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 vasimplement 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 ensebbled'évènements SAX, un DOM ou une OutputSource.

Pour une configuration pratique du transformeur, regardez : Comment créer et configurer un Transformer (pour SAXet DOM) ?

Pour des exemples, regardez : Comment créer ou modifier un fichier XML avec DOM et XSLT ? et Comment créerou modifier un fichier XML avec SAX et XSLT ?

lien : Comment créer et configurer un Transformer (pour SAX et DOM) ?lien : Comment créer ou modifier un fichier XML avec DOM et XSLT ?




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 fabriqueTransformerFactory fabrique = TransformerFactory.newInstance();

// récupération du transformeurTransformer 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 transformeurtransformer.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 fabriqueTransformerFactory fabrique = TransformerFactory.newInstance();

// récupération de TemplatesTemplates 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 transformeurTransformer transformer = template.getTransformer();





FAQ Java XML



transformer.setOutputProperty(OutputKeys.INDENT, "yes");transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1");

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 erreursdurant 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) throws TransformerException{ printException(exception); } public void fatalError(TransformerException exception) throws TransformerException{ printException(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 TransformerFactory fabrique = TransformerFactory.newInstance();





FAQ Java XML



Transformer transformer = fabrique.newTransformer(); transformer.setOutputProperty(OutputKeys.INDENT, "yes"); transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1"); // Transformation transformer.transform(source, resultat); }catch(Exception e){ 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 del'écriture dans un fichier d'un "annuaire" composé d'une List de JavaBean Personne. Voici les étapes nécessaires à sacré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'annuaireList<Personne> annuaire = new ArrayList<Personne>();// ...//remplissage de l'annuaire

// Création de la source DOMXMLReader annuaireReader = new AnnuaireReader();InputSource annuaireSource = new AnnuaireSource(annuaire);



FAQ Java XML



Source source = new SAXSource(annuaireReader, annuaireSource);

// Création du fichier de sortieFile file = new File("CreationSAX.xml");Result resultat = new StreamResult(file);

// Configuration du transformerTransformerFactory fabrique = TransformerFactory.newInstance();Transformer transformer = fabrique.newTransformer();transformer.setOutputProperty(OutputKeys.INDENT, "yes");transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1");

// Transformationtransformer.transform(source, resultat);

Téléchargez le code source complet ci-dessous.

lien : Comment créer ou modifier un fichier XML avec DOM et XSLT ?lien : Comment créer un fichier HTML à partir d'un XML ?lien : Comment créer un fichier PDF à partir d'un XML ?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{ // Création de la source DOM DocumentBuilderFactory fabriqueD = DocumentBuilderFactory.newInstance(); DocumentBuilder constructeur = fabriqueD.newDocumentBuilder(); File fileXml = new File(xml); Document document = constructeur.parse(fileXml); Source source = new DOMSource(document); // Création du fichier de sortie File fileHtml = new File(html); Result resultat = new StreamResult(fileHtml); // Configuration du transformer TransformerFactory fabriqueT = TransformerFactory.newInstance(); StreamSource stylesource = new StreamSource(xsl); Transformer transformer = fabriqueT.newTransformer(stylesource); transformer.setOutputProperty(OutputKeys.METHOD, "html"); // Transformation transformer.transform(source, resultat);}

Vous pouvez télécharger ci-dessous un exemple simple avec xml, xsl et classe de test.

lien : Comment créer ou modifier un fichier XML avec DOM et XSLT ?




FAQ Java XML



lien : Comment créer un fichier PDF à partir d'un 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 librairieexiste 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 transformer.transform(source, resultat);}

Vous pouvez télécharger un exemple complet avec xml et xsl ci dessous. Verifiez bien que la librairie FOP (et sesdépendances) se trouve bien dans votre classpath avant de compiler/exécuter l'exemple.

lien : Comment créer un fichier HTML à partir d'un XML ?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 plusieurstransformations successives à un document XML. Chaque résultat de transformation devenant ainsi la source de laprochaine. Pour vous aider à faire ceci, le package org.xml.sax vous propose la classe XMLFilter. Voici le principe :




http://xml.apache.org/fop/


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(); transformer.transform(source, resultat);}

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'undocument XML. Cette "sélection" se fait grâce à un système d'adressage que l'on pourrait comparer aux URL. Enplus de cela, XPath fournit un ensemble de fonctions sur les chaînes de caractères ou encore des fonctions permettantd'effectuer des tests.XPath peut être utilisé en combinaison avec XSLT et XPointer. Pour découvrir toutes les possibilités de ce langage, vouspouvez 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 plusamples informations.

Cette partie de la FAQ se contentera de vous fournir les bases nécessaires à l'utilisation du package javax.xml.xpathappartenant au JDK standard depuis Java 5.0. Pour l'utilisation de XPath avec d'autres API ou l'utilisation de cepackage 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 resteplus qu'à construire une XPathExpression à partir du XPath. Cette XPathExpression va retourner (grâce à sa méthodeevaluate()) 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 classeXPathConstants. 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)); //création du XPath XPathFactory fabrique = XPathFactory.newInstance(); XPath xpath = fabrique.newXPath(); //évaluation de l'expression XPath XPathExpression exp = xpath.compile(expression); Object resultat = exp.evaluate(source,retour); System.out.println(resultat); }catch(XPathExpressionException xpee){ xpee.printStackTrace(); }catch(IOException ioe){ 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 disposeelle 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 exactementla 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 cesméthodes, l'argument de type String nommé expression correspond à l'expression XPath à évaluer.




FAQ Java XML



Arguments Retour DescriptionString expression, Object item,QName returnType

Object L'argument item correspondà un élément XML à évaluer.Celui-ci peut être un Document,un DocumentFragment, unNode ou encore une NodeList(package org.w3c.dom).L'argument returnType doitêtre une des constantes dela classe XPathConstants :NUMBER, STRING, BOOLEAN,NODE ou NODESET (uneIllegalArgumentException estlevée sinon). Cet argument définitsimplement le type de l'Objectretourné par la méthode (voirtableau ci-dessous).

String expression, Object item String Cette méthode a le mêmecomportement queevaluate(expression, item,returnType) avec returnType égal àXPathConstants.STRING.

String expression, InputSourcesource, QName returnType

Object L'argument source correspond àla source XML à évaluer. Celle-cidoit être une InputSource (packageorg.xml.sax). L'argument returnTypedoit être une des constantesde la classe XPathConstants :NUMBER, STRING, BOOLEAN,NODE ou NODESET (uneIllegalArgumentException estlevée sinon). Cet argument définitsimplement le type de l'Objectretourné par la méthode (voirtableau ci-dessous).

String expression, InputSourcesource

String Cette méthode a le mêmecomportement queevaluate(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 correspondancesentre les constantes de XPathConstants (instances de QName) et les types de retour de la méthode evaluate :

QName Type de retour DescriptionXPathConstants.NODE org.w3c.dom.Node Quand un Node est requis comme

type de retour, la méthodeevaluate() retourne une instancede org.w3c.Node correspondantau premier noeud satisfaisantl'expression XPath.

XPathConstants.NODESET org.w3c.dom.NodeList Quand un NodeSet est requiscomme type de retour, la méthode




FAQ Java XML



evaluate() retourne une instance deorg.w3c.NodeList correspondant auxnoeuds sélectionnés par l'expressionXPath.

XPathConstants.STRING java.lang.String Quand un String est requis commetype de retour la méthode evaluate()retourne le contenu du ou des noeudssatisfaisant l'expression XPath(enfants compris).

XPathConstants.BOOLEAN java.lang.Boolean Quand un Boolean est requis commetype de retour la méthode evaluate()retourne Boolean.TRUE si aumoins un noeud est sélectionné,Boolean.FALSE sinon.

XPathConstants.NUMBER java.lang.Double Quand un Number est requis commetype de retour la méthode evaluate()essaye de transformer le contenu dunoeud 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 laclasse 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; } };XPathFactory fabrique = XPathFactory.newInstance();XPath xpath = fabrique.newXPath();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{ //création de la source InputSource source = new InputSource(stream); //création du XPath XPathFactory fabrique = XPathFactory.newInstance(); XPath xpath = fabrique.newXPath(); //évaluation de l'expression XPath XPathExpression exp = xpath.compile(expression); liste = (NodeList)exp.evaluate(source,XPathConstants.NODESET); }catch(XPathExpressionException xpee){ xpee.printStackTrace(); } 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 leblog 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{ //création de la source InputSource source = new InputSource(stream); //création du XPath XPathFactory fabrique = XPathFactory.newInstance(); XPath xpath = fabrique.newXPath(); //évaluation de l'expression XPath XPathExpression exp = xpath.compile(expression); node = (Node)exp.evaluate(source,XPathConstants.NODE); }catch(XPathExpressionException xpee){ xpee.printStackTrace(); } return node;}

On peut utiliser cette méthode, par exemple pour récupérer le titre du premier article publié sur le blog dedeveloppez.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{ //création de la source InputSource source = new InputSource(stream); //création du XPath





FAQ Java XML



XPathFactory fabrique = XPathFactory.newInstance(); XPath xpath = fabrique.newXPath(); //évaluation de l'expression XPath XPathExpression exp = xpath.compile(expression); b = (Boolean)exp.evaluate(source,XPathConstants.BOOLEAN); }catch(XPathExpressionException xpee){ xpee.printStackTrace(); } return b;}

Cette méthode peut être utilisée, par exemple, pour vérifier si le dernier article publié sur le blog de developpez.comappartient à 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{ //création de la source InputSource source = new InputSource(stream); //création du XPath XPathFactory fabrique = XPathFactory.newInstance(); XPath xpath = fabrique.newXPath(); if(namespace != null){ xpath.setNamespaceContext(namespace); } //évaluation de l'expression XPath XPathExpression exp = xpath.compile(expression); string = (String)exp.evaluate(source,XPathConstants.STRING); }catch(XPathExpressionException xpee){ xpee.printStackTrace(); } 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 blogde 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{ //création de la source InputSource source = new InputSource(stream); //création du XPath XPathFactory fabrique = XPathFactory.newInstance(); XPath xpath = fabrique.newXPath();




FAQ Java XML



//évaluation de l'expression XPath XPathExpression exp = xpath.compile(expression); number = (Double)exp.evaluate(source,XPathConstants.NUMBER); }catch(XPathExpressionException xpee){ xpee.printStackTrace(); } 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. Plusd'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: Packageorg.apache.xpath (NB : cette API était incluse dans J2SE 1.4). On peut aussi noter l'API JDom qui permet de travailleravec 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)




http://java.sun.com/j2se/1.5.0/docs/api/javax/xml/xpath/package-summary.html

http://xml.apache.org/xalan-j/apidocs/org/apache/xpath/package-summary.html

http://xml.apache.org/xalan-j/apidocs/org/apache/xpath/package-summary.html

http://www.jdom.org/

https://jaxp.dev.java.net/


http://xml.developpez.com/

http://jerome.developpez.com/xmlxsl/xpath/

http://www.developpez.net/forums/viewforum.php?f=25


http://www.w3.org/TR/xpath20/

Documents

FaqJavaXml