à lire

L’objectif de ce TP est de présenter les bases de la programmation Java autour des documents XML :

• l’analyse de documents avec sax, la modélisation en mémoire avec DOM et l’évaluation de chemin XPath et de feuilles XSLT depuis java.

Outils utilisés :

• Le langage Java
• Le parseur XML : Xerces
• Processeur XSLT : Xalan (http://xml.apache.org/xalan-j/index.html)
• Les données utiles sont dans ce fichier : data.tar.gz

Dans un premier temps, compiler l’exemple MySAXApp.java (section Sample SAX2 application du tutoriel http://www.saxproject.org/quickstart.html). Regarder le code source et exécuter ce programme sur le document animaux.xml.

Expliquer le résultat.

Attention, un parser sax est fourni en standard avec le jdk (xerces). Si vous voulez contrôler la version, il faut compiler et exécuter de l’une des deux façons suivantes (pourquoi ?) :

• java -Xbootclasspath/p:/usr/share/java/xalan.jar:/usr/share/java/xerces.jar TestAnimal
• java -Djava.endorsed.dirs=“/usr/local/xalan/bin” TestAnimal

Pour illustrer SaX nous allons analyser un document XML qui décrit des animaux (des chiens et des chats) qui sont dans des enclos. Les animaux ont un nom et peuvent être malade. Un exemple de répartition est donné dans le document XML animaux.xml (la DTD est donnée dans animaux.dtd).

Pour représenter cette organisation, un paquetage java est fournit : D21-TP1-20150204.jar. Un exemple d’utilisation est donné dans le programme TestAnimal.java. Vous pouvez le compiler puis l’exécuter de la façon suivante :

• Manuellement : javac -classpath D21-TP1-20150204.jar TestAnimal.java puis java -classpath D21-TP1-20150204.jar:. TestAnimal
• Ajouter ce jar dans les librairie de votre IDE
• L’ajouter localement à “Maven” : http://maven.apache.org/guides/mini/guide-3rd-party-jars-local.html

En vous inspirant du tutoriel http://www.saxproject.org/quickstart.html écrire un programme Java qui analyse un document XML conforme à la DTD animaux.dtd et qui construit les enclos en mémoire puis affiche le résultat.

Nous utiliserons l’implantation de Apache fournie par défaut dans le JDK.

L’API DOM offre les constructeurs de base pour créer un document XML en mémoire. Examiner, compiler et exécuter le programme Java ConstructionDom.java.

ConstructionDom.java

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
 
import org.w3c.dom.Document;
import org.w3c.dom.Element;
 
public class ConstructionDom {
	public static void main(String[] argv) {
		try {
			/* Récupération d'une implantation et construction d'un document */
			DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
			DocumentBuilder db = dbf.newDocumentBuilder();
			Document doc = db.newDocument();
 
			/* Création de l'élément racine et ajout au document */
			Element eAnimaux = doc.createElement("Animaux");
			doc.appendChild(eAnimaux);
 
			/* Création d'un élément Enclos */
			Element eEnclos1 = doc.createElement("Enclos");
			/* Création d'un attribut */
			eEnclos1.setAttribute("nom", "Encl1");
			/* Ajout de l'enclos à l'élément racine */
			eAnimaux.appendChild(eEnclos1);
 
			/* Création d'un élément Animal et ajout à l'enclos */
			Element eAnimal1 = doc.createElement("Animal");
			eAnimal1.setAttribute("famille", "chat");
			eAnimal1.setAttribute("nom", "Tiger");
			/* Création de information sur cet animal (un noeud texte) */
			eAnimal1.appendChild(doc.createTextNode("Agressif !"));
			eEnclos1.appendChild(eAnimal1);
 
			TransformerFactory tf = TransformerFactory.newInstance();
			Transformer copy = tf.newTransformer();
			copy.transform(new DOMSource(doc), new StreamResult(System.out));
 
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

En vous inspirant de cet example et du programme TestAnimal.java, écrire une méthode qui prend en paramètre un Enclos (la méthode getAnimaux() retourne un objet de type List<Animal>) et qui crée un document DOM qui le représente en mémoire.

Un document DOM peut aussi être crée à partir de l’analyse d’un document XML (avec un parseur SaX), en utilisant la méthode parse() de la classe DocumentBuilder.

Ecrire un programme Java qui parse directement le fichier animaux.xml pour créer un document DOM. Tester ce programme en modifiant le document XML animaux.xml pour qu’il ne soit d’abord plus bien-formé, puis qu’il ne soit plus valide.

L’API DOM propose un ensemble de méthodes associées à un nœud pour accéder à d’autres nœuds. Le document peut donc être parcouru à partir de la racine. En plus de cela, trois méthode d’accès et parcours de plus haut niveau sont proposées : Iterator, NameNodeFilter et TreeWalker .

			// Parcours avec un node Iterator
			NodeIterator iter = ((DocumentTraversal) doc).createNodeIterator(
					doc.getDocumentElement(), NodeFilter.SHOW_ELEMENT, null,
					true);
			Node node;
			while ((node = iter.nextNode()) != null)
				System.out.println("-node iterator->" + node);
 
			TreeWalker tw = ((DocumentTraversal) doc).createTreeWalker(
					doc.getDocumentElement(), NodeFilter.SHOW_ELEMENT, null,
					true);
			System.out.println(")tw root)>"+tw.getCurrentNode());
			for (Node child = tw.firstChild(); child != null; child = tw
					.nextSibling()) {
				System.out.println("#tw childs#>" + child);
			}

En utilisant ces méthodes :

• Compter les nombres d’enclos
• Compter le nombre de chats
• Afficher le document sous la forme d’un arbre

http://docs.codehaus.org/display/STAX/Home

SimpleStax.java

import javax.xml.stream.*;
import java.net.URL;
import java.io.*;
 
public class SimpleStax {
 
    public static void main(String[] args) {
        String input = "file:///home/bruno/Bureau/XML/data/animaux.xml";
 
        try {
            URL u = new URL(input);
            InputStream in = u.openStream();
            XMLInputFactory factory = XMLInputFactory.newInstance();
            XMLStreamReader parser = factory.createXMLStreamReader(in);
 
            for (int event = parser.next();
                 event != XMLStreamConstants.END_DOCUMENT;
                 event = parser.next()) {
                switch (event) {
                    case XMLStreamConstants.START_ELEMENT:
                        System.out.println(parser.getLocalName());
                        break;
                    case XMLStreamConstants.END_ELEMENT:
                        break;
                    case XMLStreamConstants.CHARACTERS:
                        break;
                    case XMLStreamConstants.CDATA:
                        break;
                }
            }
            parser.close();
        }
        catch (XMLStreamException ex) {
            System.out.println(ex);
        }
        catch (IOException ex) {
            System.out.println("IOException while parsing " + input);
        }
 
    }
 
}

• écrire un programme qui affiche les noms des chat à partir du fichier animaux.xml.
• écrire un programme qui affiche le chemin complet (tous les ancêtres) de tous les éléments rencontrés.

Il existe une API dédiée à la transformation de document XML avec XSLT depuis Java TraX: Les fichiers illustre l’utilisation de cette API : TestXSLT.java et XPathTest.java.

Il existe une API pour XQuery en Java (comparable à JDBC) : XQJ

• Installer eXist-db http://exist-db.org/exist/apps/homepage/index.html
• Déposer le document XML exemple dans eXist
• Ecrire quelques requêtes XQuery dans l’IDE Web exide
• En utilisant les exemples du livre “XQuery pour interroger les données XML” http://bruno.lsis.univ-tln.fr/enseignement/xquery_pour_interroger_des_donnees_xml interroger le document dans exist via l’api XQJ.
  • une première approche : cf. http://xqj.net/exist/
  • un tutoriel : http://www.cfoster.net/articles/xqj-tutorial/

—- dataentry page —- type : TP enseignement_tags : D21 technologie_tags : Java,Sax,DOM,StaX,JAXP,XML,XQuery theme_tags : POO, Documents