XML

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

n  Lire avec la couche SAX n  Lire et Ecrire avec la couche DOM

Echange de données

n  Intérêt d'une technologie pivot n  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  Format standard d'échange

n  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  Normalisation de la sémantique des données échangées

par des modèles standards, les protocoles d'application

n  Normalisation de la forme n  Échange de données avec le format STEP n  Modélisation avec le langage EXPRESS

n  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  Méta-langage à balise pour l'encodage des

données n  Modélisation par les DTD ou les Schémas XML

n  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 n  Tous les languages disposent des

bibliothèques pour lire et écrire des fichiers XML;

n  Un document XML contient : n  Un prologue

n  Déclaration XML (”je suis un document XML”) n  Référence éventuelle à un document qui décrit le format

n  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  version : version du XML utilisée (1.0 ou 1.1) n  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.

n  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 n  Feuille de style <?xml-stylesheet type="text/xsl" href="biblio.xsl"?> 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  les XSL (propres au XML) ainsi que n  les CSS (feuilles de style apparues avec le HTML).

Entête : Type de document

n  La structure d'un document et le modèle de données sous-jacent peuvent être explicités dans une DTD

n  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  Peut être exploité par les logiciel (browser ...) pour

contrôler les données échangées n  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  Un élément est une unité d'information avec : n  Une balise n  Éventuellement avec un contenu n  Éventuellement avec un ou plusieurs attributs

n  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  Le 1er caractère doit être une lettre, un '_' ou un ':' n  Ne peut pas commencer par ”xml” (quelque-soit la

casse) n  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  Des attributs peuvent être utilisés pour stocker de l'information

n  Un attribut est un nom associé à une information

n  L'information est alors uniquement textuelle n  Pas de structure possible n  Ils ne peuvent pas être emboités (un seul

niveau) n  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  Une seul élément racine n  Chaque élément contient

n  une balise d'ouverture <B> n  une balise de fermeture correspondante </B>

n  Les balises ne peuvent pas se chevaucher <auteur><nom></auteur></nom>

n  Les attributs à l'intérieur d'un élément ont des noms uniques n  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  On a plusieurs types de carnets définit par

l'application n  Un contact a des informations standards :

n  Nom, prénom, des adresses et des téléphones, photo... n  Un contact peut avoir des informations

suplémentaires définies par l'utilisateur n  Par exemple, ”Plat préféré”, ”Hobby” ....

n  Produire des fonctions pour initialiser un carnet n  Produire deux exports XML : un avec attribus et

l’autre sans attributs

Type de document

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

n  Deux solutions possibles : n  les "Schémas XML" et n  les "Document Type Definition" (DTD)

n  DTD : plus ancien, plus simple mais plus limité.

Type de DTD

n  Forme générale : <!DOCTYPE Carnet ... "..." "...">

n  Placée juste après le prologue n  Indique l'élément racine du document (ici ”Carnet”)

n  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  L'élément racine est ”Carnet” n  Les règles sont donnée dans la suite entre ”[” et

”]” n  Ici, un carnet se compose de zéro ou plusieurs

contacts

DTD externe

n  DTD locale <!DOCTYPE Carnet SYSTEM "carnet.dtd">

n  Stockée dans le fichier "carnet.dtd" n  DTD publique

n  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

n  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  type texte, n  vide, n  séquence, n  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  un élément de type A contient dans l'ordre, un B, un

C et un D n  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  un élément de type A contient dansun B, un C ou un

D n  Exemple

<A> <B>...</B>

</A>

Indication d'occurences

n  On dispose des cardinalités : n  Pas d'indication : une et une seule occurences

obligatoirement n  ? : zéro ou une occurences n  + : une ou plusieurs occurences n  * : zéro à plusieurs occurences

<!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 optionnel. 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  Les entités permettent d'utiliser des raccourcis pour des valeurs

n  Utile pour les caractères bizarres non directement accessible dans le jeu de caractères déclaré (accents ...)

n  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  sont utilisables pour représenter des caractères non

disponibles au clavier ou dans l'encodage choisi : n  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 carnet de contacts n  2 versions: une avec et l’autre sans attributs (donc

deux DTD différentes) n  Produisez des exemples de fichier XML et

vérifiez votre DTD avec xmllint ou tout autre outils capable de vérifier un document XML+DTD

Espace de nommage

n  Conflit de nom possible: un nom peut avoir plusieurs sens

n  Problématique si dans un même document on a besoin de plusieurs sens.

n  Exemple Bricoloto : <Date/> n  Date de prise en charge du véhicule ou bien n  Date de 1ère immatriculation pour la carte grise

Espace de nommage

n  Pour régler le problème, on peut utiliser un espace de nommage par sens différent.

n  Un espace de nommage correspond à un regroupement arbitraire et cohérent d'éléments

n  Utilisé pour bien limiter et identifier le vocabulaire dans un domaine particulier : n  orientation métier de XML

Espace de nommage : préfixage

n  Introduction du préfixage n  Pour la déclaration n  Pour l'utilisation ou la référence

n  Préfixe/suffixe : n  Séparés par ':' n  <prefixe>:<suffixe>

Espace de nommage : Déclaration

n  Deux formes possibles : n  Espace de nommage local

n  Forme explicite n  Les noms concernés sont forcément préfixés par le nom

de l'espace de nommage n  Espace de nommage par défaut

n  Forme implicite n  Les noms non préfixés (ne faisant pas référence

explicitement à un espace de nommage) font référence à l'espace de nommage par défaut courant

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 » n  Le suffixe de cet attribut indique l’espace de

nommage n  La valeur de l’attribut est l’URI qui identifie l’espace

de nommage <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  javax.xml.parsers : Interfaces devant être implémentées par les différents parseurs (SAX ou DOM) + les factory pour l'instanciation de parseurs.

n  org.w3c.dom : Classes et interfaces pour DOM n  org.xml.sax : Classes et interfaces pour SAX. n  javax.xml.transform : Classes et interfaces pour

XSLT (transformations).

Interface SAX

n  Interface de gestion XML évènementiel avec principalement n  Gestion du contenu : (ContentHandler) boucle de

lecture pour manipulation du contenu n  Gestion d'erreurs (ErrorHandler) 3 types possibles :

erreurs simples, erreurs fatales et warnings. n  Gestion du typage (DTDHandler)

n  Pour simplifier le codage : version par defaut avec la classe DefaultHandler (package org.xml.sax.helpers)

n  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  DefaultHandler est un exemple de classe qui l'implémente

n  Principe très simple de lecture dirigée par le contenu (principe ”Framework”)

n  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  Appelée une et une seule fois en début de

document n  Point d'entrée pour initialiser le contexte global de

lecture void endDocument();

n  Appelée à la fin de la lecture du document. n  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  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

n  Appelée à chaque début d'élément

Interface org.xml.sax.ContentHandler (4)

void endElement(String nameSpaceURI, String localName, String rawName) 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  Appelée à chaque fin d'élément

Interface org.xml.sax.ContentHandler (4)

void characters(char[] ch, int start, int end); n  ch : buffer de caractères n  start et end : position de début et de fin dans ch

n  Appelée à chaque fois qu'un contenu est lu entre deux balises

n  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  Dans l'exercice 2 vous avez programmé des visiteurs pour produire des fichiers XML : – A partir d’un carnet, un visiteur est utilisé pour

sérialiser le carnet sous la forme d’un document XML

n  Dans cet exercice vous allez programmer l’opération inverse de matérialisation (ou de dé-sérialisation) : – En utilisant un parser SAX, il s’agit de lire un fichier

XML de carnet et de re-créer en mémoire le carnet

Problèmes liés a SAX

n  L'API SAX est simple et puissante pour la lecture et l'interprétation d'un flux en continu

n  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  La gestion d'un modèle peut nécessiter une vue globale des données

n  Besoin de stockage intermédiares

Document Object Model (DOM)

n  Modèle générique d'un document XML n  API DOM : manipulation d'un document (arbre

d'éléments) tout en mémoire n  On dispose de tous les noeuds en mémoire n  Navigation, requètes, traitements ou

transformations programmables directement sur l'arbre

n  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  De texte, d'un élément ou d'une portion CDATA ... n  Pour connaître son type: getNodeType()

n  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  On peut créer un arbre de toute pièce directement par programme,

n  On peut aussi modifier, déplacer, supprimer des éléments

n  ... → 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 de Carnet avec DOM, version avec attributs et avec un visiteur

n  Le visiteur ne construit pas directement un String mais crée un Document DOM

n  Le Document est ensuite utilisé pour produire le String et le fichier

n  Utilisez un JTree (javax.swing) pour la visualisation d'un Carnet