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 "é"> On peut utiliser é 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