Echange de données Syntaxe du XML Java pour le XML

XML
n 
Echange de données
n 
Syntaxe du XML
n 
DTD
n 
Schéma
n 
Java pour le XML
n 
Lire avec la couche SAX
n 
Lire et Ecrire avec la couche DOM
Echange de données
n 
n 
Intérêt d'une technologie pivot
Un problème double, les système qui
échangent :
n 
Doivent être d'accord sur la forme attendue pour les
données échangées
n 
n 
Format standard d'échange
Doivent aussi être d'accord sur le sens des
données échangées
n 
Modélisation et standards par métiers
Exemples de technologie
n 
Standard STEP :
n 
Norme ISO, effort international à partir du début des
années 80.
n 
n 
Normalisation de la sémantique des données échangées
par des modèles standards, les protocoles
d'application
Normalisation de la forme
n 
n 
n 
Échange de données avec le format STEP
Modélisation avec le langage EXPRESS
Normalisation de la mise en oeuvre des échanges
n 
Interface standard d'accès aux données
Exemples de technologie (2)
n 
Technologie XML
n 
n 
n 
Méta-langage à balise pour l'encodage des
données
Modélisation par les DTD ou les Schémas XML
Définition de vocabulaires spécialisés par
métier
n 
Mathématiques (MathML)
n 
Bio-informatique (BSML)
n 
Ressources Humaines (HRML)
n 
SIG (GML) ...
Philosophie d'XML
•  Structuration logique du contenu
– Les documents ne contiennent aucune information
de mise en page
– Séparation contenu-traitement adapté à l'échange
de donnée et la mise en oeuvre de systèmes
d'information
– Réutilisabilité de l’information
Format XML
n 
Langage à balise : syntaxe générique et
régulière
<A>[ information concernant A ]</A>
<B [ attributs pour B ]> </B>
n 
Un document XML contient :
n 
Un prologue
n 
n 
n 
Déclaration XML (”je suis un document XML”)
Référence éventuelle à un document qui décrit le format
Une suite d'éléments
n 
Organisation arborescente
Entête XML
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
n 
On distingue trois informations fournies dans
cette déclaration :
n 
n 
n 
version : version du XML utilisée (1.0 ou 1.1)
encoding : le jeu de codage de caractères utilisé.
ISO-8859-1 a tendance à être remplacé par
l'ISO-8859-15 en attendant la généralisation de
l'Unicode. Par défaut, l'attribut encoding a la valeur
UTF-8.
standalone : dépendance du document par rapport à une
déclaration de type de document (yes ou no)
Entête : Instruction de traitement
n 
Instruction interprétée par l'application servant à
traiter le document XML.
n 
Elle ne fait pas totalement partie du document
Feuille de style
<?xml-stylesheet type="text/xsl" href="biblio.xsl"?>
n 
n 
Dans cet exemple, l'application est xml-stylesheet,
le processeur de feuille de style du XML.
n 
Deux feuilles de style différentes peuvent être utilisées :
n 
n 
les XSL (propres au XML) ainsi que
les CSS (feuilles de style apparues avec le HTML).
Entête : Type de document
n 
n 
La structure d'un document et le modèle de
données sous-jacent peuvent être explicités
dans une DTD
Permet de définir la structure du document.
<!DOCTYPE Carnet SYSTEM "Carnet.dtd">
n  Modèle déclaré dans le fichier local ”Carnet.dtd”
n 
n 
Peut être exploité par les logiciel (browser ...) pour
contrôler les données échangées
DTD limité → remplacé par les schémas XML
Commentaires
n 
Comme en HTML
n 
Commencent par ”<!--” et se terminent par ”-->”.
n 
N'importe ou mais à l'extérieur d'une balise
n 
Exemples :
n 
<!-- ok boy -->
n 
<Contact> <!-- ok boy--> ... </Contact>
n 
”--” interdite dans un commentaire.
Éléments XML
n 
n 
Un élément est une unité d'information avec :
n 
Une balise
n 
Éventuellement avec un contenu
n 
Éventuellement avec un ou plusieurs attributs
Un document XML est un arbre
n 
Une seule racine
n 
Un élément réprésente un noeud
Éléments XML
n 
Exemple : arbre du carnet d'adresses
<Carnet>
<Type>Activite professionnelle</Type>
<Contact>
<Nom>Albert and co</Nom>
<Telephone>0798029856</Telephone>
</Contact>
</Carnet>
ou avec des attributs
<Carnet type=”Activite professionnelle”>
<Contact nom=”Albert and co” Telephone=”0798029856”/>
</Carnet>
Règles de construction
n 
Nom de balise quasiment libre
n 
n 
n 
Le 1er caractère doit être une lettre, un '_' ou un ':'
Ne peut pas commencer par ”xml” (quelque-soit la
casse)
Le contenu peut être :
n 
Vide (<carnet></carnet> abbrégé en <carnet/>)
n 
Un ou plusieurs autres éléments
n 
Un texte libre
Attributs
n 
n 
n 
n 
n 
Des attributs peuvent être utilisés pour stocker
de l'information
Un attribut est un nom associé à une
information
L'information est alors uniquement textuelle
Ils ne peuvent pas être emboités (un seul
niveau)
Il est plutôt préconisé d'utiliser des éléments car
plus souples (document plus évolutif)
Syntaxe
n 
Quelques règles très simples
n 
n 
n 
n 
n 
Une seul élément racine
Chaque élément contient
n  une balise d'ouverture <B>
n  une balise de fermeture correspondante </B>
Les balises ne peuvent pas se chevaucher
<auteur><nom></auteur></nom>
Les attributs à l'intérieur d'un élément ont des noms uniques
Les noms d'éléments et de balises doivent être autorisés
Exercice 1
n 
Reprendre le modèle du carnet et l'enrichir :
n 
n 
On a plusieurs types de carnets définit par
l'application
Un contact a des informations standards :
n 
n 
Un contact peut avoir des informations
suplémentaires définies par l'utilisateur
n 
n 
Nom, prénom, des adresses et des téléphones, photo...
Par exemple, ”Plat préféré”, ”Hobby” ....
Produire des fonctions pour initialiser un carnet
et pour produire un export XML complet et
valide
Type de document
n 
n 
n 
Utile pour contrôler le contenu d'un fichier XML
n 
Vérification par les applications
n 
Partage ou échange de documents
n 
Standards métiers
Deux solutions possibles :
n 
les "Schémas XML" et
n 
les "Document Type Definition" (DTD)
DTD : plus ancien, plus simple mais plus limité.
Type de DTD
n 
Forme générale :
<!DOCTYPE Carnet ... "..." "...">
n 
n 
n 
Placée juste après le prologue
Indique l'élément racine du document (ici ”Carnet”)
Deux types suivant le type de stockage :
n 
Une DTD interne est intégrée au document XML
n 
Une DTD externe est dans un fichier séparé
n 
Externe privé (fichier local uniquement)
n 
Externe publique (fichier accessible en public sur le web)
DTD interne
<!DOCTYPE Carnet[
<!ELEMENT Carnet (Contact)*> ...
]>
n 
n 
n 
L'élément racine est ”Carnet”
Les règles sont donnée dans la suite entre ”[” et
”]”
Ici, un carnet se compose de zéro ou plusieurs
contacts
DTD externe
n 
DTD locale
<!DOCTYPE Carnet SYSTEM "carnet.dtd">
n 
n 
Stockée dans le fichier "carnet.dtd"
DTD publique
n 
n 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0
Strict//EN" "
http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
PUBLIC suivi de l'identifiant de la DTD, du
propriétaire(ici le W3C), puis son nom, enfin sa
langue.
Déclaration d'élément
n 
Forme générale :
<!ELEMENT nom type_element>
n 
Nom : nom de l'élément
n 
type_element type associé.
n 
n 
n 
n 
type texte,
vide,
séquence,
choix d'élément
Type simple : texte ou vide
n 
Type texte
<!ELEMENT nom (#PCDATA)>
exemple :
<nom>The clash</nom>
n 
Type vide
<!ELEMENT collected EMPTY>
exemples:
<collected/>
<collected date=”22/01/1964”>
Séquences
n 
Séquence : spécifie les fils d'un noeud
<!ELEMENT A (B, C, D)>
n 
n 
un élément de type A contient dans l'ordre, un B, un
C et un D
Exemple
<A>
<B>...</B>
<C>...</C>
<D>...</D>
</A>
Choix déléments
n 
Spécifie les fils possibles
n 
Un seul choix parmi la liste
<!ELEMENT A (B | C | D)>
n 
n 
un élément de type A contient dansun B, un C ou
un D
Exemple
<A>
<B>...</B>
</A>
Indication d'occurences
n 
On dispose des cardinalités :
n 
Pas d'indication : une et une seule occurences
obligatoirement
? : zéro ou une occurences
n 
+ : une ou plusieurs occurences
n 
* : zéro à plusieurs occurences
n 
<!ELEMENT A (B, C?, D+, E*)>
A contient, dans l'ordre, un B, éventuellement un C, au
moins un D et éventuellement plusieurs E
Indication d'occurences (2)
n 
Les cardinalités peuvent s'appliquer à des
regroupements
<!ELEMENT A (B, C)+>
Un A contient au moins une séquence B,C,D,E.
Exemple
<A>
<B/><C/>
<B/><C/>
<B/><C/>
<A/>
Élément quelconque
n 
Il est possible de relacher tout contrôle en
utilisant le type d'élément quelconque.
<!ELEMENT A ANY>
A peut contenir n'importe quel élément de la DTD
n 
À limiter ou a n'utiliser que pendant la mise au
point car on perd l'intérêt de la DTD
Contenu mixte
n 
Pour un modèle assez libre dans lequel du
texte peut être inséré au même niveau que des
noeuds fils
<!ELEMENT Dicton (#PCDATA | Origine)*>
un élément dicton peut contenir n'importe quelle
combinaison de texte et de noeud Origine
exemple :
<Dicton>
Après la pluie vient le beau temps
<Origine>pays ou il pleut</Origine>
</Dicton>
Type d'attribut
n 
On peut aussi contrôler les attributs avec
ATTLIST
<!ATTLIST A
nom_attribut1 type_attribut type_valeur
nom_attribut2 type_attribut type_valeur
>
A est le nom de l'élément
nom_attribut celui d'un attribut de A
Type d'attribut
n 
CDATA : chaîne de caractères
n 
ID : identifiant unique
n 
IDREF : référence à un ID
n 
IDREFS : série de références
n 
(a | b | c) : énumération de toutes les valeurs
possibles
Type de valeur
n 
REQUIRED : attribut obligatoire
n 
IMPLIED : attribut optionnel
n 
FIXED ”valeur” : valeur fixe
n 
”valeur” : valeur par défaut
Exemples d'attributs
<!ELEMENT elt (...)>
<!ATTLIST elt X CDATA "Yoyo">
L'élément elt peut avoir l'attribut X, chaine de caractères
avec ”Yoyo” comme valeur par défaut
<!ELEMENT elt (...)>
<!ATTLIST elt X CDATA #REQUIRED>
Là, X est obligatoire, pas de valeur par défaut donc
<!ELEMENT elt (...)>
<!ATTLIST elt X CDATA #IMPLIED>
Et là, X peut ne pas être présent
Exemples d'attributs (2)
<!ELEMENT elt (...)>
<!ATTLIST elt X ID #IMPLIED>
X est un identifiant obligatoire. Deux éléments ne peuvent pas
avoir la même valeur pour X
<elt X=”AAAA”/>
<elt X=”ZZ”/>
<elt X=”AAAA”/> ← interdit dans le même fichier !!
<!ELEMENT elt EMPTY>
<!ATTLIST elt X (a | b | c) "a">
l'attribut X peut prendre comme valeur: ”a”, ”b” ou ”c”.
”a” est la valeur par défaut
Les entités
n 
n 
n 
Les entités permettent d'utiliser des raccourcis
pour des valeurs
Utile pour les caractères bizarres non
directement accessible dans le jeu de
caractères déclaré (accents ...)
Plusieurs sortes d'entités :
n 
Paramétriques, de caractère et les internes
Les entités (2)
n 
Les entités paramétriques
n 
S'apparente à une macro de DTD
n 
Exemple de la DTD du HTML
<!ENTITY %heading "H1|H2|H3|H4|H5|H6">
Toute occurence de %heading; est remplacé par H1|H2|H3|
H4|H5|H6 dans la DTD.
Les entités (3)
n 
Les entités de caractères
n 
n 
sont utilisables pour représenter des caractères non
disponibles au clavier ou dans l'encodage choisi :
Exemples de la DTD de HTML:
<!ENTITY eacute "&#233;">
On peut utiliser &eacute pour avoir le ”é”
Les entités (4)
n 
Entités internes
<!ENTITY antic "anticonstitutionnellement">
On utilise &antic dans le document à la place de
anticonstitutionnellement
Exercice 2
n 
Produisez la DTD pour le TP ”Roger bricoloto”
http://cassoulet.univ-brest.fr/idm/index.php/Roger_Bricoloto
n 
n 
n 
Prendre la correction et ajouter deux exports
XML
n 
Un premier export sans attribut (version 1)
n 
Un second avec des attributs (version 2)
Produisez des exemples de fichier XML et
vérifiez votre DTD avec xmllint
Utiliser l'API java DOM pour convertir la version
1 vers la version 2 puis faites l'inverse
Espace de nommage
n 
Problème :
n 
n 
n 
conflit de nom possible: un nom peut avoir plusieurs
sens
Plusieurs éléments avec la même balise mais
plusieurs structures différentes (par exemple, un
sans sous-élément et l’autre avec des souséléments)
Il faut donc pouvoir expliciter la provenance
d’un nom
Espace de nommage
n 
n 
n 
Pour régler le problème, on utilise les espaces
de nommage.
Un espace de nommage correspond à un
regroupement arbitraire et cohérent d'éléments
Utilisé pour bien limiter et identifier le
vocabulaire dans un domaine particulier :
n 
orientation métier de XML
Espace de nommage : préfixage
n 
n 
Introduction du préfixage
n 
Pour la déclaration
n 
Pour l'utilisation ou la référence
Préfixe/suffixe :
n 
n 
Séparés par ':'
<prefixe>:<suffixe>
Exemple
<crn:carnet xmlns:crn=http://dossen.univ-brest.fr>
<crn:contact crn:nom=“bibi” crn:tel=“06060606”/>
<crn:contact crn:nom=“zorro” crn:tel=“07068609”/>
<crn:contact crn:nom=“bob” crn:tel=“08765435”/>
</crn:carnet>
“crn” est le préfixe de l’espace de nommage
Espace de nommage:
identification
Un espace de noms est identifié par une URI
Exemple:
<crn:carnet xmlns:crn=http://dossen.univ-brest.fr>
Espace de nommage :
Déclaration
n 
A l’aide du préfixe d’attribut « xmlns »
Le suffixe de cet attribut indique l’espace de
nommage
La valeur de l’attribut est l’URI qui identifie l’espace
de nommage
n 
n 
<crn:carnet xmlns:crn=http://dossen.univ-brest.fr>
crn:contact …
<
Portée d’une déclaration
•  C’est l'élément dans lequel est introduit la
déclaration
•  Cet élément est inclu dans la portée
<crn:carnet xmlns:crn=http://dossen.univ-brest.fr>
<crn:contact crn:nom=“bibi” crn:tel=“06060606”/>
</crn:carnet>
Le XML et Java
n 
JAXP (Java API for XML Processing)
n 
4 packages :
n 
n 
n 
n 
javax.xml.parsers : Interfaces devant être
implémentées par les différents parseurs (SAX ou
DOM) + les factory pour l'instanciation de parseurs.
org.w3c.dom : Classes et interfaces pour DOM
org.xml.sax : Classes et interfaces pour SAX.
javax.xml.transform : Classes et interfaces pour
XSLT (transformations).
Interface SAX
n 
Interface de gestion XML évènementiel avec
principalement
n 
n 
n 
n 
n 
Gestion du contenu : (ContentHandler) boucle de
lecture pour manipulation du contenu
Gestion d'erreurs (ErrorHandler) 3 types possibles :
erreurs simples, erreurs fatales et warnings.
Gestion du typage (DTDHandler)
Pour simplifier le codage : version par defaut
avec la classe DefaultHandler (package
org.xml.sax.helpers)
Il suffit de programmer une sous-classe
Exemple SAX
Exemple de lecture sans aucune action de branchée
try {
SAXParserFactory factory = SAXParserFactory.newInstance(); // Une
fabrique
SAXParser parser = factory.newSAXParser(); // Un parseur SAX
File file = new File("/home/plantec/COURS/XML/ExempleSax.xml");
DefaultHandler gestionnaire = new DefaultHandler(); // un gestionaire SAX
parser.parse(file, gestionnaire); // Lecture du fichier
} catch (ParserConfigurationException pce) {
} catch (SAXException se) {
} catch (IOException ioe) {
}
Interface
org.xml.sax.ContentHandler (1)
n 
Mise en oeuvre de la lecture d'un flux XML
n 
n 
n 
DefaultHandler est un exemple de classe qui l'implémente
Principe très simple de lecture dirigée par le
contenu (principe ”Framework”)
Les évenements sont liés au contenus XML
rencontrés, principalement :
n 
Début/fin de document
n 
Début/fin d'un élément
Interface
org.xml.sax.ContentHandler (2)
void startDocument();
n 
n 
Appelée une et une seule fois en début de
document
Point d'entrée pour initialiser le contexte global de
lecture
void endDocument();
n 
n 
Appelée à la fin de la lecture du document.
Point d'entrée pour finir le traitement (mise en place
finale de la représentation mémoire par exemple)
Interface
org.xml.sax.ContentHandler (3)
void startElement (String namespaceUri, String
localName, String rawName, Attributs attributs);
n 
n 
nameSpaceUri : URI complète de l'espace de
nommage du tag courant ou une chaîne vide
n 
localName : nom du tag sans le préfixe éventuel
n 
rawName : nom du tag complet (avec préfixe)
n 
attributs : contient la liste des attributs du tag
Appelée à chaque début d'élément
Interface
org.xml.sax.ContentHandler (4)
void endElement(String nameSpaceURI, String
localName, String rawName)
n 
n 
nameSpaceUri : URI complète de l'espace de
nommage du tag courant ou une chaîne vide
n 
localName : nom du tag sans le préfixe éventuel
n 
rawName : nom du tag complet (avec préfixe)
Appelée à chaque fin d'élément
Interface
org.xml.sax.ContentHandler (4)
void characters(char[] ch, int start, int end);
n 
n 
n 
ch : buffer de caractères
n 
start et end : position de début et de fin dans ch
Appelée à chaque fois qu'un contenu est lu
entre deux balises
On peut directement construire un String :
String s = new String(ch, start, end);
Interface
org.xml.sax.ContentHandler (5)
Traitement des attributs :
n 
attributs gère 2 listes de String, pour le nom et la
valeur des attributs
public void startElement(String nameSpaceURI, String localName, String
rawName, Attributes attributs) throws SAXException {
for (int index = 0; index < attributs.getLength(); index++) {
System.out.print( attributs.getLocalName (index) + " = ");
System.out.println( attributs.getValue (index));
}
}
Exemple du Carnet (1)
public class CarnetHandler extends
DefaultHandler{
Carnet carnet;
boolean dansTypeCarnet = false, dansContact ...
public void startDocument() throws SAXException {
carnet = new Carnet();
}
public void endDocument() throws SAXException {
System.out.println(”done”);
}
Exemple du Carnet (2)
public void startElement(String nameSpaceURI, String localName,
String rawName, Attributes attributs) throws SAXException {
if (localName.equals(”TypeCarnet”)) {
dansTypeCarnet = true;
} ...
}
public void characters(char[] ch, int start, int end) throws
SAXException {
if (dansTypeCarnet) {
carnet.setType(new String(ch,start,end));
} ...
Exemple du Carnet (3)
try {
SAXParserFactory factory =
SAXParserFactory.newInstance();
factory.setNamespaceAware(true);
SAXParser parser = factory.newSAXParser();
File file = new File("carnet.xml");
DefaultHandler handler = new CarnetHandler();
parser.parse(file, handler);
} catch (ParserConfigurationException pce) {
} ...
Exercice 3
n 
n 
Reprendre l'exercice 3 et utiliser l'API SAX pour
convertir la version 1 du fichier xml (sans
attribut) vers la version 2 (avec attributs) puis
faites l'inverse
Mettre en place la gestion des ID/IDREF
Ajouter dans la classe societe une liste de réparations en
contentieux (se sont des idref).
Générer le document XML avec un ID unique pour chaque
entité et les IDREF
n 
Mettre en oeuvre la lecture SAX avec la résolution des
IDREF
Problèmes liés a SAX
n 
n 
L'API SAX est simple et puissante pour la
lecture et l'interprétation d'un flux en continu
Un analyseur SAX est délicat à développer:
n 
Gestion lourde des états de l'automate
n 
Cohérence de l'automate difficile à valider
n 
Traitement élément par élément
n 
n 
La gestion d'un modèle peut nécessiter une vue globale
des données
Besoin de stockage intermédiares
Document Object Model (DOM)
n 
n 
Modèle générique d'un document XML
API DOM : manipulation d'un document (arbre
d'éléments) tout en mémoire
n 
n 
n 
On dispose de tous les noeuds en mémoire
Navigation, requètes, traitements ou
transformations programmables directement sur
l'arbre
API java standard
DOM : lecture d'un document
n 
Interface Document : porte la racine du document
XML en mémoire
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
DocumentBuilder builder = fabrique.newDocumentBuilder();
File xml = new File("Carnet.xml");
Document document = builder.parse(xml);
Interfaces DOM
n 
Node
n 
Unité de base de l'arbre
n 
suivant sont type, il s'agit :
n 
n 
n 
De texte, d'un élément ou d'une portion CDATA ...
Pour connaître son type: getNodeType()
Element
n 
constitué d'un tag, d'attributs
n 
et d'un contenu (ses éléments fils)
Interface Node
•  Interface commune à tous les objets DOM.
•  Un node permet de lire/écrire toutes les
propriétés génériques
•  Mets en oeuvre les fonctions de navigation
génériques
Interface Node
package org.w3c.dom;
public interface Node {
public static final short ELEMENT_NODE = 1 ;
public static final short ATTRIBUTE_NODE =2;
public static final short TEXT_NODE = 3;
public static final short CDATA_SECTION_NODE = 4;
public static final short ENTITY_REFERENCE_NODE = 5;
public static final short ENTITY_NODE = 6;
public static final short PROCESSING_INSTRUCTION_ NODE = 7;
public static final short COMMENT_NODE = 8;
public static final short DOCUMENT_NODE = 9
public static final short DOCUMENT_TYPE_NODE = 10;
public static final short DOCUMENT_FRAGMENT_NODE = 11;
public static final short NOTATION_NODE = 12;
…
Interface Node
…
public String getNodeName();
Retourne le nom du Node.
• 
Pour un Element ou un Node Attribute, retourne le nom qualifié (Qname)
• 
Pour un Node Document, “#document”.
• 
Pour un Node Comment “#comment”.
• 
Pour un Node Text “#text”.
Etc…
Interface Node
…
public String getNodeValue();
public void setNodeValue(String nodeValue)
• 
Retourne/modifie la valeur (texte) du Node.
• 
Pour Attribute, CDATA, et Comment la valeur est le texte du Node
• 
Pour les autres type de Node, retourne null ou sans effet.
public short getNodeType();
•  Retourne le type du Node
public Node getParentNode();
•  Retourne le Node parent
Interface Node
NodeList getChildNodes()
• 
Retourne les noeuds enfants.
Node getFirstChild()
• 
Retourne le premier Node enfant.
Node getLastChild()
• 
Retourne le dernier Node enfant.
Node getNextSibling()
• 
Retourne le frère suivant
Node GetPreviousSibling()
• 
Retourne le frère précédent
public Document getOwnerDocument();
• 
Retourne le Document du Node
Interface Node
public Node insertBefore(Node newChild, Node refChild);
public Node replaceChild(Node newChild, Node oldChild);
public Node removeChild(Node oldChild);
public Node appendChild(Node newChild);
•  Méthodes pour ajouter/remplacer/supprimer un Node enfant
public boolean hasChildNodes();
•  Le Node est-il une feuille ?
public Node cloneNode(boolean deep);
•  Cloner en profondeur ou non
Interface Node
public String getNamespaceURI();
public String getPrefix();
public void setPrefix(String prefix);
public String getLocalName();
•  Méthodes relatives à l’espace de nommage
public boolean hasAttributes();
•  Est-ce que le Node a des attributs ?
Naviguer dans un arbre
Void naviguerProfondeurDabord( Node n ) {
// Traitement avec le Node n
// Traiter récursivement le premier fils
Node p = n.getFirstChild();
if ( p != null ) naviguerProfondeurDabord( p );
// Traiter récursivement le frère suivant
p = n.getNextSibling();
if ( p != null ) naviguerProfondeurDabord( p ); }
}
Interface NodeList
package org.w3c.dom;
public interface NodeList {
public Node item(int index);
public int getLength();
}
void naviguerProfondeurDabord ( Node n ) {
NodeList nl = n.getChildNodes();
for(int i=0;i<nl.getLength();i++) {
naviguerProfondeurDabord ( nl.item ( i ));
}}
Interface Element
n 
Pour manipuler les éléments XML
n 
Node avec une balise,
n 
Eventuellement avec des attributs et
n 
Éventuellement avec des Elements fils
Interface Element
public String getTagName();
• 
• 
Retourne la propriété “nodeName” de l’élément.
Si le document contient un espace de nommage alors le résultat dépend de
la mise en oeuvre …
public String getAttribute(String name);
public void setAttribute(String name, String value);
public void removeAttribute(String name);
public boolean hasAttribute(String name);
public boolean hasAttributeNS(String namespaceURI, String localName);
• 
Retrouver/ajouter/modifier/supprimer un attribut
Interface Element
public Attr getAttributeNode(String name);
public Attr setAttributeNode(Attr newAttr);
public Attr removeAttributeNode(Attr oldAttr;
•  Retrouver/ajouter/modifier/supprimer un attribut
mais cette fois avec un Objet de type Attr
Interface Element
On peut retrouver les éléments fils
NodeList getElementsByTagName(String t) :
n 
les éléments enfants dont le tag correspond à t (*
pour renvoyer tous les éléments).
NodeList getElementsByTagNameNS(String t) :
n 
idem mais avec en plus prise en compte de
l'espace de nommage
String getTextContent() :
n 
Le texte contenu dans un élément
Interface Attr
package org.w3c.dom;
public interface Attr extends Node {
public String getName();
public String getValue();
public void setValue(String value);
public Element getOwnerElement();
}
Interface Document
•  Représente la racine d’un arbre DOM.
•  Mise en oeuvre comme une Factory pour créer
les autres types de Node
Interface Document
public interface Document extends Node {
public DocumentType getDoctype();
public DOMImplementation getImplementation();
public Element getDocumentElement();
public Element createElement(String tagName);
public Text createTextNode(String data);
public Comment createComment(String data);
public CDATASection createCDATASection(String
data);
…
Interface Document
…
public Attr createAttribute(String name);
public NodeList getElementsByTagName(String tagname);
public Element createElementNS(String URI, String qualName);
public Attr createAttributeNS(String URI, String qualName);
public NodeList getElementsByTagNameNS(String URI, String
localName);
}
Interface Document
NodeList addElementAndGetList ( Document doc ) {
Element docelt = doc.getDocumentElement();
Element e = doc.createElement ( "employee" );
docelt.appendChild ( e );
Attr a = doc.createAttribute ( "id" );
Text t = doc.createTextNode ( "5" );
a.appendChild ( t );
e.setAttributeNodeNS ( a );
return doc.getElementsByTagName ( "employee" );
}
DOMImplementation
•  C’est avec un DOMImplementation que l’on
crée le Document initial
public interface DOMImplementation {
public boolean hasFeature(String feature, String version);
public DocumentType createDocumentType(String
qualifiedName, String publicId, String systemId);
public Document createDocument(String namespaceURI, String
qualifiedName, DocumentType doctype);
}
Création , modification d'un arbre
DocumentBuilderFactory dbf =
DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
DOMImplementation domImpl = db.getDOMImplementation();
Document document = domImpl.createDocument(
"urn:example.namespace",
"my:example",
null);
Element element = document.createElementNS(
"http://another.namespace",
"element");
document.getDocumentElement().appendChild(element);
...
Création , modification d'un arbre
n 
n 
n 
On peut créer un arbre de toute pièce
directement par programme,
On peut aussi modifier, déplacer, supprimer
des éléments
...
→ Se reporter à la documentation Oracle et aux
exemples sur internet
Ecrire un fichier XML avec un
DOMSource et un Transformer
DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
Document doc = docBuilder.newDocument();
doc.getDocumentElement().appendChild(doc.createElement("company”));
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
DOMSource source = new DOMSource(doc);
// Ecrire dans un fichier
StreamResult f = new StreamResult(new File("C:\\company.xml"));
transformer.transform(source, f);
// Ecrire sur la sortie standard
StreamResult c = new StreamResult(System.out);
transformer.transform(source, c);
Exercice 4
n 
Lire et créer un document XML Bricoloto avec DOM,
version avec attributs et avec un visiteur
n 
n 
n 
Le visiteur ne construit pas directement un String mais
renvoie un Document
Le Document est ensuite utilisé pour produire le String
Utilisez un JTree (javax.swing) pour la visualisation
d'un document
1. 
Visu brute : sans se préoccuper du type de Node
2. 
Visu classique : présentation « propre » des éléments