L'API XPath disponible dans le paquetage javax.xml.xpath, propose un environnement d'évaluation des expressions XPath.

Une instance de la classe XPath permet de compiler et évaluer des expressions XPath. Un objet XPath s'obtient en invoquant la méthode d'instance d'un objet XPathFactory, lequel est instancié par sa méthode de classe newInstance().

XPathFactory fabrique = XPathFactory.newInstance();
XPath environnement = fabrique.newXPath();
XPathExpression expression = environnement.compile("//element");

La méthode newInstance() accepte un argument indiquant le modèle d'objet à utiliser pour l'objet XPath. Par défaut, le modèle d'objet XPath est celui énoncé dans la constante XPathFactory.DEFAULT_OBJECT_MODEL_URI.

XPathFactory fabrique = XPathFactory.newInstance(
                              XPathFactory.DEFAULT_OBJECT_MODEL_URI);
/*
XPathFactory.DEFAULT_OBJECT_MODEL_URI = 
             "http://java.sun.com/jaxp/xpath/dom"
XPathConstants.DOM_OBJECT_MODEL = 
             "http://java.sun.com/jaxp/xpath/dom"
*/

Il est possible de vérifier si le modèle d'objet est supporté par l'implémentation XPath sous-jacente. La méthode isObjectModelSupported() s'occupe de cela.

if(fabrique.isObjectModelSupported(modele)){
  fabrique.newInstance(modele);
}

L'objet XPathExpression représente une expression XPath compilée. A partir de cet objet, une évaluation de l'expression XPath sur une ressource XML est réalisable au moyen des méthodes evaluate().

URL url = new URL("http://laltruiste.com/coursjava/exemples/logitheque.xml");
InputSource source = new InputSource(url.openStream());

XPathExpression expression = environnement.compile(
                            "//logiciel[@id='15202718']/nom/text()");
String resultat = expression.evaluate(source)

expression = environnement.compile("//nom");
NodeList resultat = 
           (NodeList)expression.evaluate(source, XPathConstants.NODESET);

DocumentBuilderFactory fabriqueDOM = DocumentBuilderFactory.newInstance();
DocumentBuilder analyseur = fabriqueDOM.newDocumentBuilder();
Document document = analyseur.parse(new File("logitheque.xml"));

expression = environnement.compile(
                            "//element[last()]/enfant/text()");
String resultat = expression.evaluate(document);

expression = environnement.compile("element[@id='elt3']");
NodeList liste = document.getElementsByTagName("element");
Node noeud = (Node)expression.evaluate(liste, XPathConstants.NODE);

Les objets acceptés comme argument par les deux dernières méthodes evaluate() sont soit des noeuds XML (Document, DocumentFragment, Element ou Attr), soit des liste de noeuds (NamedNodeMap et NodeList). L'expression XPath s'applique seulement à ce contexte, c'est-à-dire, à sa structure. La valeur de l'argument peut être aussi une référence à une variable ou à une fonction. Dans ce cas, les objets XPathVariableResolver et XPathFunctionResolver sont exploités pour résoudre ces expressions. Si la variable ou la fonction n'ont pu être résolus, une exception XPathExpressionException sera lancée. Enfin, un nom qualifié peut être fourni. Ce nom est résolu en s'appuyant sur le contexte d'espace de noms XPath spécifié par la méthode setNamespaceContext().

Le second argument, pour deux des méthodes evaluate(), exprime le type de l'objet retourné. Le langage XPath propose cinq types de retour possibles (Ensemble de noeuds, noeud, chaîne de caractères, nombre et valeur booléenne), lesquels sont mis à disposition sous la forme de constantes, dans la classe XPathConstants.

La classe XPath dispose également de méthodes d'évaluation similaires à celles d'un objet XPathExpression. En fait, ces méthodes evaluate() accomplissent dans un premier temps la compilation d'une expression XPath, puis l'opération d'évaluation. Elles constituent donc une alternative compacte en n'utilisant qu'un appel de méthode, plutôt que deux comme exposé ci-dessus.

import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;

public class ExpressionXPath {
  public static void main(String[] args) {
    try {
      DocumentBuilderFactory fabriqueDOM = 
                                    DocumentBuilderFactory.newInstance();
      DocumentBuilder analyseur = fabriqueDOM.newDocumentBuilder();
      Document document = analyseur.parse(new File("logitheque.xml"));
      XPathFactory fabriqueXPath = XPathFactory.newInstance();
      XPath xpath = fabriqueXPath.newXPath();
      String expression = "//logiciel[@code='15202718']";
      Node noeud = (Node) xpath.evaluate(
                                    expression, document, XPathConstants.NODE);
      afficherInfos(noeud);
      expression = "ancestor::*/logiciel[3]/commentaire";
      noeud = (Node) xpath.evaluate(
                                    expression, noeud, XPathConstants.NODE);
      afficherInfos(noeud);
    }
    catch(IOException e) {
      e.printStackTrace();
    }
    catch (ParserConfigurationException e) {
      e.printStackTrace();
    }
    catch (SAXException e) {
      e.printStackTrace();
    }
    catch (XPathExpressionException e) {
      e.printStackTrace();
    }
  }
  public static void afficherInfos(Node noeud) {
    String nom = noeud.getNodeName();
    String valeur = noeud.getNodeValue();
    short type = noeud.getNodeType();
    if (type == Node.ELEMENT_NODE)
      valeur = noeud.getTextContent();
    System.out.println(nom + " (" + type + ") = '" + valeur + "'");
  }
}

Le second argument de la méthode evaluate() détermine un noeud contextuel à partir duquel s'appliquera l'expression XPath spécifiée.