L'analyse XML

Ce matériel couvre les fondamentaux de l'analyse XML, en particulier l'utilisation du modèle DOM (Document Object Model) et son API en Java. Il s'adresse aux étudiants en informatique souhaitant apprendre à lire et écrire des documents XML à l'aide de Java, en comprenant la structure en arbre du DOM et les principales interfaces associées.

Introduction à XML et aux parseurs

XML est un langage de structuration et de représentation de données. Il ne contient pas d'instructions de contrôle et ne permet pas d'exploiter directement les données. Pour manipuler des documents XML, on utilise des langages de programmation classiques comme Java, PHP, C++ ou Python.

Un parseur XML est un outil qui analyse un fichier XML, extrait les balises, leur contenu et leurs attributs, et les rend accessibles aux applications. Il découpe le fichier en "tokens" (mots) exploitables.

Exemples de parseurs XML :

• Parseur XML DOM
• Parseur XML SAX

Le modèle DOM (Document Object Model)

Le DOM est une technologie qui permet de lire un document XML et d'en extraire des informations (éléments, attributs, commentaires, etc.). Lorsqu'un document XML est lu par un parseur DOM, il est représenté en mémoire sous la forme d'un arbre. Les éléments sont liés par des relations parent/enfant, ce qui facilite la navigation entre eux.

Par exemple, un document XML peut être visualisé comme un arbre où chaque balise est un nœud, et les nœuds enfants sont les sous-éléments contenus dans la balise parente.

L'API DOM

Introduction à l'API DOM

L'API DOM est un ensemble de méthodes, classes et interfaces basées sur la programmation orientée objet, permettant de naviguer et de créer des documents XML. Elle est indépendante de toute plateforme ou langage, et est implémentée dans de nombreux langages comme Java, C++, C#, PHP, etc.

Les principaux éléments de l'API DOM

Toutes les classes et interfaces sont regroupées dans le package org.w3c.dom. Chaque type d'entité dans l'arbre DOM est défini par une interface. L'interface de base est Node, dont héritent plusieurs autres interfaces.

• Interface Node : représente un nœud de l'arbre. Elle définit plusieurs méthodes, notamment getNodeType() qui permet de connaître le type du nœud (élément, texte, commentaire, etc.).
• Interface NodeList : représente une liste ordonnée de nœuds selon l'ordre du document XML. Elle définit des méthodes pour accéder aux nœuds de la liste.
• Interface Document : représente la racine de l'arbre DOM. Elle hérite de Node et possède toujours le type DOCUMENT_NODE.
• Interface Element : représente un élément XML (une balise). Elle hérite de Node et a pour type ELEMENT_NODE. Elle permet de manipuler les attributs et sous-éléments.
• Interface CharacterData : permet de manipuler les données de type PCDATA (texte).
• Interface Attr : permet de manipuler les attributs d'un élément.
• Interface Comment : représente un nœud commentaire (balise ). Elle étend CharacterData.
• Interface Text : représente un nœud de type texte, contenu d'un élément ou valeur d'un attribut.

Exemple d'utilisation en Java

Lire un document XML

Voici les étapes pour lire un document XML avec l'API DOM en Java :

1. Récupération d'une instance de DocumentBuilderFactory :

   DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

2. Création d'un parseur DocumentBuilder :

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

3. Création d'un Document à partir d'un fichier XML :

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

4. Récupération de l'élément racine :

   Element racine = document.getDocumentElement();
   System.out.println(racine.getNodeName()); // Affiche : repertoire

5. Récupération des nœuds enfants de la racine :

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

   Ce code affiche des nœuds de types texte, commentaire et élément, par exemple :

#text
#comment
#text
personne
#text

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

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

Element nom = (Element) personne.getElementsByTagName("nom").item(0);
System.out.println(nom.getTextContent()); // Affiche : DEO

NodeList telephones = personne.getElementsByTagName("telephone");
int nbTelephonesElements = telephones.getLength();
for (int j = 0; j < nbTelephonesElements; j++) {
    Element telephone = (Element) telephones.item(j);
    System.out.println(telephone.getAttribute("type") + " : " + telephone.getTextContent());
}
// Affiche :
// fixe : 01 02 03 04 05
// portable : 06 07 08 09 10

Écrire un document XML

Voici les étapes pour créer un document XML en Java avec l'API DOM :

1. Récupération d'une instance de DocumentBuilderFactory et création d'un parseur (identique à la lecture).
2. Création d'un Document vierge :

   Document document = builder.newDocument();

3. Création de l'élément racine :

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

4. Création d'un commentaire :

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

5. Création de l'élément personne avec un attribut :

   Element personne = document.createElement("personne");
   personne.setAttribute("sexe", "masculin");
   racine.appendChild(personne);

Element nom = document.createElement("nom");
Element prenom = document.createElement("prenom");
nom.appendChild(document.createTextNode("DOE"));
prenom.appendChild(document.createTextNode("John"));
personne.appendChild(nom);
personne.appendChild(prenom);

Element telephones = document.createElement("telephones");

Element fixe = document.createElement("telephone");
fixe.appendChild(document.createTextNode("01 02 03 04 05"));
fixe.setAttribute("type", "fixe");

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);

TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();

DOMSource source = new DOMSource(document);
StreamResult sortie = new StreamResult(new File("F:\\file.xml"));

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

transformer.transform(source, sortie);

Glossaire des termes clés

• XML : Langage de structuration et de représentation de données.
• Parseur XML : Outil qui analyse un fichier XML et extrait ses composants (balises, attributs, contenu).
• DOM (Document Object Model) : Modèle de représentation d'un document XML sous forme d'arbre en mémoire.
• Node : Interface de base représentant un nœud dans l'arbre DOM.
• NodeList : Liste ordonnée de nœuds.
• Document : Racine de l'arbre DOM, représentant l'ensemble du document XML.
• Element : Nœud représentant une balise XML.
• Attr : Interface pour manipuler les attributs d'un élément.
• Comment : Nœud représentant un commentaire XML.
• Text : Nœud représentant le texte contenu dans une balise ou un attribut.
• DocumentBuilderFactory : Classe Java pour créer des instances de parseurs DOM.
• DocumentBuilder : Parseur DOM permettant de lire ou créer des documents XML.
• Transformer : Objet Java permettant de transformer un document DOM en sortie (fichier, console).

Points clés à retenir

• XML est un langage de données, non un langage de programmation.
• Le modèle DOM représente un document XML sous forme d'arbre en mémoire, facilitant la navigation et la manipulation.
• L'API DOM en Java permet de lire, créer, modifier et écrire des documents XML.
• Les nœuds DOM sont typés (éléments, texte, commentaires, attributs) et accessibles via des interfaces spécifiques.
• Pour lire un document XML, on crée un parseur, on charge le document, puis on navigue dans l'arbre via les méthodes de l'API DOM.
• Pour écrire un document XML, on crée un document vide, on construit l'arbre en créant des éléments et des nœuds texte, puis on utilise un Transformer pour générer le fichier XML.
• La méthode getElementsByTagName permet d'accéder directement aux éléments d'un certain nom.
• Les attributs se manipulent via les méthodes getAttribute et setAttribute de l'interface Element.