Lire et écrire du XML

Table des matières
Introduction
1. Un peu d'histoire
2. Les API Java pour XML
Un premier exemple
1. Introduction
2. Structure de base d’un fichier XML
2.1. Un fichier XML simple
2.2. Notion d’espaces de noms
3. Un premier code pour lire un fichier XML
3.1. Lecture avec Dom4J
Description d’un document XML
1. Introduction
2. Organisation d'un document XML
2.1. Introduction
2.2. Nœuds dans un document XML
2.3. Relations entre nœuds dans un document XML
2.4. Ordre dans un document
2.5. Valeurs atomiques dans un document XML
2.6. Notion de PCDATA et CDATA
3. Document Type Definition (DTD)
3.1. Attacher un document à une DTD
3.2. Contenu d’une DTD
3.3. Exemple de DTD, analyse de web-app_2_3.dtd
4. XML Schema
4.1. Introduction
4.2. Un premier schéma
4.3. Attacher un document XML à un schéma
4.4. Types simples
4.5. Attribut
4.6. Restriction sur une déclaration
4.7. Types complexes
4.8. Contraindre un contenu simple
Lire et écrire du XML
1. Introduction
2. Utilisation de DOM4J
2.1. Introduction
2.2. Un premier exemple simple
2.3. Organisation de l'API
2.4. Classe Namespace
2.5. Classe QName
2.6. Interface Node
2.7. Interface Branch
2.8. Interface Document
2.9. Interface Element
2.10. Interface Attribute
2.11. Interface Text
3. Utilisation de Xerces
3.1. Introduction
3.2. Présentation de SAX
3.3. Présentation de DOM
Analyseur SAX en Xerces
1. Introduction
2. Création d'un analyseur SAX
2.1. Introduction
2.2. Objet DefaultHandler
2.3. Exemple d'analyse d'un fichier
3. Présentation de l'API
3.1. Interface ContentHandler
3.2. Interface ErrorHandler
3.3. Interface DTDHandler
3.4. Interface EntityResolver
3.5. Interface LexicalHandler
Manipuler un DOM en Xerces
1. Introduction
2. Création d'un DOM
3. Présentation de l'API
3.1. Organisation de l'API
3.2. Interface Node
3.3. Interface NodeList
3.4. Interface Element
3.5. Interface Attr
3.6. Interface CharacterData
3.7. Interface Comment
3.8. Interface CDATASection
3.9. Interface Text
3.10. Interface Entity
3.11. Interface EntityReference
3.12. Interface ProcessingInstruction
3.13. Interface Document
3.14. Interface DocumentFragment
3.15. Interface DocumentType
Interroger un document en XPath
1. Introduction, notion de nœud XML
2. Une première requête XPath
2.1. Un premier document à interroger
2.2. Une première requête
2.3. Forme d'une requête XPath

1. Introduction

Il existe deux grandes façons de lire des documents XML et de les analyser dans du code Java (ou autre langage) : DOM et SAX. DOM signifie Document Object Model . Il consiste à associer un graphe d’objets à un document XML, et à naviguer dedans en suivant les relations père-fils naturellement. Son principal avantage est la facilité avec laquelle on peut naviguer dans l’arbre XML. L’approche DOM semble la plus naturelle du point de vue de la programmation objet. L’inconvénient majeur de DOM est qu’il nécessite de charger l’intégralité du document XML en mémoire. Dès que les documents dépassent une certaines taille (quelques giga-octets tout de même…), DOM n’est plus utilisable. D’autre part, dans certains cas cette possibilité de navigation offerte par DOM n’est pas utile. Les traitements que DOM doit faire pour convertir un document XML en graphe d’objets deviennent alors superflus, ce qui est d’autant ennuyeux qu’ils peuvent être très lourds. À l’opposé SAX, Simple API for XML , ne reconstruit pas d’arbre d’objets en mémoire. SAX analyse un document XML, et lorsqu’il rencontre des éléments ou des attributs particuliers, précisés par l’utilisateur, exécute certains traitements, invoqués sous forme de callbacks. On dit que SAX est un modèle piloté par événements. Ces événements sont simplement l’occurrence d’un élément, par exemple. DOM est consommateur de ressources, et à mesure que le document augmente de taille, cette consommation augmente aussi. À l’opposé, SAX consomme une quantité de ressources à peu près constante, qui dépend essentiellement du nombre de callbacks que l’on pose sur l’analyse du document. D’une façon générale, il faut réserver à DOM le traitement des documents peu importants, et lorsque les performances ne sont pas cruciales. Dans tous les autres cas, SAX sera la bonne API à choisir. Ces deux API sont comme à l’habitude, des jeux d’interfaces. L’implémentation standard de ces interfaces, fournie par le JDK, est Xercès, développé et distribué en open-source par l’Apache Software Fondation. Cette API n’est probablement pas la meilleure : elle est complexe, lourde à utiliser, et peu performante. On pourra lui préférer Dom4J, bien qu'elle soit moins complète. C’est cette implémentation que nous allons présenter dans la suite.
API Java pour XML
Retour au blog Java le soir
Cours & Tutoriaux