FAQ Java XMLConsultez toutes les FAQ

Nombre d'auteurs : 5, nombre de questions : 59, dernière mise à jour : 3 septembre 2014  Ajouter une question

 

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


SommaireXPath (13)
précédent sommaire
 

XPath, ou XML Path Language, est un langage dont le but premier est de permettre la « sélection » de nœuds 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 :

Mis à jour le 1er février 2005 Ioan

Voici un schéma simplifié du fonctionnement du package javax.xml.xpath :



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 ?

Mis à jour le 1er février 2005 Ioan

Si vous voulez utiliser les fonctions de XPath ou des fonctions standards dans un document XML, il suffit d'inclure leurs références en début de fichier :

Code xml : Sélectionner tout
1
2
3
xmlns:fn="http://www.w3.org/2005/xpath-functions"   
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://serveur.com/schema/blog blog.xsd"  
xmlns:xs="http://www.w3.org/2001/XMLSchema"

Mis à jour le 3 septembre 2014 Robin56

Voici deux méthodes statiques montrant comment créer une instance de XPath et lui faire évaluer une XPathExpression.

Exemple avec un Document DOM :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 
		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 :
Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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 dispose elle aussi d'une méthode evaluate().
Ainsi, on pourrait remplacer le code de la première méthode par :
Code java : Sélectionner tout
1
2
                    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.

Mis à jour le 1er février 2005 Ioan

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.

Arguments Retour Description
String expression, Object item, QName returnType Object L'argument item correspond à un élément XML à évaluer. Celui-ci peut être unDocument, un DocumentFragment, un Node ou encore une NodeList (package org.w3c.dom). L'argument returnType doit être une des constantes de la classeXPathConstants : 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).
String expression, Object item String Cette méthode a le même comportement que evaluate(expression, item, returnType) avec returnType égal à XPathConstants.STRING.
String expression, InputSource source, QName returnType Object 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 classeXPathConstants : 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).
String expression, InputSource source String 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 Type de retour Description
XPathConstants.NODE org.w3c.dom.Node Quand un Node est requis comme type de retour, la méthode evaluate() retourne une instance de org.w3c.Node correspondant au premier nœud satisfaisant l'expression XPath.
XPathConstants.NODESET org.w3c.dom.NodeList Quand un NodeSet est requis comme type de retour, la méthode evaluate() retourne une instance de org.w3c.NodeList correspondant aux nœuds sélectionnés par l'expression XPath.
XPathConstants.STRING java.lang.String Quand un String est requis comme type de retour, la méthode evaluate() retourne le contenu du ou des nœuds satisfaisant l'expression XPath (enfants compris).
XPathConstants.BOOLEAN java.lang.Boolean Quand un Boolean est requis comme type de retour, la méthode evaluate() retourne Boolean.TRUE si au moins un nœud est sélectionné, Boolean.FALSE sinon.
XPathConstants.NUMBER java.lang.Double Quand un Number est requis comme type de retour, la méthode evaluate() essaye de transformer le contenu du nœud sélectionné en Double.

Pour un exemple pratique d'utilisation de chacune de ces méthodes regardez les liens ci-dessous.

Mis à jour le 1er février 2005 Ioan

Pour utiliser les espaces de nommage, vous pouvez utiliser la méthode setNamespaceContext(NamespaceContext) de la classeXPath. Par exemple :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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; 
	}  
}; 
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 ?

Mis à jour le 1er février 2005 Ioan

Voici un exemple permettant de récupérer un NodeSet (org.w3c.dom.NodeList) à partir d'une expression XPath.

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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 le blog de developpez.com.

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
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()); 
	} 
}

Vous pouvez télécharger cet exemple ci-dessous.

Mis à jour le 1er février 2005 Ioan

Voici une méthode permettant de récupérer un Node (package org.w3c.dom) avec XPath.

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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 de developpez.com (RSS 2.0).
Code Java : Sélectionner tout
1
2
3
4
5
6
URL url = new URL("http://blog.developpez.com/xmlsrv/rss2.php?blog=12"); 
  
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.

Mis à jour le 1er février 2005 Ioan

Voici une méthode permettant de récupérer un booléen (java.lang.Boolean) avec XPath.

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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  
		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.com appartient à la rubrique Java.
Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
URL url = new URL("http://blog.developpez.com/xmlsrv/rss2.php?blog=1"); 
  
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.

Mis à jour le 1er février 2005 Ioan

Voici une méthode permettant de récupérer une chaîne de caractères (java.lang.String) à partir de XPath.

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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; 
}
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.

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
URL url = new URL("http://blog.developpez.com/xmlsrv/rss2.php?blog=1"); 
  
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);
Cet exemple est téléchargeable ci-dessous.

Mis à jour le 1er février 2005 Ioan

Voici une méthode permettant de récupérer un nombre (java.lang.Double) à partir de XPath.

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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(); 
  
		//é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.

Code java : Sélectionner tout
1
2
3
4
5
6
URL url = new URL("http://blog.developpez.com/xmlsrv/rss2.php?blog=12"); 
  
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");
Cet exemple est téléchargeable ci-dessous.

Mis à jour le 1er février 2005 Ioan

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/

Mis à jour le 1er février 2005 Ioan

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -