Cours 5 sur les API Java pour XML : DOM, SAX et DOM4J Niveau :SI_ISIL
1. Introduction :
Vous avez un fichier XML dont vous aimeriez utiliser le contenu dans un programme par exemple lire des
documents XML et de les analyser dans du code Java (ou autre langage). Il existe plusieurs API: DOM, SAX,
DOM4J et JDOM.
2. DOM
DOM signifie Document Object Model . Il consiste à associer un graphe d’objets à un document XML, et à
naviguer dedans en suivant les relations père-fils naturellement. Son principal avantage est la facilité avec
laquelle on peut naviguer dans l’arbre XML. L’approche DOM semble la plus naturelle du point de vue de la
programmation objet.
L’inconvénient majeur de DOM est qu’il nécessite de charger l’intégralité du document XML en mémoire.
Dès que les documents dépassent une certaines taille (quelques giga-octets), DOM n’est plus utilisable. D’autre
part, dans certains cas cette possibilité de navigation offerte par DOM n’est pas utile.
DOM est consommateur de ressources, et à mesure que le document augmente de taille, cette consommation
augmente aussi.
Exemple sur la méthode DOM :
Soit le document XML suivant :
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<Documentation>
<Site Wiki="Wikibooks">
<Livre Wikilivre="Java">
<Page1>Introduction</Page1>
<Page2>Bases du langage</Page2>
<Exemple>XML</Exemple>
</Livre>
</Site>
</Documentation>
Avec DOM on peut analyser (générer, lire…) un fichier XML. Le programme suivant génère le fichier XML
précédente dans le même répertoire avec le nom ‘XML_résultat.xml’ :
import java.io.File;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.*;
public class xml_creation_dom {
public static void main(String argv[])
{
try
{
1
DocumentBuilderFactory XML_Fabrique_Constructeur = DocumentBuilderFactory.newInstance();
DocumentBuilder XML_Constructeur = XML_Fabrique_Constructeur.newDocumentBuilder();
Document XML_Document = XML_Constructeur.newDocument();
Element documentation = XML_Document.createElement("Documentation");
XML_Document.appendChild(documentation);
Element site = XML_Document.createElement("Site");
documentation.appendChild(site);
Attr attribut1 = XML_Document.createAttribute("Wiki");
attribut1.setValue("Wikibooks");
site.setAttributeNode(attribut1);
Element livre = XML_Document.createElement("Livre");
site.appendChild(livre);
Attr attribut2 = XML_Document.createAttribute("Wikilivre");
attribut2.setValue("Java");
livre.setAttributeNode(attribut2);
Element page1 = XML_Document.createElement("Page1");
page1.appendChild(XML_Document.createTextNode("Introduction"));
livre.appendChild(page1);
Element page2 = XML_Document.createElement("Page2");
page2.appendChild(XML_Document.createTextNode("Bases du langage"));
livre.appendChild(page2);
Element example = XML_Document.createElement("Exemple");
example.appendChild(XML_Document.createTextNode("XML"));
livre.appendChild(example);
TransformerFactory XML_Fabrique_Transformeur = TransformerFactory.newInstance();
Transformer XML_Transformeur = XML_Fabrique_Transformeur.newTransformer();
DOMSource source = new DOMSource(XML_Document);
StreamResult resultat = new StreamResult(new File("XML_résultat.xml"));
XML_Transformeur.transform(source, resultat);
System.out.println("Le fichier XML a été généré !");
}
catch (ParserConfigurationException pce) { pce.printStackTrace(); }
catch (TransformerException tfe) { tfe.printStackTrace(); }
}
}
3. SAX
À l’opposé, les traitements de SAX ( Simple API for XML) , ne reconstruit pas d’arbre d’objets en mémoire.
SAX analyse un document XML portion par portion. Il exécute certains traitements lorsqu’il rencontre des
éléments ou des attributs particuliers, précisés par l’utilisateur. On dit que SAX est un modèle piloté par
événements. Ces événements sont simplement l’occurrence d’un élément, par exemple.
SAX sera la bonne API à choisir.
2
Ces deux API (DOM et SAX) sont comme d’habitude, des jeux d’interfaces. L’implémentation standard de
ces interfaces, fournie par le JDK, est Xercès, développé et distribué en open-source par l’Apache Software
Fondation.
Cette API n’est probablement pas la meilleure : elle est complexe, lourde à utiliser, et peu performante et
l’interface Dom4J bien préféré
Exemple sur la méthode SAX : Aussi avec SAX on peut analyser (générer, lire…) des fichiers XML. Pour
lire le fichier XML ci-dessus(XML_résultat.xml), il faut le parser avec un handler SAX défini par le program
suivant:
import java.io.*;
import javax.xml.parsers.*;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import org.xml.sax.helpers.DefaultHandler;
public class xml_creation_sax {
public static void main(String[] args)
{
try
{
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser parser = factory.newSAXParser();
parser.parse("XML_résultat.xml",
new DefaultHandler()
{
public void startDocument() throws SAXException
{ System.out.println("Début de document XML"); }
public void endDocument() throws SAXException
{ System.out.println("Fin de document XML"); }
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException
{ System.out.println("Début d'élément : " + qName); }
public void endElement(String uri, String localName, String qName) throws SAXException
{ System.out.println("Fin d'élément : " + qName); }
public void characters(char[] ch, int start, int length) throws SAXException
{ System.out.println("Caractère lus dans un élémént"); }
}
);
}
catch (IOException e)
{ System.err.println("Erreur de lecture : "+e);
System.exit(1); }
catch (SAXException e)
{ System.err.println("Erreur d'interprétation : "+e);
System.exit(1); }
catch (ParserConfigurationException e)
{ System.err.println("Pas d'interpréteur SAX pour la configuration demandée : "+e);
3
System.exit(1); }
}
4. DOM4J
DOM4J est une API Java open source permettant de lire et écrire du XML, et faire des requêtes XPath sur des
documents XML ce qui la rend très naturelle à utiliser. Elle est plus performante, que ce soit en création de
document ou en analyse.
Exemple : sur la Création d'un document XML en mémoire avec DOM4J
Remarque : il faut télécharger le fichier ‘dom4j.zip’
public Document createDocument() {
// création du document
Document document = DocumentHelper.createDocument() ;
// création d'un élément racine, et ajout d'un attribut id de valeur 15
Element root = document.addElement("marins").addAttribute("id", "15") ;
// création d'un sous-élément de l'élément racine
Element marin1 = root.addElement("marin") ;
// création d'un sous-élément "nom"
Element nom1 = marin.addElement("nom") ;
// ajout du texte "Surcouf" à cet élément
nom1.addText("Surcouf") ;
// création d'un sous-élément contenant le texte "Robert"
// l'appel est chaîné, car addElement retourne une instance de Element
Element prenom1 = marin.addElement("prenom").addText("Robert");
return document;
}
Quelques documents sur DOM4J :
https://www.youtube.com/watch?v=Y1N3PcRA4xs
https://www.youtube.com/watch?v=tS1USe_xh0c
https://blog.paumard.org/cours/xml/chap04-dom-sax-utiliser-dom4j.html#d0e1797
