Vous devez activer Javascript pour accéder à ce site
 

Semaine

RECHERCHE

DOM

Introduction

Nous supposons que vous disposez d'un environnement de développement Java et que vous ferez les exemples de ce tutoriel afin de mieux comprendre. Notre objectif est avant tout de vous rendre suffisamment à l'aise avec DOM pour pouvoir l'utiliser; nous vous invitons toutefois à naviguer dans le web pour en apprendre davantage sur le sujet, au besoin.

L'API Java elle-même est disponible sur le site d'Oracle. Pour pouvoir faire vos propres programmes, consultez l'API Java qui comprend tous les objets et fonctions du tutoriel.

Notions de base

On dit qu'un modèle DOM est une structure en arbre. En informatique, un arbre est un graphe ou une structure constituée de nœuds, de façon telle que chaque nœud a un et un seul parent - ou aucun -, lequel a un seul ou plusieurs enfants. Un seul nœud est autorisé à ne pas avoir de parent, c'est le nœud-racine. Pour illustrer notre propos, nous pouvons penser à une cellule qui se divise : chaque cellule a une et une seule cellule-parente, et chaque cellule peut se diviser (souvent en deux) ou mourir avant de pouvoir se diviser. On dit d'un nœud qui n'a pas d'enfant qu'il est un nœud-feuille.

Comme nous allons le voir, dans un arbre DOM, tous les éléments, les déclarations XML, etc., sont représentés par un nœud. Le nœud-racine est le document lui-même qui peut contenir la déclaration XML, la déclaration de type de document et l'élément-racine, comme ses enfants.

Point de vue critique

L'API DOM est très utilisée. Elle est supportée dans plusieurs langages, dont ECMAScript, Java, C#, C++, etc. parce qu'elle a été spécifiée avec l'Interface description language. Par contre, comme c'est un traitement du XML en arbre, les implémentations de l'API DOM consomment beaucoup de mémoire. En plus, l'API DOM fait travailler le programmeur en exigeant beaucoup de lignes de code pour faire les choses les plus simples. Il arrive aussi qu'une implémentation de l'API DOM soit beaucoup plus lente que des alternatives plus simples. Malgré tous ces défauts, le fait que l'API DOM soit si bien supportée en fait une référence incontournable.

Un document XML

Créons d'abord un document XML, que nous nommerons « test.xml », et un répertoire pour y déposer le fichier en question, ainsi que le code Java pour ce tutoriel.

<?xml version="1.0"  encoding="ISO-8859-1" ?>
 <liste>
 <joueur>
 <nom surnom="jojo">Jean</nom>
 <buts>32</buts>
 </joueur>
 <joueur>
 <nom surnom="Ma">Marie</nom>
 <buts>54</buts>
 </joueur>
 </liste>

Charger un document XML en Java

Écrivons maintenant un programme en Java qui va lire ce fichier XML. Pour ce faire, créons avec Notepad/Bloc-notes ou avec tout autre éditeur approprié, un fichier « test.java » contenant le texte suivant :

import org.w3c.dom.*;
import javax.xml.parsers.*;

 public class test {
    public static void main(String[] args) throws Exception {
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = factory.newDocumentBuilder();
       Document doc = parser.parse(args[0]); 
    }
 }

Ensuite, compilons et exécutons le programme :

 javac test.java
 java test test.xml

Si tout se passe bien, vous ne devriez rien voir s'afficher sur votre écran. En effet, les trois lignes de code Java utilisées plus haut ne font que créer l'objet « Document » qui contient, selon un modèle en arbre, notre document « test.xml ».

Java utilise un traitement événementiel (SAX) pour charger le fichier. Cependant, une fois que l'objet doc a été créé, vous pourriez effacer le fichier du disque sans mal. Le traitement du document se fait entièrement en mémoire.

Accès à l'élément-racine

Le premier élément que nous voulons consulter est l'élément-racine qui, dans notre cas, est un élément « liste ». Nous obtiendrons le résultat désiré en utilisant la méthode « getDocumentElement », comme ceci : 

import org.w3c.dom.*;
import javax.xml.parsers.*;

 public class test {
    public static void main(String[] args) throws Exception {
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = factory.newDocumentBuilder();
       Document doc = parser.parse(args[0]); 
       Element racine = doc.getDocumentElement(); 
    }
 }

Cet exemple n'est pas très intéressant puisque, encore une fois, rien ne s'affiche à l'écran. Par contre, nous avons maintenant un objet « racine » qui est un modèle de l'élément-racine du document XML et qui a le type d'une interface « Element ». L'interface « Element » est l'interface la plus importante en DOM. Notre nouvel objet « racine » a une méthode « getTagName() » qui permet de connaître le nom de l'élément. Par exemple, le code suivant devrait afficher le texte « liste » à l'écran.

import org.w3c.dom.*;
import javax.xml.parsers.*;

 public class test {
    public static void main(String[] args) throws Exception {
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = factory.newDocumentBuilder();
       Document doc = parser.parse(args[0]); 
       Element racine = doc.getDocumentElement(); 
       System.out.println(racine.getTagName()); 
    }
 }

Voici deux des méthodes importantes de l'interface « Element » :

MéthodeRésultat
getTagName()Donne le nom de l'élément
getAttribute(String nom)Donne la valeur d'un attribut

Point technique : Dans le cas où vous devez faire afficher du texte en ligne de commande sous un environnement Windows, il arrive que les accents ne passent pas. En effet, le jeu de caractère utilisé par l'outil de ligne de commande Windows est souvent Cp850. Il faut donc en informer Java en ajouter la ligne « System.setOut(new PrintStream(System.out, true, "Cp850")); » avant d'utiliser la méthode System.out.

L'interface « Node »

Dans le modèle DOM, l'arbre est un arbre fait de nœuds ou « nodes », en anglais. Plusieurs choses sont représentées par l'interface « Node » : du texte, un élément, une instruction de traitement, une déclaration de type de document, une entité, etc. L'arbre DOM commence à la racine par le document lui-même. Les attributs peuvent être traités comme des « Node », même s'ils ne font pas partie de l'arbre DOM : un attribut est une propriété d'un élément de l'arbre. Le modèle en arbre DOM peut être décrit ainsi : un document contient des « Node », et chaque « Node » contient d'autres « Node », etc.

L'interface « Node » possède deux méthodes très importantes : « getNodeName() » et « getNodeValue() ». La valeur donnée par l'une ou l'autre de ces deux méthodes dépend du type de nœud représenté. Le tableau suivant résume le comportement de ces méthodes pour différents types importants :

type de nœud nom DOM valeur de getNodeName() valeur de getNodeValue()
attribut Attr nom de l'attribut valeur de l'attribut
élément Element nom de l'élément null
instruction de traitement ProcessingInstruction cible de l'instruction contenu entier de l'instruction sans la cible
texte Text la chaîne « #text » le texte

Une autre méthode importante est « getNodeType ». Par exemple, si « e » est un nœud et que nous voulons vérifier s'il s'agit d'un élément, nous pouvons le faire comme ceci :

if( e.getNodeType() == Node.ELEMENT_NODE) {
 System.out.println(" Ce noeud est un élément!!! ");
 }

Demandons maintenant à DOM de nous fournir tous les sous-éléments « joueur » de l'élément-racine, comme ceci :

import org.w3c.dom.*;
import javax.xml.parsers.*;

 public class test {
    public static void main(String[] args) throws Exception {
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = factory.newDocumentBuilder();
       Document doc = parser.parse(args[0]);
       Element racine = doc.getDocumentElement(); 
       NodeList nl = racine.getElementsByTagName("joueur");
    }
 }

Nous avons utilisé la méthode « getElementsByTagName » qui nous permet d'obtenir la liste des sous-éléments ayant le nom XML donné. Une alternative est d'utiliser la méthode « getElementById » qui donne le seul élément ayant un attribut de type « ID » correspondant à la chaîne de caractères founie. En XHTML, par exemple, on peut ajouter un attribut nommé « id » qui a comme une valeur « ID ». Rappelons qu'un attribut a une valeur de type « ID » si elle est un nom XML et si toutes les valeurs de type « ID » dans le document sont différentes. L'avantage sur la méthode « getElementsByTagName » est qu'on peut rapidement sélectionner un unique élément.

L'interface « NodeList » est, quant à elle, très simple. Elle n'a que deux méthodes : « getLength() », qui retourne le nombre de « Node », et « item(int) », qui nous donne accès au « Node » en question. Donc, pour visiter tous les sous-éléments de l'élément-racine, nous pouvons faire comme ceci :

import org.w3c.dom.*;
import javax.xml.parsers.*;

 public class test {
    public static void main(String[] args) throws Exception {
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = 
        factory.newDocumentBuilder();
       Document doc = parser.parse(args[0]);
       Element racine = doc.getDocumentElement(); 
       NodeList nl = racine.getChildNodes();
       for (int i = 0; i < nl.getLength(); ++i) {
          Node n = nl.item(i);
       }
    }
 }

Les deux sous-éléments « joueur » de l'élément « liste » sont visités. Parce que les deux « Node » en question sont des éléments, nous aurions très bien pu écrire : 

import org.w3c.dom.*;
import javax.xml.parsers.*;

 public class test {
    public static void main(String[] args) throws Exception {
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = 
        factory.newDocumentBuilder();
       Document doc = parser.parse(args[0]);
       Element racine = doc.getDocumentElement(); 
       NodeList nl = racine.getChildNodes();
       for (int i = 0; i < nl.getLength(); ++i) {
          Element n = (Element) nl.item(i);
       }
    }
 }

Supposons maintenant que nous voulions afficher le contenu des deux éléments « joueur ». Nous pouvons y arriver en commençant comme ceci :

import org.w3c.dom.*;
import javax.xml.parsers.*;

 public class test {
    public static void main(String[] args) throws Exception {
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = 
        factory.newDocumentBuilder();
       Document doc = parser.parse(args[0]);
       Element racine = doc.getDocumentElement(); 
       NodeList nl = racine.getElementsByTagName("joueur");
       for (int i = 0; i < nl.getLength(); ++i) {
          Element joueur = (Element) nl.item(i);
          NodeList listedenoms = joueur.getElementsByTagName("nom");
          Element nom = (Element) listedenoms.item(0);
      }
   }
 }

En principe, nous avons maintenant les éléments « nom » des joueurs, mais comment faire pour obtenir le contenu textuel d'un élément? Nous devons savoir que le texte est lui-même un « Node ». Il suffit donc de sélectionner le premier et seul « Node » contenu dans l'élément « nom » et d'aller en chercher la valeur (getFirstChild().getNodeValue()), comme ceci :

import org.w3c.dom.*;
import javax.xml.parsers.*;

 public class test {
    public static void main(String[] args) throws Exception {
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = 
        factory.newDocumentBuilder();
       Document doc = parser.parse(args[0]);
       Element racine = doc.getDocumentElement(); 
       NodeList nl = racine.getElementsByTagName("joueur");
       for (int i = 0; i < nl.getLength(); ++i) {
          Element joueur = (Element) nl.item(i);
          NodeList listedenoms = joueur.getElementsByTagName("nom");
          Element nom = (Element) listedenoms.item(0);
          System.out.println(nom.getFirstChild().getNodeValue());
       }
    }
 }

Essayez maintenant ce programme. Vous devriez voir les noms des joueurs qui s'affichent. Si vous souhaitez ajouter le nombre de buts correspondant à chaque joueur, rien de plus facile! Il suffit de répéter le code comme dans l'exemple qui suit :

import org.w3c.dom.*;
import javax.xml.parsers.*;

 public class test {
    public static void main(String[] args) throws Exception {
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = 
        factory.newDocumentBuilder();
       Document doc = parser.parse(args[0]);
       Element racine = doc.getDocumentElement(); 
       NodeList nl = racine.getElementsByTagName("joueur");
       for (int i = 0; i < nl.getLength(); ++i) {
          Element joueur = (Element) nl.item(i);
          NodeList listedenoms = joueur.getElementsByTagName("nom");
          Element nom = (Element) listedenoms.item(0);
          System.out.println(nom.getFirstChild().getNodeValue());
          NodeList listedebuts = joueur.getElementsByTagName("buts");
          Element buts = (Element) listedebuts.item(0);
          System.out.println(buts.getFirstChild().getNodeValue());
      }
   }
 }

Dans l'éventualité ou un élément nom ne contiendrait pas de texte, la méthode getFirstChild() retourne la valeur null. Il faudrait donc cette éventualité (buts.getFirstChild()==null) afin d'éviter un plantage du programme.

Vous vous rappelez sans doute que les éléments « nom » ont un attribut « surnom ». Pour aller en chercher la valeur, il suffit d'utiliser la méthode « getAttribute » comme ceci :

import org.w3c.dom.*;
import javax.xml.parsers.*;

 public class test {
 public static void main(String[] args) throws Exception {
    DocumentBuilderFactory factory = 
     DocumentBuilderFactory.newInstance();
    DocumentBuilder parser = 
     factory.newDocumentBuilder();
    Document doc = parser.parse(args[0]);
    Element racine = doc.getDocumentElement(); 
    NodeList nl = racine.getElementsByTagName("joueur");
    for (int i = 0; i < nl.getLength(); ++i) {
       Element joueur = (Element) nl.item(i);
       NodeList listedenoms = joueur.getElementsByTagName("nom");
       Element nom = (Element) listedenoms.item(0);
       System.out.println(nom.getFirstChild().getNodeValue());
       System.out.println(nom.getAttribute("surnom"));
       NodeList listedebuts = joueur.getElementsByTagName("buts");
       Element buts = (Element) listedebuts.item(0);
       System.out.println(buts.getFirstChild().getNodeValue());
    }
  }
 }

Nous constatons que les attributs ne sont pas des « Node » et qu'ils sont donc plutôt traités comme faisant partie d'un élément. C'est logique; puisqu'un attribut ne peut contenir d'autres attributs, il ne forme donc pas un élément essentiel d'une structure en arbre, contrairement aux éléments.

Et c'est tout ce qu'il nous faut pour lire complètement le fichier XML « test.xml ». Vous pouvez bien sûr créer un programme plus sophistiqué!

Création de documents

À partir d'une structure DOM, nous pouvons créer un document XML en Java à l'aide de quelques lignes et du paquetage « javax.xml.transform » et de ses sous-paquetages.

L'écriture d'une structure DOM se fait vers un objet de type « Writer ». Si nous voulons écrire dans un fichier, nous devons créer un « FileWriter » et si nous voulons afficher à l'écran, nous passerons en paramètre l'objet « System.out ».

Par exemple, pour lire le document « test.xml », en faire une structure DOM et l'enregistrer, nous pouvons utiliser le programme suivant :

import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;

 public class construction {
    public static void main(String[] args) throws Exception {
    // lecture d'un document
    DocumentBuilderFactory factory = 
     DocumentBuilderFactory.newInstance();
    DocumentBuilder parser = 
     factory.newDocumentBuilder();
    Document doc = parser.parse(args[0]);
    // écriture d'un document
    TransformerFactory tfact = 
     TransformerFactory.newInstance();
    Transformer transformer = 
     tfact.newTransformer();
    DOMSource source = new DOMSource(doc);
    FileWriter fw = new FileWriter(args[1]);
    StreamResult result = new StreamResult(fw);
    transformer.transform(source, result);
    }
 }

Pour afficher à l'écran, nous aurions pu utiliser la syntaxe « new StreamResult(System.out); ».

Si nous enregistrons ce code Java dans un fichier nommé « construction.java », il suffira ensuite de taper : 

 javac construction.java
 java construction test.xml copy.xml

Le fichier qui en résulte, « copy.xml », devrait être pratiquement identique à « test.xml ». Nous pouvons évidemment utiliser cette approche pour créer des documents XML.

Nous allons maintenant créer un document XML « vide », avant de lui ajouter du contenu. Nommons le fichier du programme « construction2.java ». Nous utilisons la méthode « newDocument » :

import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;

 public class construction2 {
    public static void main(String[] args) throws Exception {
    DocumentBuilderFactory factory = 
     DocumentBuilderFactory.newInstance();
    DocumentBuilder parser = 
     factory.newDocumentBuilder();
    Document doc = parser.newDocument();
    }
 }

Si nous enregistrons ce document, il n'y aura que la déclaration XML. Créons maintenant un élément « liste » et ajoutons-le à notre document. Pour ce faire, nous utiliserons la méthode « createElement » de l'interface « Document » et la méthode « appendChild », comme ceci :

import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;

 public class construction2 {
    public static void main(String[] args) throws Exception {
    DocumentBuilderFactory factory = 
     DocumentBuilderFactory.newInstance();
    DocumentBuilder parser = 
     factory.newDocumentBuilder();
    Document doc = parser.newDocument();
    Element liste = doc.createElement("liste");
    doc.appendChild(liste);
   }
 }

Il est important de noter qu'on ne peut créer un élément ou autre nœud sans avoir d'abord un document. Un nœud DOM contient toujours une référence au document auquel il appartient, même si on ne l'a pas encore inséré dans le document avec une fonction « appendChild ». Il est impossible de prendre un élément d'un document et de l'insérer dans un autre document : vous risquez ainsi de vous retrouver avec un document dysfonctionnel. On peut cependant copier un nœud d'un document pour l'amener dans un nouveau document avec la méthode « importNode » de l'interface « Document ».

Nous pouvons donc créer un nouveau fichier avec le contenu de « test.xml », entièrement à partir de fonctions en Java. À chaque nœud, nous pouvons ajouter des enfants à l'aide de la méthode « appendChild ». Nous pouvons aussi créer des nœuds de texte à partir de la méthode « createTextNode » de l'interface « Document ». Finalement, l'interface « Element » a une méthode « setAttribute » pour créer un attribut.

Comme nous utilisons souvent « ISO-8859-1 » pour l'encodage de caractères, nous vous suggérons de spécifier l'attribut « encoding » du document XML, comme ceci : 

TransformerFactory tfact = TransformerFactory.newInstance();
Transformer transformer =  tfact.newTransformer();
transformer.setOutputProperty("encoding", "ISO-8859-1");

Le programme suivant va créer un document « nouveaufichier.xml » équivalent au fichier « test.xml » défini plus haut. Nous appellerons le fichier « construction3.java ».

import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;

 public class construction3 {
    public static void main(String[] args) throws Exception {
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = 
        factory.newDocumentBuilder();
       Document doc = parser.newDocument();
       Element liste = doc.createElement("liste");
       doc.appendChild(liste);
       Element joueur1 = doc.createElement("joueur");
       Element joueur2 = doc.createElement("joueur");
       liste.appendChild(joueur1);
       liste.appendChild(joueur2);
       Element nom1 = doc.createElement("nom");
       nom1.appendChild(doc.createTextNode("Jean"));
       Element nom2 = doc.createElement("nom");
       nom2.appendChild(doc.createTextNode("Marie"));
       joueur1.appendChild(nom1);
       joueur2.appendChild(nom2);
       Element but1 = doc.createElement("buts");
       but1.appendChild(doc.createTextNode("32"));
       Element but2 = doc.createElement("buts");
       but2.appendChild(doc.createTextNode("54"));
       joueur1.appendChild(but1);
       joueur2.appendChild(but2);
       nom1.setAttribute("surnom","jojo");
       nom2.setAttribute("surnom","Ma");
       TransformerFactory tfact = 
        TransformerFactory.newInstance();
       Transformer transformer = 
        tfact.newTransformer();
       transformer.setOutputProperty("encoding", "ISO-8859-1");
       DOMSource source = new DOMSource(doc);
       FileWriter fw = new FileWriter("nouveaufichier.xml");
       StreamResult result = new StreamResult(fw);
       transformer.transform(source, result);
   }
 }

Testez ce programme et modifiez-le pour explorer différentes possibilités. Il peut être utile de vérifier les fonctions disponibles dans le cadre de l'API Java.

Il est intéressant d'observer qu'il est possible d'ajouter à plusieurs reprises un nœud de texte à même un élément :

 e.appendChild(doc.createElement("a"));
 e.appendChild(doc.createElement("b"));
 e.appendChild(doc.createElement("c"));

Le contenu de l'élément, dans cet exemple, sera tout simplement le texte « abc » décomposé en 3 nœud.

Modifier un « Document »

Nous observons que l'écriture d'un document XML se fait à partir d'un objet « Document ». Rien ne nous empêche donc de charger un document XML, de le modifier et de l'enregistrer à nouveau.

Voici un tableau qui donne quelques fréquentes opérations de modification :

CodeRésultat
e.getParentNode().removeChild(e);Permet d'éliminer un nœud
e.getParentNode().replaceChild(e,f);Permet de remplacer un nœud par un autre
e.setAttribute(String nom, String valeur)Permet de modifier un attribut
e.removeAttribute(String nom)Permet d'éliminer un attribut

Par exemple, le programme suivant, « Modif.java », permet d'ajouter un attribut à l'élément-racine de tout document XML :

import org.w3c.dom.*;
import java.io.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;

 public class Modif {

    public static void main(String[] args) throws Exception {
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = 
        factory.newDocumentBuilder();
       Document doc = parser.parse(args[0]);
       Element racine = doc.getDocumentElement();
       racine.setAttribute("unattribut","une valeur");
       TransformerFactory tfact = 
        TransformerFactory.newInstance();
       Transformer transformer = 
        tfact.newTransformer();
          transformer.setOutputProperty("encoding", "ISO-8859-1");
   DOMSource source = new DOMSource(doc);
   FileWriter fw = new FileWriter(args[0]);
   StreamResult result = new StreamResult(fw);    
   transformer.transform(source, result);
   }
 }

Il suffit de l'appeler avec la syntaxe « java Modif monfichier.xml » où «monfichier.xml» est le nom d'un fichier d'intérêt disponible sur votre machine. (Remplacez éventuellement «monfichier.xml» par le véritable nom de fichier.)

Les espaces de noms

L'utilisation des espaces de noms est prévue en DOM (version 2.0). Par exemple, pour créer un élément appartenant à un espace de noms, il faut utiliser la syntaxe « createElementNS(String espace, String nom) », où « espace » prend la valeur de l'URI et « nom » contient le préfixe et le nom de l'élément. Cette nouvelle méthode vient remplacer le simple « createElement(String nom) ». Il existe aussi une méthode correspondante « setAttributeNS(String espace, String nom, String valeur) ».

Considérons l'exemple de document XML suivant :

<?xml version="1.0" encoding="ISO-8859-1"?>
 <md:racine xmlns:md="http://www.mondomaine.com/">
 <md:element md:unattribut="sa valeur"/></md:racine>

Pour le produire en DOM, il faudrait utiliser un code comme celui-ci :

import org.w3c.dom.*;
import java.io.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;

 public class Espace {
  
    public static void main(String[] args) throws Exception {
       String uri= "http://www.mondomaine.com/";
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = 
        factory.newDocumentBuilder();
       Document doc = parser.newDocument();
       Element racine = doc.createElementNS(uri,"md:racine");
       racine.setAttribute("xmlns:md",uri);
       doc.appendChild(racine);
       Element e = doc.createElementNS(uri,"md:element");
       racine.appendChild(e);
       e.setAttributeNS(uri,"md:unattribut","sa valeur");
       TransformerFactory tfact = 
        TransformerFactory.newInstance();
       Transformer transformer = 
        tfact.newTransformer();
       transformer.setOutputProperty("encoding", "ISO-8859-1");
       DOMSource source = new DOMSource(doc);
       StreamResult result = new StreamResult(System.out);
       transformer.transform(source, result);
   }
 }

Il faut nommer le fichier « Espace.java ».

Nous pouvons aussi retrouver l'espace de noms d'un élément à l'aide de la méthode « getNamespaceURI() » de l'interface « Node ». Cependant, par défaut, la classe « DocumentBuilderFactory » ignore les espaces de noms et il faut, par conséquent, ajouter la ligne « factory.setNamespaceAware(true); ». L'exemple du code qui suit donne l'espace de noms (URI), le préfixe et le nom de l'élément (avec le préfixe) de tout fichier XML saisi dans une ligne de commande :

import org.w3c.dom.*;
import javax.xml.parsers.*;

 public class LireEspace {
  
    public static void main(String[] args) throws Exception {
       DocumentBuilderFactory factory = 
        DocumentBuilderFactory.newInstance();
       factory.setNamespaceAware(true);
       DocumentBuilder parser = factory.newDocumentBuilder();
       Document doc = parser.parse(args[0]);
       Element racine = doc.getDocumentElement();
       System.out.println(racine.getNamespaceURI()+" "
       +racine.getPrefix()+" "+ racine.getTagName());
   }
 }

Il faut nommer le fichier « LireEspace.java », et l'exécuter avec la syntaxe « java LireEspace monfichier.xml ».

Livres de référence

© Daniel Lemire, 2014. Tous droits réservés.