Link Search Menu Expand Document
Structurez vos données avec XML

DOM - Exemple d’utilisation en Java

Dans le chapitre précédent, nous venons donc de faire connaissance avec l’API DOM. Dans ce nouveau chapitre, nous allons manipuler l’implémentation Java de cette technologie en découvrant ensemble, étape par étape, comment lire et créer un document XML.

Pour ceux d’entre vous qui n’utilisent pas Java ou qui sont plus à l’aise avec un autre langage de programmation, n’hésitez pas à aller faire une petite visite sur le forum du site du Zéro pour trouver des réponses à toutes vos questions !

Lire un document XML

Le document XML

Avant de plonger dans le code, voici le document XML que nous allons tenter d’exploiter :

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<repertoire>
  <!-- John DOE -->
  <personne sexe="masculin">
    <nom>DOE</nom>
    <prenom>John</prenom>
    <telephones>
      <telephone type="fixe">01 02 03 04 05</telephone>
      <telephone type="portable">06 07 08 09 10</telephone>
    </telephones>
  </personne>
</repertoire>

Mise en place du code

Étape 1 : récupération d’une instance de la classe “DocumentBuilderFactory”

Avant même de pouvoir prétendre créer un parseur DOM, nous devons récupérer une instance de la classe DocumentBuilderFactory. C’est à partir de cette instance que dans l’étape suivante nous pourrons créer notre parseur.

Pour récupérer une instance de la classe DocumentBuilderFactory une ligne de code suffit :

final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

Cette ligne de code s’accompagne de l’importation du package :

import javax.xml.parsers.DocumentBuilderFactory;

Étape 2 : création d’un parseur

La seconde étape consiste à créer un parseur à partir de notre variable factory créée dans l’étape 1.

Une nouvelle fois, une seule ligne de code est suffisante :

final DocumentBuilder builder = factory.newDocumentBuilder();

Pour pouvoir utiliser la classe DocumentBuilder, le package suivant est nécessaire :

import javax.xml.parsers.DocumentBuilder;

Puisque l’appel à la fonction newDocumentBuilder(), peut lever une exception, il convient de le placer dans un bloc de type try/catch :

try 
{
  final DocumentBuilder builder = factory.newDocumentBuilder();
}
catch (final ParserConfigurationException e) 
{
  e.printStackTrace();
}

La gestion de cette exception oblige à également importer le package :

import javax.xml.parsers.ParserConfigurationException;

Étape 3 : création d’un Document

La troisième étape consiste à créer un Document à partir du parseur de l’étape 2. Plusieurs possibilités s’offre alors à vous :

  • A partir d’un fichier.
  • A partir d’un flux.

Ce flux peut par exemple être le résultat de l’appel à un web service. Dans notre exemple, c’est un fichier qui est utilisé :

final Document document= builder.parse(new File("repertoire.xml"));

Comme à chaque nouvelle instruction, des packages doivent être importés :

import java.io.File;
import org.w3c.dom.Document;

De nouvelles exceptions pouvant être levées, il convient également de modifier leurs captures dans des blocs catch. Voici alors ce que vous devriez avoir :

try 
{
  final DocumentBuilder builder = factory.newDocumentBuilder();     
  final Document document= builder.parse(new File("repertoire.xml"));
}
catch (final ParserConfigurationException e) 
{
  e.printStackTrace();
}
catch (final SAXException e) 
{
  e.printStackTrace();
}
catch (final IOException e) 
{
  e.printStackTrace();
}

La gestion de ces nouvelles exceptions nous oblige également à importer quelques packages :

import java.io.IOException;
import org.xml.sax.SAXException;

Comme je vous le disais dans le chapitre précédent, un Document représente le document XML dans son intégralité. Il contient son prologue et son corps. Nous allons pouvoir le vérifier en affichant les éléments du prologue, à savoir :

  • La version XML utilisée.
  • L’encodage utilisé.
  • S’il s’agit d’un document “standalone” ou non.
//Affiche la version de XML
System.out.println(document.getXmlVersion());

//Affiche l'encodage
System.out.println(document.getXmlEncoding());  

//Affiche s'il s'agit d'un document standalone      
System.out.println(document.getXmlStandalone());

A l’exécution du programme, voici ce que vous devriez avoir à l’écran :

UTF-8
1.0
true

Si l’on compare cet affichage au prologue du document XML, on se rend compte que les informations correspondent bien.

Étape 4 : récupération de l’Element racine

Dans cette quatrième étape, nous allons laisser de côté le prologue et tenter de nous attaquer au corps du document XML. Pour ce faire, nous allons extraire l’Element racine du Document. C’est à partir de lui que nous pourrons ensuite naviguer dans le reste du document.

Pour récupérer l’élément racine, il suffit de faire appel à la fonction getDocumentElement() de notre document :

final Element racine = document.getDocumentElement();

Une nouvelle fois, pour pouvoir utiliser la classe Element, le package suivant doit être importé :

import org.w3c.dom.Element;

Nous pouvons dès maintenant vérifier que ce que nous venons de récupérer est bien l’élément racine de notre document en affichant son nom :

System.out.println(racine.getNodeName());

Après exécution du programme, voici ce que vous devriez avoir à l’écran :

repertoire

Étape 5 : récupération des personnes

C’est à partir de cette étape que les choses sérieuses commencent ! En effet, dans cette cinquième étape, nous allons réellement parcourir le corps de notre document XML.

Il est possible de parcourir un document XML sans connaître sa structure. Il est donc possible de créer un code assez générique notamment grâce à la récursivité. Cependant, ce n’est pas la méthode que j’ai choisi d’utiliser dans ce chapitre. 😉 Nous allons donc parcourir notre document en partant du principe que nous connaissons sa structure.

Pour récupérer tous les noeuds enfants de la racine, voici la ligne de code à écrire :

final NodeList racineNoeuds = racine.getChildNodes();

Il vous faudra également importer le package suivant :

import org.w3c.dom.NodeList;

Nous pouvons également nous amuser à afficher le nom de chacun des nœuds via le code suivant :

final int nbRacineNoeuds = racineNoeuds.getLength();
            
for (int i = 0; i<nbRacineNoeuds; i++) 
{
  System.out.println(racineNoeuds.item(i).getNodeName());
}

Vous devriez alors avoir le résultat suivant :

#text
#comment
#text
personne
#text

On retrouve bien notre balise <personne /> au milieu d’autres nœuds de type text et comment. Nous allons maintenant légèrement modifier notre boucle afin de n’afficher à l’écran que les nœuds étant des éléments. Grâce à la méthode getNodeType() de la classe Node :

for (int i = 0; i<nbRacineNoeuds; i++) 
{
  if(racineNoeuds.item(i).getNodeType() == Node.ELEMENT_NODE) 
  {
    final Node personne = racineNoeuds.item(i);
    System.out.println(personne.getNodeName());
  }             
}

A l’exécution de votre programme, vous devriez normalement avoir le résultat suivant :

personne

A noter : si nous avions voulu récupérer le commentaire, nous aurions comparé le type de notre nœud à la constante Node.COMMENT_NODE.

Avant de passer à l’affichage de la suite du document XML, nous allons tenter d’afficher le sexe de la personne, qui pour rappel est un attribut. Il existe plusieurs manières de faire plus ou moins génériques. La méthode la plus générique est de faire appelle à la méthode getAttributes() de la classe Node qui nous renvoie l’ensemble des attributs du nœud. Dans notre cas, nous allons utiliser la méthode getAttribute(nom) qui nous renvoie la valeur de l’attribut spécifié en paramètre. Cette méthode n’est cependant pas accessible à partir de la classe Node, il convient donc de “caster” notre nœud en un Element pour pouvoir l’appeler :

for (int i = 0; i<nbRacineNoeuds; i++) 
{
  if(racineNoeuds.item(i).getNodeType() == Node.ELEMENT_NODE) 
  {
    final Element personne = (Element) racineNoeuds.item(i);
    System.out.println(personne.getNodeName());
    System.out.println("sexe : " + personne.getAttribute("sexe"));
  }             
}

A l’écran devrait alors s’afficher le résultat suivant :

personne
sexe : masculin

Étape 6 : récupération du nom et du prénom

Nous allons maintenant récupérer le nom et le prénom des personnes présentes dans notre document XML. Puisque nous savons exactement ce que l’on souhaite récupérer, nous allons y accéder directement via la méthode getElementsByTagName(name) de l’objet Element. Cette méthode nous renvoie tous les éléments contenus dans l’élément et portant le nom spécifié.

Pour mieux comprendre, voyons un exemple :

final NodeList noms = personne.getElementsByTagName("nom");

Ainsi, nous venons de récupérer tous les éléments d’une personne ayant pour nom “nom”. Dans notre cas, nous savons qu’une personne ne peut avoir qu’un seul nom, nous pouvons donc préciser que nous voulons le premier élément de la liste :

final Element nom = (Element) personne.getElementsByTagName("nom").item(0);

Finalement, si l’on souhaite afficher le Text de la balise, il nous suffit d’appeler la méthode getTextContent() :

System.out.println(nom.getTextContent());

Vous devriez alors voir s’afficher à l’écran le nom de la seule personne déclarée dans notre document XML :

DOE

Pour extraire le prénom d’une personne, la logique est exactement la même. 😉

Étape 7 : récupération des numéros de téléphone

La septième et dernière étape de la lecture de notre document XML consiste à récupérer les numéros de téléphone d’une personne. La logique est sensiblement la même que dans l’étape 6 si ce n’est que le résultat de la méthode getElementsByTagName(name) nous renverra éventuellement plusieurs résultats. Il suffit alors de boucler sur les résultats pour afficher les valeurs et les attributs.

Voici le code qui devrait être écrit :

final NodeList telephones = personne.getElementsByTagName("telephone");
final int nbTelephonesElements = telephones.getLength();
                    
for(int j = 0; j<nbTelephonesElements; j++) 
{
  final Element telephone = (Element) telephones.item(j);
  System.out.println(telephone.getAttribute("type") + " : " + telephone.getTextContent());
}

Vous devriez alors voir s’afficher à l’écran la liste des numéros de téléphones :

fixe : 01 02 03 04 05
portable : 06 07 08 09 10

Le code complet

Nous venons donc de lire ensemble notre premier document XML ! Pour ceux qui en auraient besoin, vous trouverez le code complet du petit programme que nous venons d’écrire juste en dessous :

import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class ReadXMLFile 
{
    
  public static void main(final String[] args) 
  {
    /*
     * Etape 1 : récupération d'une instance de la classe "DocumentBuilderFactory"
     */
    final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        
    try 
    {
      /*
       * Etape 2 : création d'un parseur
       */
      final DocumentBuilder builder = factory.newDocumentBuilder();
            
      /*
       * Etape 3 : création d'un Document
       */
      final Document document= builder.parse(new File("repertoire.xml"));
            
      //Affichage du prologue
      System.out.println("*************PROLOGUE************");
      System.out.println("version : " + document.getXmlVersion());
      System.out.println("encodage : " + document.getXmlEncoding());        
      System.out.println("standalone : " + document.getXmlStandalone());
                    
      /*
       * Etape 4 : récupération de l'Element racine
       */
      final Element racine = document.getDocumentElement();
        
      //Affichage de l'élément racine
      System.out.println("\n*************RACINE************");
      System.out.println(racine.getNodeName());
        
      /*
       * Etape 5 : récupération des personnes
       */
      final NodeList racineNoeuds = racine.getChildNodes();
      final int nbRacineNoeuds = racineNoeuds.getLength();
            
      for (int i = 0; i<nbRacineNoeuds; i++) 
      {
        if(racineNoeuds.item(i).getNodeType() == Node.ELEMENT_NODE) 
        {
          final Element personne = (Element) racineNoeuds.item(i);
                
          //Affichage d'une personne
          System.out.println("\n*************PERSONNE************");
          System.out.println("sexe : " + personne.getAttribute("sexe"));
            
          /*
           * Etape 6 : récupération du nom et du prénom
           */
          final Element nom = (Element) personne.getElementsByTagName("nom").item(0);
          final Element prenom = (Element) personne.getElementsByTagName("prenom").item(0);
                    
          //Affichage du nom et du prénom
          System.out.println("nom : " + nom.getTextContent());
          System.out.println("prénom : " + prenom.getTextContent());
                    
          /*
           * Etape 7 : récupération des numéros de téléphone
           */
          final NodeList telephones = personne.getElementsByTagName("telephone");
          final int nbTelephonesElements = telephones.getLength();
                    
          for(int j = 0; j<nbTelephonesElements; j++) 
          {
            final Element telephone = (Element) telephones.item(j);
          
            //Affichage du téléphone
            System.out.println(telephone.getAttribute("type") + " : " + telephone.getTextContent());
          }
        }               
      }         
    }
    catch (final ParserConfigurationException e) 
    {
      e.printStackTrace();
    }
    catch (final SAXException e) 
    {
      e.printStackTrace();
    }
    catch (final IOException e) 
    {
      e.printStackTrace();
    }       
  }
}

Ecrire un document XML

Le document XML

Dans le chapitre précédent, nous avons vu comment lire un document XML. Dans ce chapitre, je vous propose d’en créer un de toute pièce. Voici le document que nous allons créer :

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<repertoire>
  <!-- John DOE -->
  <personne sexe="masculin">
    <nom>DOE</nom>
    <prenom>John</prenom>
    <telephones>
      <telephone type="fixe">01 02 03 04 05</telephone>
      <telephone type="portable">06 07 08 09 10</telephone>
    </telephones>
  </personne>
</repertoire>

Je suis sûr que vous le connaissez. 😉

Mise en place du code

Étape 1 : récupération d’une instance de la classe “DocumentBuilderFactory”

Comme pour la lecture d’un document XML, la première étape consiste à récupérer une instance de la classe DocumentBuilderFactory. C’est à partir de cette instance que notre parseur sera créé dans l’étape suivante :

final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

N’oubliez pas d’importer le package :

import javax.xml.parsers.DocumentBuilderFactory;

Étape 2 : création d’un parseur

La seconde étape est également commune à la lecture d’un document XML. Ainsi, nous allons créer un parseur à partir de notre variable factory créée dans l’étape précédente :

final DocumentBuilder builder = factory.newDocumentBuilder();

Cette ligne de code s’accompagne de l’importation du package suivant :

import javax.xml.parsers.DocumentBuilder;

Bien que nous l’ayons déjà vu dans le chapitre précédent, n’oubliez pas qu’une exception peut être levée, c’est pourquoi cette instruction doit être placée dans un bloc de type try/catch :

try 
{
  final DocumentBuilder builder = factory.newDocumentBuilder();
}
catch (final ParserConfigurationException e) 
{
  e.printStackTrace();
}

La gestion de cette exception nous oblige à également importer le package suivant :

import javax.xml.parsers.ParserConfigurationException;

Étape 3 : création d’un Document

La trosième étape consiste à créer un Document vierge. Ce document est créé à partir de notre parseur :

final Document document = builder.newDocument();

Pour pouvoir utiliser la classe Document, n’oubliez pas d’importer le package suivant :

import org.w3c.dom.Document;

Étape 4 : création de l’Element racine

Dans cette quatrième étape, nous allons créer l’élément racine de notre document XML, à savoir la balise <repertoire />. La création de l’élément racine se fait via notre document et plus particulièrement la fonction createElement() qui prend en paramètre le nom que l’on souhaite donner à la balise :

final Element racine = document.createElement("repertoire");

A noter que l’utilisation de la classe Element s’accompagne de l’importation du package :

import org.w3c.dom.Element;

Maintenant que notre élément racine est déclaré, nous pouvons l’ajouter à notre document :

document.appendChild(racine);

Étape 5 : création d’une personne

Si l’on regarde le document XML que l’on doit créer, on s’aperçoit qu’avant de créer la balise <personne/>, nous devons créer un commentaire.

La création d’un commentaire n’est pas plus compliquée que la création d’une balise et se fait via la fonction createComment() du document qui prend comme paramètre le fameux commentaire :

final Comment commentaire = document.createComment("John DOE");

Pour pouvoir déclarer un commentaire, n’oubliez pas d’importer le package suivant :

import org.w3c.dom.Comment;

Il convient ensuite d’ajouter notre commentaire à la suite de notre document et plus spécifiquement à la suite de notre élément racine. Si l’on se réfère à l’arbre XML, le commentaire est réellement un sous élément de l’élément racine. C’est pourquoi celui-ci est ajouté en tant qu’enfant de l’élément racine :

racine.appendChild(commentaire);

Nous pouvons maintenant nous attaquer à la création de la balise <personne />. Il s’agit d’un élément au même titre que l’élément racine que nous avons déjà vu. Puisque la balise est au même niveau que le commentaire, il convient de l’ajouter en tant qu’enfant de l’élément racine :

final Element personne = document.createElement("personne");
racine.appendChild(personne);

Si l’on s’arrête ici, on omet d’ajouter l’attribut “sexe” pourtant présent dans la balise <personne /> du document XML que l’on souhaite créer. Ajouter un attribut à un élément est en réalité très simple et se fait via la méthode setAttribute() de la classe Element. Cette méthode prend 2 paramètres : le nom de l’attribut et sa valeur.

personne.setAttribute("sexe", "masculin");

Étape 6 : création du nom et du prénom

En soit, la création des balises <nom /> et <prenom /> n’a rien de compliqué. En effet, nous avons déjà créé ensemble plusieurs éléments.

final Element nom = document.createElement("nom");
final Element prenom = document.createElement("prenom");
            
personne.appendChild(nom);
personne.appendChild(prenom);

Ici, la nouveauté concerne le renseignement de la valeur contenue dans les balises, à savoir John DOE dans notre exemple. Pour ce faire, il convient d’ajouter à nos balises un enfant de type Text. Cet enfant doit être créé avec la méthode createTextNode() du document qui prend en paramètre la valeur :

nom.appendChild(document.createTextNode("DOE"));
prenom.appendChild(document.createTextNode("John"));

Étape 7 : création des numéros de téléphone

Je vais aller très vite sur cette étape en vous fournissant directement le code source. En effet, cette septième étape ne contient rien de nouveau par rapport à ce que nous avons vu jusqu’ici :

final Element telephones = document.createElement("telephones");
            
final Element fixe = document.createElement("telephone");
fixe.appendChild(document.createTextNode("01 02 03 04 05"));
fixe.setAttribute("type", "fixe");
            
final Element portable = document.createElement("telephone");
portable.appendChild(document.createTextNode("06 07 08 09 10"));
portable.setAttribute("type", "portable");
            
telephones.appendChild(fixe);
telephones.appendChild(portable);
personne.appendChild(telephones);

Étape 8 : affichage du résultat

Il est maintenant temps de passer à la dernière étape qui consiste à afficher notre document XML fraîchement créé. Deux possibilités s’offrent à nous :

  • Dans un document XML.
  • Dans la console de l’IDE.

Ne vous inquiétez pas, les 2 possibilités seront abordées dans ce tutoriel. 😉

Pour pouvoir afficher notre document XML, nous allons avoir besoin de plusieurs objets Java. Le premier est une instance de la classe TransformerFactory :

final TransformerFactory transformerFactory = TransformerFactory.newInstance();

La récupération de cette instance s’accompagne de l’importation du package suivant :

import javax.xml.transform.TransformerFactory;

Nous allons utiliser cette instance pour créer un objet Transformer. C’est grâce à lui que nous pourrons afficher notre document XML par la suite :

final Transformer transformer = transformerFactory.newTransformer();

A noter que la fonction newTransformer() peut lever une exception de type TransformerConfigurationException qu’il est important de capturer via un bloc catch.

N’oubliez pas d’importer les packages suivants :

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;

Pour afficher le document XML, nous utiliserons la méthode transform() de notre transformer. Cette méthode prend en compte 2 paramètres :

  • La source.
  • La sortie.
transformer.transform(source, sortie);

A noter qu’une exception de type TransformerException est susceptible d’être levée :

import javax.xml.transform.TransformerException;

En ce qui nous concerne, la source que l’on souhaite afficher est notre document XML. Cependant, nous ne pouvons pas passer notre objet document tel quel. Il convient de le transformer légèrement sous la forme d’un objet DOMSource :

final DOMSource source = new DOMSource(document);

Pour pouvoir utiliser cette classe, il convient d’importer le package suivant :

import javax.xml.transform.dom.DOMSource;

Maintenant que nous avons la source, occupons nous de la sortie. La sortie est en réalité un objet StreamResult. C’est ici que nous allons préciser si nous souhaitons afficher notre document dans un fichier ou dans la console de notre IDE :

//Code à utiliser pour afficher dans un fichier
final StreamResult sortie = new StreamResult(new File("F:\\file.xml"));

//Code à utiliser pour afficher dans la console
final StreamResult sortie = new StreamResult(System.out);

Encore une fois, l’importation d’un package est nécessaire :

import javax.xml.transform.stream.StreamResult;

Avant d’exécuter notre programme, il nous reste encore quelques petits détails à régler : l’écriture du prologue et le formatage de l’affichage.

Commençons par le prologue. Nous allons renseigner ses différentes propriétés via la méthode setOutputProperty() de notre transformer qui prend en paramètre le nom du paramètre et sa valeur :

transformer.setOutputProperty(OutputKeys.VERSION, "1.0");
transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
transformer.setOutputProperty(OutputKeys.STANDALONE, "yes");

Pour pouvoir utiliser les constantes de la classe OutputKeys, il convient d’importer le package suivant :

import javax.xml.transform.OutputKeys;

Si nous exécutons notre programme maintenant, tout sera écrit sur une seule ligne, ce qui n’est pas très lisible, vous en conviendrez. C’est pourquoi nous allons donner quelques règles de formatage à notre transformer. En effet, ce que l’on souhaite c’est que notre document soit indenté. Chaque niveau différent de notre document XML sera alors décalé de 2 espaces :

transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");

Le code complet

Nous venons donc de créer notre premier document XML ! Pour ceux qui en auraient besoin, vous trouverez le code complet du petit programme que nous venons d’écrire juste en dessous :

import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class ReadXMLFile 
{
    
  public static void main(final String[] args) {
    /*
     * Etape 1 : récupération d'une instance de la classe "DocumentBuilderFactory"
     */
    final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        
    try 
    {
      /*
       * Etape 2 : création d'un parseur
       */
      final DocumentBuilder builder = factory.newDocumentBuilder();
            
      /*
       * Etape 3 : création d'un Document
       */
      final Document document= builder.newDocument();
                    
      /*
       * Etape 4 : création de l'Element racine
       */
      final Element racine = document.createElement("repertoire");
      document.appendChild(racine);         
            
      /*
       * Etape 5 : création d'une personne
       */
      final Comment commentaire = document.createComment("John DOE");
      racine.appendChild(commentaire);
            
      final Element personne = document.createElement("personne");
      personne.setAttribute("sexe", "masculin");
      racine.appendChild(personne);
            
      /*
       * Etape 6 : création du nom et du prénom
       */
      final Element nom = document.createElement("nom");
      nom.appendChild(document.createTextNode("DOE"));
            
      final Element prenom = document.createElement("prenom");
      prenom.appendChild(document.createTextNode("John"));
            
      personne.appendChild(nom);
      personne.appendChild(prenom);         
                            
      /*
       * Etape 7 : création des numéros de téléphone
       */
      final Element telephones = document.createElement("telephones");
      
      final Element fixe = document.createElement("telephone");
      fixe.appendChild(document.createTextNode("01 02 03 04 05"));
      fixe.setAttribute("type", "fixe");
            
      final Element portable = document.createElement("telephone");
      portable.appendChild(document.createTextNode("06 07 08 09 10"));
      portable.setAttribute("type", "portable");
            
      telephones.appendChild(fixe);
      telephones.appendChild(portable);
      personne.appendChild(telephones);
            
      /*
       * Etape 8 : affichage
       */
      final TransformerFactory transformerFactory = TransformerFactory.newInstance();
      final Transformer transformer = transformerFactory.newTransformer();
      final DOMSource source = new DOMSource(document);
      final StreamResult sortie = new StreamResult(new File("F:\\file.xml"));
      //final StreamResult result = new StreamResult(System.out);
            
      //prologue
      transformer.setOutputProperty(OutputKeys.VERSION, "1.0");
      transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
      transformer.setOutputProperty(OutputKeys.STANDALONE, "yes");          
            
      //formatage
      transformer.setOutputProperty(OutputKeys.INDENT, "yes");
      transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
            
      //sortie
      transformer.transform(source, sortie);    
    }
    catch (final ParserConfigurationException e)
    {
      e.printStackTrace();
    }
    catch (TransformerConfigurationException e) 
    {
      e.printStackTrace();
    }
    catch (TransformerException e) 
    {
      e.printStackTrace();
    }           
  }
}

Vous savez maintenant lire et écrire un document XML grâce à l’implémentation Java de l’API DOM.

Exceptionnellement, il n’y aura pas de TP sur cette technologie. En effet, DOM étant implémenté dans de nombreux langages de programmation, il est impossible pour moi de proposer une correction dans chacun des langages utilisés !

Ce cours vous plait ?

Retrouvez ce cours en livre physique sur Amazon !