DOM, SAX, JAXP, JDOM: Gestion de documents XML

Transcription

1 DOM, SAX, JAXP, JDOM: Gestion de documents XML Cycle de vie d un document XML Le cycle de vie du point de vue d une application: Buts : Le point sur le traitement et la gestion de documents XML Introduction au parsing du XML DOM (Document Object Model) Levels 1,2,3 SAX (Simple API for XML) DOM ou SAX JAXP, JDOM, XSL W3C SAX XQL XML DOM XQuery HTML JDOM Document XML XML Analyse Deux étapes de base: analyse manipulation data Application DOM JAXP Interaction Avec les clients Utilisant les données XML SAX SAX JDOM 2 Parseur XML - I Parseur XML II Pourquoi un parseur? Infinité de modèles XML pour diverses applications Toutes les applications devront implémenter le parsing de données XML: Résoudre le problème de l indexation, de stockage, et de manipulation Qu'est-ce qu'un parseur? Un parseur serait donc un petit module de programme, dont le seul objectif serait de découper un flux d'entrée en un ensemble de "mots" (token) qui seront ensuite proposés à d'autres applications. Un parseur n'est donc pas un programme en soi : il est associé à un module de traitement et c'est la nature de ce module qui prime. La spécification XML parle alors de "processeur XML". Définition parseur (point de vue XML), il inclut: L analyse lexicale, L analyse syntaxique Le contrôle de conformité de la syntaxe par rapport à la norme La vérification de la validation du document par rapport à sa DTD ou son schéma Un processeur XML inclut des notions de validation lexicale et structurelle de document. Il propose aussi son module de traitement ad hoc, basé sur une représentation de l'information contenue dans le document (fichier) lu. Aujourd'hui, la représentation utilise soit l'interface SAX, soit des interfaces définies dans le "cœur" de DOM.

2 Architecture d'un processeur XML Modèles de parsing et API - I Construire une application XML revient donc à utiliser des parseurs, pour des outils fonctionnels différents: 1. Validation DTD, Schéma 2. Chargeur de document Validation + représentation du contenu 3. Processeurs XSLT Processeur Chargeur Valideur <doc> <doc> <a> <doc> <a> test</a> test</a> <et>.. <a> test</a> <doc> <et>.. </et> <et>.. <a> test</a> </et> </et> <et>.. </doc> </et> Documents XML </doc> </doc> </doc> Reader Parsing Résolution d entités Résolution espaces de nommages Contrôle de validité structurelle Contrôle arbre bien formé Contrôle au regard du modèle (DTD schéma) Interface de fourniture des informations contenus dans le document (SAX, DOM, etc.) Application Toute application qui doit traiter des entités XML, est interfacée avec un parseur à travers une API XML data XML parseur Interfaces standards But : création d un standard autonome et neutre pour faciliter le processus de traitement des documents XML: Manipulation et gestion des éléments constitutifs d un document XML Création, modification et consultation, etc. Automatisation des processus de manipulation Application 5 6 Modèles de parsing et API - II Catégories des parseurs Deux APIs de parseurs: DOM (Docment Object Model) Le parseur compile l ensemble du document et en construit une représentation interne sous forme d arbre. SAX (Simple API for XML) Le parseur lit le flot de données XML en entrée et reconnaît et interprète les marques de balisage au fur et à mesure qu il les rencontre. Chaque construction reconnue est immédiatement signalée et passée à l application. Ce modèle est appelé «traitement dirigé par les événements» JAXP (Java Api for Xml Parsing) JDOM = Java + XML On peut classifier les parseurs sous plusieurs catégories: Les validant versus non-validant Les parseurs supportant le DOM Les parseurs supportant le SAX Les parseurs écrits avec différents langages Java, C++, Perl, etc. Les parseurs: Xml4java, Oracle XML Parser, Xerces Java Parser, Microsoft XML Parser, etc

3 DOM (Document Object Model) - I DOM (Docment Object Model) II DOM: C est une norme du W3C, elle spécifie une API orientée objet permettant au programmeur d application d écrire des fonctions de création, de modification et de consultation des éléments constitutifs d un document XML ou HTML. C est un modèle d objets représentant un document: une interface de programmation pour les documents HTML ou XML DOM core, DOM HTML représentation arborescente d objets (attributs et méthodes permettent la manipulation de la structure logique et l information contenue dans ce document) Indépendant des plates formes, des langages de programmation et de script La spécification est organisée en différentes parties, différenciant des niveaux que doit supporter une implémentation de DOM. Pour chaque niveau, les spécifications différencient ce qui est fondamental (et qui doit donc être implémenté pour être conforme) de ce qui est optionnel (les extensions). Chaque spécification s'intéresse au "coeur" (core) qui est générique, pour n'importe quel document XML et à des interfaces spécifiques, pour des types de documents donnés (tels des documents XML, des CSS, voire des objets plus génériques comme des feuilles de styles) DOM (Docment Object Model) II DOM (Docment Object Model) III Le "coeur" (core) de DOM définit les éléments ci-après : ce que sont une implémentation DOM et les natures d'erreurs reconnues les interfaces de gestion d'un document XML pour deux objectifs : y accéder (fonction d'accès à des éléments, attributs, etc.) le construire (fonctions de création de documents, d'éléments, d'attributs, etc.), le niveau 2 prend notamment en compte les notions d'espace de noms ; Les extensions au cœur, qui sont optionnelles dans les implémentations, ajoutent : les notions de sections CDATA et la gestion des entités externes (niveau 1), les notions de DTD, de processing instructions, de notation (niveau 2). Ce sont les niveaux d'implémentation qui définissent le type de structure qu'ils reconnaissent : DOM niveau 1 : prend en compte les documents HTML (et non pas XHTML ) et XML ; Ce sont surtout des objets nouveaux qui apparaissent, comme les frames, les images ou les ancres. Les fonctionnalités de manipulation sont minimes, celles du core étant a priori souvent suffisantes. DOM niveau 2 ajoute : fonctionnalités de manipulation des CSS, les feuilles de styles associées aux documents HTML. fonctionnalités d'accès à des événements liées à des changements d'état d'un document ou à des actions de l'utilisateur sur un document (ou un objet contenu dans un document)

4 DOM (Docment Object Model) IV DOM parseur I DOM niveau 2 ajoute : fonctionnalités de parcours de document XML, avec ou sans filtre ; fonctionnalités d'identification de portion de document, basées sur les informations de structure ou sur des contenus quelconques, identifiés par leur ordre séquentiel. À noter que ces fonctionnalités sont essentielles, pour prendre en compte les notions de position associées à la recommandation XPointer. DOM niveau 3 permettra aussi l'accès aux modèles (structurés sous forme de DTD, Schéma ou tout autre formalisme). Pour accéder à l information d un document XML: Le parseur lit le fichier Vérification de la validité s il y a lieu (DTD, ou schema) Conversion du document XML en document objet en mémoire Le document objet est un arbre de nœuds contenant les données et la structure de l information Le DOM fournit les interfaces nécessaires pour accéder aux nœuds du document. org.w3c.dom.* Il crée des objets qui sont des instances de classes prédéfinis par l API La classe centrale est 'Document' (DOM tree) Le standard n inclut pas: Parcours de l arbre La sérialisation du document DOM parseur II Création d un arbre DOM - I Fichier XML DOM Parser DOM Tree A P I Application Parseur XML et couche DOM Organisation hiérarchique Tout est nœud Même le document

5 Création d un arbre DOM II Interfaces et classes DOM DocumentFragment import org.w3c.dom.*; //interfaces DOM import com.sun.xml.tree.*; //Using Sun classes import org.xml.sax.*; //Need SAX classes public class myclass { Document mydoc; //Document object try { //if 'true' -> validate mydoc = XmlDocument.createXmlDocument("file:/doc.xml", true); catch (IOException err) { catch (SAXException err) { catch (DOMException err) { //If no exceptions, should have a 'Document' object Node Document CharacterData Attr Element DocumentType Notation Entity EntityReference Text CDATASection Comment NodeList NamedNodeMap DocumentType ProcessingInstruction Modèle de document DOM - I Modèle de document DOM II Nom de l objet Description Descendants Nom de l objet Description Descendants Document DocumentFragment Node ProcessingInstruction Racine de l arbre d objet représentant un document. Cet objet représente le document dans son entier. Propose des méthodes pour créer un élément, un fragment, etc. Portion de l arbre d objet représentant un document. Utilisé pour créer ou déplacer des fragments de document. Objet de base pour tous les objets DOM, représentant un nœud de l arbre constituant un document Représente une référence à une instruction de traitement définie dans un document Element (un seul) l élément racine, ProcessingInstruction, Comment, DocumentType Element, ProcessingInstruction, Comment, Text, CDATASection, EntityReference pas d instanciation Pas de descendant Text Comment CDATASection Entity EntityReference Attribute Cet objet représente le contenu textuel d un élément ou d un attribut Cet objet représente un commentaire Cet objet permet de délimiter un bloc de texte contenant des données qui seraient interprétées comme des balises XML Represente une entité Représente une référence à une entité dans un document Objet, hérite des méthodes et des attributs de Node. Pas de descendant Pas de descendant Pas de descendant Element, ProcessingInstruction, Comment, Text, Element, ProcessingInstruction, Comment, Text, - Element Cet objet représente un élément du document Element, Text, Comment,. Etc.. Etc. Etc.

6 Interface Node Méthodes de Node Objet de base Description des nœuds: Elements Attributes Text Comments CDATA sections Entity declarations Entity references Notation declarations Entire documents Processing instructions Collections des Node NodeList, NamedNodeMap, DocumentFragment Trois catégories de méthodes Caractéristiques des Node name, type, value Emplacement et accès relatif au: parents, siblings, children, ancestors, descendants Modification des Node edit, delete, re-arrange child nodes Méthodes: short getnodetype(); String getnodename(); String getnodevalue() throws DOMException; void setnodevalue(string value) throws DOMException; boolean haschildnodes(); NamedNodeMap getattributes(); Document getownerdocument(); Types de nœud - getnodetype(); Nom et valeur de Node Chaque nœud a un nom et possible valeur ELEMENT_NODE = 1 ATTRIBUTE_NODE = 2 TEXT_NODE = 3 CDATA_SECTION_NODE = 4 ENTITY_REFERENCE_NODE = 5 ENTITY_NODE = 6 PROCESSING_INSTRUCTION_NODE = 7 COMMENT_NODE = 8 DOCUMENT_NODE = 9 DOCUMENT_TYPE_NODE = 10 DOCUMENT_FRAGMENT_NODE = 11 NOTATION_NODE = 12 if (mynode.getnodetype() == Node.ELEMENT_NODE) { //process node Type Interface Name Name Value ATTRIBUTE_NODE Attr Attribute name Attribute value DOCUMENT_NODE Document #document NULL DOCUMENT_FRAGMENT_NODE DocumentFragment #document-fragment NULL DOCUMENT_TYPE_NODE DocumentType DOCTYPE name NULL CDATA_SECTION_NODE CDATASection #cdata-section CDATA content COMMENT_NODE Comment Entity name Content string ELEMENT_NODE Element Tag name NULL ENTITY_NODE Entity Entity name NULL ENTITY_REFERENCE_NODE EntityReference Entity name NULL NOTATION_NODE Notation Notation name NULL PROCESSING_INSTRUCTION_ NODE ProcessingInstruction Target string Content string TEXT_NODE Text #text Text string

7 Navigation dans Node Manipulation de Node Chaque nœud a une localisation spécifique dans l arbre L interface Node spécifie des méthodes pour se retrouver et trouver les nœuds autour getprevioussibling() Les nœuds peuvent subir des manipulations: ajout, modification, déplacement, copie, etc. Old getparentnode() getnextsibling() getfirstchild() getchildnodes() getlastchild() Node parent = mynode.getparentnode(); if (mynode.haschildren()) { NodeList children = mynode.getchildnodes(); 25 insertbefore Ref New replacechild public Node insertbefore(node newchild, Node refchild) throws DOMException; public Node replacechild(node newchild, Node oldchild) throws DOMException; clonenode Shallow 'false' Deep 'true' New 26 DocumentFragment::Node Interface Element Node Un fragment du Document peut être temporairement stocker dans le nœud DocumentFragment Lightweight object, e.g. for 'cut-n-paste' Attaché sur un autre nœud, il se détruit (très utile pour l ajout des enfants dans l arbre) DOM tree DocumentFragment New DOM tree Représente un élément Inclus les balises de début, de fin et le contenu Types de noeud fils Nœud Element Nœud Attribute Nœud ProcessingInstruction Nœud Comment Nœud Text Nœud CDATASection Nœud EntityReference

8 Interface Element Text Node public interface Element extends Node { public String gettagname(); public String getattribute(string name); public void setattribute(string name, String value) throws DOMException; public void removeattribute(string name) throws DOMException; public Attr getattributenode(string name); public Attr setattributenode(attr newattr) throws DOMException; public Attr removeattributenode(attr oldattr) throws DOMException; public NodeList getelementsbytagname(string name); public String getattributens(string namespaceuri, String localname); public void setattributens(string namespaceuri, String qualifiedname, String value) throws DOMException; public void removeattributens(string namespaceuri, String localname) throws DOMException; public Attr getattributenodens(string namespaceuri, String localname); public Attr setattributenodens(attr newattr) throws DOMException; public NodeList getelementsbytagnamens(string namespaceuri, String localname); 29 Représente le contenu textuel d un élément ou un attribut Contient du texte pure pas de balise Un nœud texte pour chaque texte continu et pure Élément sans sous-élément Le texte est représenté comme un objet texte unique Élément avec plusieurs sous-elements Plusieurs objets texte Les méthodes getnodevalue() returns text Ex: public interface Text extends CharacterData { public Text splittext(int offset) throws DOMException; 30 Comment Node CDATA Section Node Représente un commentaire Types des nœuds fils Pas de nœud méthodes getnodevalue() returns text Comment Interface public interface Comment extends CharacterData { Represents a CDATA section Child node types None Node interface methods getnodevalue() returns text CDATASection Interface public interface CDATASection extends Text { Exemple de code case Node.TEXT_NODE: case Node.CDATA_SECTION_NODE: case Node.COMMENT_NODE: System.out.println(node.getNodeValue()); break; // end switch statement

9 Attribute Node Document Type Node Représente un attribut Types des nœuds fils Nœuds Text Nœuds Entity reference Méthodes getnodename() returns name of attribute getnodevalue() returns value of attribute Attribute Interface public interface Attr extends Node { public String getname(); public boolean getspecified(); public String getvalue(); public void setvalue(string value) throws DOMException; public Element getownerelement(); Représente la déclaration du type de document Types de nœuds fils Pas de nœud L interface DocumentType public interface DocumentType extends Node { public String getname(); public NamedNodeMap getentities(); public NamedNodeMap getnotations(); public String getpublicid(); public String getsystemid(); public String getinternalsubset(); Processing Instruction Node Le reste de l API Représente les instructions de processing <?xml-stylesheet href="xsl\javaxml.html.xsl" type="text/xsl"?> Types de nœuds fils Pas de nœud Les méthode de Node interface getnodename() returns target getnodevalue() returns the rest Exemple du code case Node.PROCESSING_INSTRUCTION_NODE: System.out.println("<?" + node.getnodename() + " " + node.getnodevalue() + "?>"); break; (Document, DocumentType, Element, Attr, CharacterData, Text, CDATASection, Comment, ProcessingInstruction, EntityReference, Entity, Notation)::Node voir documentation

10 Exemple DOM HTML 4.0 ProcessingInstruction <?xml:stylsheet type=''text/xsl''?> Document <?xml version=''1.0'' encoding=''iso '' standalone=''yes''?> DocuemntType <!DOCTYPE dossier[...]> Comment <!--ce document...> <?xml version= 1.0 encoding= iso standalone= yes?> <?xml:stylesheet type= text/xsl?> <!DOCTYPE dossier [ <!ENTITY titre construire une application XML > <!ELEMENT dossier (fichier*)> <!ATTLIST dossier chemin CDATA #REQUIRED> <!ELEMENT fichier (#PCDATA) Text <!ATTLIST fichier nom CDATA #REQUIRED> ]> <dossier chemin= c:\doc\xml > Etc </dossier> Element <fichier nom=''exemple.xml''> Element <dossier chemin=''c:\doc\xml''> EntityReference Text CDATASection Element <fichier nom=''livre.xml''> Text ce fichier... <table border= 1 > <thead><th>nom</th><th>prenom</th> <thead> <tbody> <tr><td>dupont>/td><td>jean</td></tr> <tr><td>durant>/td><td>jacques</td></tr> </tbody> </table> Nom prenom Dupont Durant Jean jacques Manipulation des nœuds Organisation hiérarchique DOM HTML 4.0 SAX I <html tablesectionelement> <html TableCellElement> <html TableCellElement> nom prenom <html TableCellElement> Dupont <html table element> <html tablesectionelement> <html TableRowElement> <html TableRowElement> <html TableCellElement> jean <html TableCellElement> Durand <html TableCellElement> jacques Standard de fait 1997, Modèle événementiel Norme: SAX est très rapide, mais il ne permet pas de transformer l'arbre lors du parsing (il ne fait que consommer les données). Le principe du parser SAX est simple: on lui raccorde des objets dont les méthodes (implantant des interfaces précises) sont appelées par le parser lorsque certains évènements se produisent au cours du parsing du fichier XML.

11 SAX - II Gestion des évènements SAX Caractéristiques Basé sur la gestion des événements Rapide avec une légère API Pas besoin de charger le document entier dans la mémoire Accès séquentiel en lecture uniquement Pas de support pour les modifications du contenu La version SAX 2 supporte les namespaces À l origine conçu pour JAVA Mais maintenant supporter par d autre langage (C++, Python, Perl) Le parseur SAX génère des évènements quand: Au début et à la fin du document Une balise d ouverture d un élément Une balise de fermeture rencontrée Des #pcdata et cdata sont rencontrées Des Commentaires, instructions de traitement sont rencontrées Le processus séquentiel des évènements est très important pour pouvoir traiter correctement Utilisation d un mécanisme de callback pour avertir l application Procédures de programmation Package org.xml.sax.* Create XML Parser Create Event Handler Call Parser and Set Event Handler Parse Handling Event Handler Processing XMLReader parser = XMLReaderFactory.createXMLReader(); myhandler handler = new myhandler(); parser.parse(args[0]); SAX parser calls methods on the event handler public void startdocument(){ System.out.println( XML Document Start ); Les interfaces Parser DocumentHandler ErrorHandler DTDHandler EntityHandler AttributeList Locator EntityResolver Étapes d utilisation de SAX: Création du modèle objet du document Création de SAX parseur Création de DocumentHandler pour changer le document XML en instance du modèle objet

12 Interfaces SAX - I La norme SAX définit ainsi quatre interfaces : 1) DocumentHandler: Implémenté par la classe qui active le parseur class myclass implements DocumentHandler { myparser.setdocumenthandler(this); Le parseur appelle ses méthodes pour rendre compte des évènements relatifs au document. L interface définit, entre autre, les méthodes suivantes : void startdocument() //lorsqu'il ouvre un nouveau document void enddocument() void startelement(string name, AttributeList attrs) //lorsqu'il rencontre un nouvel élément void endelement(string name) void characters(char[] ch, int start, int length) //lorsqu'il rencontre des caractères void ignorablewhitespace(char[] ch, int start, int length) //ignorer les espaces blanches void processinginstruction(string target,string data) Interfaces SAX II La norme SAX (suite) 2) ErrorHandler : ses méthodes sont appelées lorsque le parseur rencontre des warnings ou des erreurs. Elle permet par exemple à l'utilisateur de décider d'arrêter ou non le parsing si le processeur rencontre un warning. Trois niveaux d exceptions: void error(saxparseexception ex); void fatalerror(saxparserexcpetion ex); void warning(saxparserexception ex); 3) DTDHandler : ses méthodes sont appelées lors du parsing de la DTD du document, avertit l application quand le parseur rencontre des data binaires notationdecl(string name, String publicid, String systemid); unparsedentitydecl(string name, String publicid, String systemid, String notationname); Interfaces SAX III Exemple La norme SAX (suite) 4) EntityResolver : son unique méthode resolveentity() renvoie une URL pour une URI donnée. Utile pour la gestion des catalogues par exemple. public InputSource resolveentity(string publicid, String systemid) { if (systemid.equals("disclaimer") publicid.equals("-//ebi//text Disclaimer//EN")) return (new InputSource(file:/xml/disc.xml)); Interface Locator: associe un événnement à une localisation d un document int getlinenumber(); int getcolumnnumber(); String getsystemid(); String getpublicid(); InputSource, AttributeList interface, EntityResolver Interface, ParserFactory Class voir documentation Transformation du document XML en groupe d évènements

13 Quand gérer la validation (DTD/Schema)? Quand utiliser DOM? SAX? La validation est un processus qui ralentit l application: Validez durant le développement C est la phase de test Si une partie de votre application génère ou modifie du code XML, alors il faut intégrer la validation du code Foncez durant la production Augmente la rapidité Exceptions: Si le client prend partie active dans la gestion du document XML Attention de garder la validation Si votre application reçoit du code XML d une autre application qui est hors de votre control Cela dépend de données d entrée et de sortie d une application SAX est séquentiel Donc pas d accès aléatoire au document On accède à l information uniquement quand l analyseur accède et on les perd aussitôt qu il les perd Il faut faire un effort de sauvegarde de l historique (peine perdue et déjà faite ailleurs) Avec SAX pas d accès latéral aux sein des éléments Pas de notion de frère ou fils, etc. Pour le processeur XSL c est une catastrophe Quand utiliser DOM? SAX? Quand utiliser DOM? SAX? Pourquoi utiliser SAX alors? Exemple: table de matière d un livre très volumineux avec un index DOM explosera la mémoire SAX est parfait DOM est parfait pour XSLT? XSLT peut créer durant son traitement une nouvelle arborescence DOM pour le document de sortie en copiant, modifiant, ajoutant et supprimant des nœuds dans l arborescence d entrée. DOM nécessite un chargement intégrale du document dans la mémoire I exigence en mémoire est proportionnelle à la taille et à la complexité du document Pourquoi utiliser DOM alors? Pour des documents < 1 Mo Pour des documents > 1 Mo bases de données DOM: Représentation arborescente hiérarchique Accès aléatoire aux données Permet de traverser l arbre et de modifier le contenu Pour des documents complexes Documents venant de plusieurs sources Pour des documents avec avec des traitements complexes: Indexation Accès multiples, etc. Demande beaucoup de mémoire SAX: Représentation événementielle Accès hiérarchique aux données Documents volumineux (2-3 Mo de caractères) Documents sont machine readable Documents simples non complexes sans ajout, ni modification du contenu

14 JAXP (Java Api for Xml Parsing) JAXP: principe JAXP est un ensemble d'apis Java permettant d'effectuer des traitements XML qui inclut SAX (SAX 2.0), DOM(DOM Level 2) et la manipulation de transformations XSLT. Le but est de : Fournir une couche d abstraction au dessus de SAX ou DOM afin de garantir un effort de standardisation des aspects non couverts par SAX et DOM L analyse L'API est le fruit de travaux de développement communs à Ariba, AOL/Netscape, BEA, Bluestone, Fujitsu, IBM, et Oracle. téléchargeable gratuitement sur l'espace de Sun Java Technology and XML. Raison d utiliser JAXP: 1. DOM ne spécifie pas comment créer un objet parseur différent API selon implémentation portabilité du code est affecté En utilisant DOM (ou SAX), il faut explicitement importer et référencer la classe de l analyseur (org.apache.xerces.parsers. DOMParser) Si on change de parseur problèmes User Application Reference Parser JAXP Interfaces Other Parser 2. Avant chaque opération DOM, le document XML a besoin d être parser et un objet doit être créer. Cette opération n est pas standardiser par le W3C 3. indépendance des processeurs JDOM - principe JDOM - package Encore une API? Java + XML = JDOM Philosophie de JDOM: Facile à utiliser pour les programmeurs java devrait cacher les complexités de XML dans la mesure du possible devrait intégrer DOM et SAX Lecture et écriture des documents DOM et les évènements SAX Utilisation des différents parseurs DOM ou SAX (utilisation du modèle JAXP) devrait rester compatible avec les dernières normes de XML Pourquoi ne pas utiliser DOM: Occupation élevée de la mémoire Pourquoi ne pas utiliser SAX: Pas de possibilité de modifier les documents, d accéder aléatoirement, ou de générer une sortie physique JDOM traite tout format hiérarchique et non uniquement DOM JDOM pour le DOM/SAX comme le RMI pour CORBA Java optimalisé Les classes représentant un document XML et sa construction: Attribute, CDATA Comment, DocType Document, Element Entity, Namespace ProcessingInstruction (PartialList) (Verifier) (Assorted Exceptions) Les classes de lecture des documents XML depuis des sources existants: DOMBuilder SAXBuilder Les classes pour écrire les documents XML sous plusieurs formes et sorties: DOMOutputter SAXOutputter XMLOutputter org.jdom org.jdom.adapters org.jdom.input org.jdom.output Packages d adaptateurs pour obtenir Un objet DOM à partir de n importe quel analyseur

15 JDOM fonctionnement Cycle de vie XML Document SAXBuilder XMLOutputter XML Document SAXBuilder DOMBuilder DOM Node(s) Direct Build JDOM Document Création de JDOM: - Direct - À partir d une source XML utilisant un analyseur DOM - À partir d une source XML utilisant un analyseur SAX XMLOutputter SAXOutputter DOMOutputter 57 Un document est représenté par la classe org.jdom.document Le document peut être construit from scratch Document doc = new Document( new Element("root").setText("hi")); Le document peut être construit depuis un fichier, un stream ou un URL SAXBuilder builder = new SAXBuilder(); Document doc = builder.build(url); Le résultat peut être XML, SAX ou DOM XMLOutputter outputter = new XMLOutputter(); outputter.output(doc, System.out); 58 Exemples SAX/DOM Parseurs et performances I Examples (fournis avec xerces-apache ou XML4java-ibm): Compteur d éléments, d attributs, et d espaces vides Avec SAX java sax.saxcount [inputfile] Avec DOM java dom.domcount [inputfile] Les tests réalisés se sont intéressés, plus précisément, aux points suivants : jeux de caractères : PCDATA, noms d'élément et d'attribut, valeurs d'attribut ; documents bien formés : tests de base un élément n'est pas fermé, n'est pas ouvert, reconnaissance des éléments vides, syntaxe de base des attributs, prise en compte des Processing Instructions, des commentaires ; tests poussés pour valider : Que l'on ne peut avoir des noms d'élément et d'attribut ayant des caractères ":", en dehors des namespaces, DTD et validation

16 Parseurs et performances II Conclusion Les résultats bruts sont les suivants : Xerces Java Parser validation d'un arbre bien formé de 57 Mo : 11 secondes validation d'un document de 49 Mo : 20 secondes Oracle XML Parser validation d'un arbre bien formé de 57 Mo : 10 secondes validation d'un document de 49 Mo : 57 secondes Java API for XML Parsing validation d'un arbre bien formé de 57 Mo : 10 secondes validation d'un document de 49 Mo : 11 secondes Microsoft XML Parser validation d'un arbre bien formé de 57 Mo : 14 secondes validation d'un document de 49 Mo : -- DOM : object-based, random-access, read-write Sax : event-driven, sequential-access, read-only JAXP Java API for XML parsing (SUN). Implémente les librairies de SAX pour lire les données XML et pour construire le DOM. Offre la possibilité de changer le parseur sans avoir à recompiler l application. JDOM Définit un modèle de représentation : JDOM Document. Ce document n est pas chargé en totalité dans la mémoire. Compatible avec SAX et DOM et optimisée pour Java. API rapide et peu exigeante en ressources. Licence type Open Source mais attaché à java Références Français : Livres: Java and XML, Brett Mclaughlin ISBN: ,O REILLY Java et XML, Brett Mclaughlin (version française) ISBN: Java, XML, and JAXP, Arthur Griffith ISBN: