INaLCO - M2 Ingénierie Multilingue

Techniques XML, cours n°3 - version provisoire

Jean-François Perrot

DOM (Document Object Model)


  1. I. Notion de parseur XML, SAX & DOM
    1. Principe général
    2. L'exemple classique de la compilation des programmes
    3. Ce que XML apporte
    4. Modalités
      1. Deux manières de lire un fichier XML : SAX & DOM
      2. Généralités sur DOM :

  2. II. DOM - Java
    1. L'interface Node
    2. L'interface Document
    3. L'interface Element

  3. III. Un exemple simple


I. Notion de parseur XML, SAX & DOM

  1. Vous avez dit, parseur ?

    On fit aussi analyseur syntaxique...
    Cet objet omniprésent en informatique résout le problème très général que voici :
    Vu sous un autre angle :
    L'analyse syntaxique est donc le processus qui fait passer d'un texte (structure unidimensionnelle) à un arbre (structure bidimensionnelle). La suite du traitement consiste en des transformations d'arbres, puis en une interprétation du dernier arbre produit.
    Par exemple, la visualisation d'une fichier XML dans une page Web par le truchement d'une feuille de style XSLT
    passe par trois étapes :
    1. Lecture et analyse syntaxique du fichier XML, construisant l'arbre associé ;
    2. Transformation de cet arbre en un arbre HTML par l'action de la feuille de style ;
    3. Interprétation de l'arbre HTML par le navigateur, aboutissant à sa visualisation dans la fenêtre.

  2. L'exemple classique de la compilation des programmes

    Dans un compilateur (traducteur d'un texte-source en langage-machine) on distingue deux étapes :
    1. l'analyse syntaxique qui transforme le texte-source (écrit en syntaxe concrète)
      en un arbre  (l'arbre syntaxique) représenté en machine
    2. le générateur de code (assembleur) qui travaille sur l'arbre syntaxique.
    Le parseur doit tenir compte

    Exemple : "le même programme" en syntaxe C :
    int a, b, q, r ;
    main () {
          scanf("%d", &a); scanf("%d", &b); q = 0; r = a;
          while (r >= b) {
                q = q+1; r = r-b;
        }
          printf("%d", q); printf("%d", r);
        }
    et en syntaxe Ada :
    with Ada.Integer_Text_Io; use Ada.Integer_Text_Io;
    procedure Main is
    a, b, q, r : Integer;
    begin get(a); get(b); q := 0; r := a;
          while r >= b loop q := q+1; r := r-b; end loop;
          put(q); put(r);
    end Main;   
    Compilation
    Si on change de syntaxe concrète il faut changer de parseur !
    Il faut aussi changer de parseur si on change la syntaxe abstraite !

    Soulignons que la représentation d'un arbre en machine pose deux niveaux de problèmes :

  3. Ce que XML apporte

    XML offre un moyen pour écrire "directement" l'arbre syntaxique,
    plus exactement, il offre une syntaxe concrète uniforme (mais peu lisible) applicable à toute sorte d'arbres.
    Exemple : le programme ci-dessus en XML
    fichier qr.xml 
    <?xml version='1.0'?>
    <Prog>
     <Variables> <Var nom="a"/> <Var nom="b"/> <Var nom="q"/> <Var nom="r"/>
     </Variables>
     <Sequence>
     <Lecture> <Var nom="a"/> </Lecture>
     <Lecture> <Var nom="b"/> </Lecture>
     <Affectation> <Var nom="q"/> <Cte val="0"/> </Affectation>
     <Affectation> <Var nom="r"/> <VarExp> <Var nom="a"/> </VarExp> </Affectation>
     <Boucle>
     <Comparaison op="&gt;="> <VarExp> <Var nom="r"/> </VarExp>
    	<VarExp> <Var nom="b"/> </VarExp>
     </Comparaison>
     <Sequence>
     <Affectation> <Var nom="q"/>
     <Bin op="+"> <VarExp> <Var nom="q"/> </VarExp> <Cte val="1"/> </Bin>
     </Affectation>
     <Affectation> <Var nom="r"/>
     <Bin op="-"> <VarExp><Var nom="r"/></VarExp> 
     <VarExp><Var nom="b"/></VarExp>
     </Bin>
     </Affectation>
     </Sequence>
     </Boucle>
     <Ecriture> <VarExp> <Var nom="q"/> </VarExp> </Ecriture>
     <Ecriture> <VarExp> <Var nom="r"/> </VarExp> </Ecriture>
     </Sequence>
    </Prog>
    avec le Document Object Model (DOM) il offre aussi une syntaxe abstraite,
    c'est à dire une définition précise des arbres correspondant aux fichiers XML.

  4. Modalités

Dans ce cours, nous nous concentrerons sur la réalisation de DOM en Java.
Pour C++, voir l'implémentation Apache-Xerces.
Sur la réalisation homologue en PHP-5, on lira (outre le Manuel PHP) un excellent
tutoriel introductif chez Développez.com.
La version JavaScript, qui se spécialise dans le traitement de HTML
est quelque peu différente dans le détail, nous n'en parlerons pas ici.

II. Éléments principaux du DOM (pour le détail de la réalisation en Java, voir le bréviaire)

  1. L'interface Node

    L'interface Node est le type de données principal pour le modèle objet de document dans son ensemble.
    Elle représente un seul nœud dans l'arbre du document.
    Bien que tous les objets mettant en œuvre l'interface Node exposent des méthodes
    pour la gestion des enfants, certains ne peuvent pas avoir d'enfants.
    Par exemple, les nœuds Text ne peuvent pas avoir d'enfants,
    et ajouter un enfant à ces nœuds soulève alors une exception DOMException.

    Les attributs nodeName, nodeValue et attributes composent un mécanisme
    permettant d'accéder aux informations d'un nœud sans devoir faire appel aux interfaces dérivées spécifiques.
    Au cas où il n'y aurait pas de correspondance évidente entre ces attributs et un type de nœud particulier
    (par exemple, nodeValue pour un objet Element ou attributes pour un objet Comment),
    la valeur null est retournée.

    Remarquer que les interfaces spécialisées peuvent offrir des mécanismes supplémentaires plus pratiques
    pour obtenir ou fixer les informations pertinentes.

  2. L'interface Document

    L'interface Document représente le document HTML, ou XML, entier.
    Conceptuellement, c'est la racine de l'arbre du document, qui offre l'accès primaire aux données du document.

    Puisque les éléments, les nœuds de texte, les commentaires, les instructions de traitement, etc.,
    ne peuvent pas exister en-dehors du contexte d'un Document,
    l'interface Document contient aussi les méthodes nécessaires pour créer ces objets.

    Les objets Node créés possèdent un attribut ownerDocument qui les associent au Document
    dans le contexte duquel ils ont été créés.

  3. L'interface Element

    L'interface Element représente un élément dans un document HTML ou XML.

    Les éléments peuvent avoir des attributs associés ;
    comme l'interface Element hérite de celle de Node, on peut utiliser l'attribut générique attributes
    de l'interface Node pour récupérer le jeu de tous les attributs d'un élément.
    L'interface Element possède des méthodes pour récupérer par leur nom soit un objet Attr,
    soit une valeur d'attribut.

III. Un exemple simple