Quelle est la différence entre SAX et DOM?
J'ai lu des articles sur les analyseurs XML et suis tombé sur SAX et DOM.
SAX est basé sur des événements et DOM est un modèle arborescent - je ne comprends pas les différences entre ces concepts.
D'après ce que j'ai compris, événement signifie qu'un type d'événement se produit sur le nœud. Comme lorsque l'on clique sur un nœud particulier, tous les sous-nœuds seront créés, plutôt que de les charger tous en même temps. Mais dans le cas de DOM, son analyse chargera tous les noeuds et fera le modèle d'arbre.
Ma compréhension est-elle correcte?
S'il vous plaît, corrigez-moi si je me trompe ou expliquez-moi d'une manière plus simple, basée sur les événements et le modèle d'arborescence.
Eh bien, vous êtes proche.
Dans SAX, les événements sont déclenchés lorsque le XML est en cours analysé. Lorsque l'analyseur analyse le code XML et qu'il rencontre une balise commençant (par exemple, <something>), il déclenche l'événement tagStarted (le nom réel de l'événement peut différer). De même, lorsque la fin de la balise est rencontrée lors de l'analyse syntaxique (</something>), il déclenche tagEnded. L'utilisation d'un analyseur SAX implique que vous deviez gérer ces événements et donner un sens aux données renvoyées avec chaque événement.
Dans DOM, aucun événement n'est déclenché lors de l'analyse. L'ensemble du code XML est analysé et une arborescence DOM (des noeuds du code XML) est générée et renvoyée. Une fois analysé, l'utilisateur peut parcourir l'arborescence pour accéder aux différentes données précédemment intégrées aux différents nœuds du XML.
En général, DOM est plus facile à utiliser, mais il est trop long d'analyser l'intégralité du XML avant de pouvoir commencer à l'utiliser.
En quelques mots ...
SAX (S imple A PI pour X ML): est un processeur basé sur un flux. Vous n’avez qu’une petite partie de la mémoire à tout moment et vous "flipez" le flux XML en implémentant du code de rappel pour des événements tels que tagStarted() etc. comme utiliser xpath ou traverser des arbres.
DOM (D document O bject M odel): Vous chargez le tout dans la mémoire - c'est une énorme mémoire. Vous pouvez perdre de la mémoire même avec des documents de taille moyenne. Mais vous pouvez utiliser xpath et parcourir l’arbre, etc.
Ici, dans des mots plus simples:
DOM
Analyseur de modèle d'arborescence (basé sur les objets) (arborescence de nœuds).
DOM charge le fichier dans la mémoire, puis analyse le fichier.
Contient des contraintes de mémoire car il charge l'intégralité du fichier XML avant l'analyse.
DOM est en lecture et en écriture (peut insérer ou supprimer des nœuds).
Si le contenu XML est petit, préférez alors l'analyseur DOM.
La recherche en arrière et en avant est possible pour rechercher les étiquettes et évaluer les informations à l'intérieur des étiquettes. Donc, cela donne la facilité de navigation.
Plus lent au moment de l'exécution.
SAX
Analyseur basé sur les événements (séquence d'événements).
SAX analyse le fichier comme il le lit, c’est-à-dire analyse noeud par noeud.
Aucune contrainte de mémoire car il ne stocke pas le contenu XML dans la mémoire.
SAX est en lecture seule, c’est-à-dire qu’il ne peut pas insérer ou supprimer le noeud.
Utilisez l'analyseur SAX lorsque le contenu de la mémoire est volumineux.
SAX lit le fichier XML de haut en bas et la navigation en arrière n'est pas possible.
Plus rapide au moment de l'exécution.
Vous avez raison de bien comprendre le modèle basé sur le DOM. Le fichier XML sera chargé dans son ensemble et tout son contenu sera construit comme une représentation en mémoire de l’arbre représenté par le document. Cela peut prendre beaucoup de temps et d’énergie, en fonction de la taille du fichier d’entrée. L'avantage de cette approche est que vous pouvez facilement interroger n'importe quelle partie du document et manipuler librement tous les nœuds de l'arborescence.
L’approche DOM est généralement utilisée pour les petites structures XML (qui dépendent de la puissance et de la mémoire de votre plate-forme) qui peuvent nécessiter d’être modifiées et interrogées de différentes manières une fois chargées.
D'autre part, SAX est conçu pour gérer les entrées XML de toutes tailles. Au lieu que le framework XML se charge de déterminer la structure du document et de préparer potentiellement de nombreux objets pour tous les nœuds, attributs, etc., SAX vous le laisse totalement.
En gros, il lit les entrées à partir du haut et appelle les méthodes de rappel que vous fournissez lorsque certains "événements" se produisent. Un événement peut toucher une balise d'ouverture, un attribut dans la balise, trouver du texte à l'intérieur d'un élément ou rencontrer une balise de fin.
SAX lit obstinément l'entrée et vous dit ce qu'elle voit de cette façon. C'est à vous de gérer toutes les informations d'état dont vous avez besoin. Habituellement, cela signifie que vous construisez une sorte de machine à états.
Bien que cette approche du traitement XML soit beaucoup plus fastidieuse, elle peut aussi être très puissante. Imaginez que vous souhaitiez extraire simplement les titres d'articles de nouvelles d'un flux de blog. Si vous lisez ce XML en utilisant DOM, tout le contenu de l'article, toutes les images, etc. contenus dans le XML seront chargés en mémoire, même si cela ne vous intéresse pas.
Avec SAX, vous pouvez simplement vérifier si le nom de l’élément est (par exemple) "title" chaque fois que votre méthode d’événement "startTag" est appelée. Si tel est le cas, vous savez que vous devez ajouter ce que le prochain événement "elementText" vous proposera. Lorsque vous recevez l'appel à l'événement "endTag", vous vérifiez à nouveau s'il s'agit de l'élément de clôture du "titre". Après cela, vous ignorez simplement tous les éléments suivants, jusqu'à ce que l'entrée soit terminée ou qu'un autre "startTag" portant le nom "title" apparaisse. Etc...
Vous pouvez lire des mégaoctets et des mégaoctets de XML de cette façon, en extrayant simplement la quantité infime de données dont vous avez besoin.
Le côté négatif de cette approche est bien sûr que vous devez faire beaucoup plus de comptabilité vous-même, en fonction des données que vous devez extraire et de la complexité de la structure XML. De plus, vous ne pouvez naturellement pas modifier la structure de l'arborescence XML, car vous ne l'avez jamais sous la main dans son ensemble.
Donc, en général, SAX convient au traitement de quantités potentiellement importantes de données que vous recevez avec une "requête" spécifique à l'esprit, mais ne doit pas être modifié, alors que DOM vise davantage à vous donner toute la flexibilité nécessaire pour modifier la structure et le contenu, aux dépens de plus forte demande de ressources.
Vous comparez des pommes et des poires. SAX est un analyseur qui analyse les structures DOM sérialisées. Il existe de nombreux analyseurs syntaxiques, et "basé sur les événements" fait référence à la méthode d'analyse.
Peut-être qu'une petite récapitulation est en ordre:
Le modèle d'objet de document (DOM) est un modèle de données abstrait qui décrit une structure de document hiérarchique basée sur une arborescence. un arbre de document est composé de nœuds , à savoir des nœuds d'élément, d'attribut et de texte (et quelques autres). Les nœuds ont des parents, des frères et soeurs et des enfants et peuvent être traversés, etc., tout ce à quoi vous êtes habitué depuis JavaScript (ce qui n'a d'ailleurs rien à voir avec le DOM).
Une structure DOM peut être sérialisée , c'est-à-dire écrite dans un fichier, à l'aide d'un langage de balisage tel que HTML ou XML. Un fichier HTML ou XML contient donc une version "écrite" ou "aplatie" d'un arbre de document abstrait.
Pour qu'un ordinateur puisse manipuler, ou même afficher, une arborescence DOM à partir d'un fichier, il doit désérialiser ou analyser , le fichier et reconstruire l’arbre abstrait en mémoire. C'est ici qu'intervient l'analyse.
Nous arrivons maintenant à la nature des analyseurs syntaxiques. Une façon d'analyser consiste à lire l'intégralité du document et à créer de manière récursive une arborescence en mémoire, puis à exposer l'intégralité du résultat à l'utilisateur. (Je suppose que vous pouvez appeler ces analyseurs "analyseurs DOM".) Cela serait très pratique pour l'utilisateur (je pense que c'est ce que fait l'analyseur XML de PHP), mais il souffre de problèmes d'évolutivité et devient très coûteux pour les gros documents.
Par ailleurs, l’analyse basée sur les événements , comme celle effectuée par SAX, examine le fichier de manière linéaire et crée simplement . rappels à l'utilisateur chaque fois qu'il rencontre une donnée structurelle, telle que "cet élément a commencé", "cet élément a pris fin", "du texte ici", etc. il peut durer indéfiniment sans se soucier de la taille du fichier d'entrée, mais il est beaucoup plus modeste car il oblige l'utilisateur à effectuer tout le travail de traitement (en fournissant des rappels). Pour revenir à votre question initiale, le terme "basé sur les événements" fait référence à ceux qui analysent les événements que l'analyseur soulève lorsqu'il traverse le fichier XML.
Le article Wikipedia contient de nombreux détails sur les étapes de l'analyse syntaxique SAX.
Je vais fournir une réponse générale orientée Q & A pour cette question:
réponse aux questions
Pourquoi avons-nous besoin d'un analyseur XML?
Nous avons besoin d'un analyseur XML car nous ne voulons pas tout faire dans notre application, et nous avons besoin de programmes ou de bibliothèques "auxiliaires" pour faire quelque chose de très bas niveau mais très nécessaire pour nous. Ces tâches élémentaires mais nécessaires incluent la vérification de la qualité de la mise en forme, la validation du document par rapport à sa DTD ou à son schéma (uniquement pour la validation des analyseurs), la résolution de la référence de caractère, la compréhension des sections CDATA, etc. Les analyseurs syntaxiques XML sont de tels programmes "auxiliaires" et ils effectueront tous ces travaux. Avec l'analyseur XML, nous sommes protégés de beaucoup de ces complexités et nous pourrions nous concentrer sur une programmation de haut niveau via les API implémentées par les analyseurs, et gagner ainsi en efficacité de programmation.
Lequel est le meilleur, SAX ou DOM?
SAX et DOM Parser ont leurs avantages et leurs inconvénients. Laquelle est la meilleure devrait dépendre des caractéristiques de votre application (veuillez vous référer aux questions ci-dessous).
Quel analyseur peut obtenir une meilleure vitesse, des analyseurs DOM ou SAX?
L'analyseur SAX peut obtenir une meilleure vitesse.
Quelle est la différence entre une API basée sur une arborescence et une API basée sur un événement?
Une API basée sur une arborescence est centrée autour d'une structure arborescente et fournit donc des interfaces sur les composants d'une arborescence (un document DOM), tels que l'interface Document, l'interface Node, l'interface NodeList, l'interface Element, l'interface Attr, etc. En revanche, une API basée sur les événements fournit des interfaces sur les gestionnaires. Il existe quatre interfaces de gestionnaire, l’interface ContentHandler, l’interface DTDHandler, l’interface EntityResolver et l’interface ErrorHandler.
Quelle est la différence entre un analyseur DOM et un analyseur SAX?
Les analyseurs DOM et SAX fonctionnent de différentes manières:
Un analyseur DOM crée une arborescence en mémoire à partir du document d'entrée, puis attend les demandes du client. Mais un analyseur SAX ne crée aucune structure interne. Au lieu de cela, il prend les occurrences des composants d'un document d'entrée en tant qu'événements et indique au client ce qu'il lit pendant la lecture du document d'entrée. UNE
L’analyseur DOM sert toujours à l’application cliente avec le document entier, quel que soit le besoin réel du client. Mais un analyseur SAX sert toujours à l'application cliente uniquement avec des parties du document à un moment donné.
- Avec l'analyseur DOM, les appels de méthode dans l'application client doivent être explicites et forment une sorte de chaîne. Mais avec SAX, certaines méthodes (généralement surchargées par le client) seront invoquées automatiquement (implicitement) de manière appelée "callback" lorsque certains événements se produisent. Ces méthodes ne doivent pas nécessairement être appelées explicitement par le client, bien que nous puissions les appeler explicitement.
Comment décidons-nous quel analyseur est bon?
Idéalement, un bon analyseur devrait être rapide (gain de temps), peu encombrant, riche en fonctionnalités et facile à utiliser. Mais en réalité, aucun des principaux analyseurs n'a toutes ces caractéristiques en même temps. Par exemple, un analyseur DOM est riche en fonctionnalités (car il crée une arborescence DOM en mémoire et vous permet d'accéder à une partie du document à plusieurs reprises et vous permet de modifier l'arborescence DOM), mais il est inefficace lorsque le document est volumineux. , et cela prend un peu de temps pour apprendre à travailler avec. Cependant, un analyseur SAX est beaucoup plus efficace en cas de documents volumineux (car il ne crée aucune structure interne). De plus, il fonctionne plus rapidement et est plus facile à apprendre que DOM Parser, car son API est très simple. Mais du point de vue de la fonctionnalité, il fournit moins de fonctions, ce qui signifie que les utilisateurs eux-mêmes doivent en prendre davantage, comme la création de leurs propres structures de données. Au fait, qu'est-ce qu'un bon analyseur? Je pense que la réponse dépend vraiment des caractéristiques de votre application.
Quelles sont certaines applications du monde réel dans lesquelles utiliser l'analyseur SAX est avantageux par rapport à l'analyseur DOM et inversement? Quelles sont les applications habituelles pour un analyseur DOM et pour un analyseur SAX?
Dans les cas suivants, l’analyseur SAX présente un avantage par rapport à l’analyseur DOM.
- Le document d'entrée est trop volumineux pour la mémoire disponible (dans ce cas, SAX est votre seul choix)
- Vous pouvez traiter le document par petits blocs d’entrée contigus. Vous n'avez pas besoin de l'intégralité du document pour pouvoir effectuer un travail utile.
- Vous voulez simplement utiliser l'analyseur pour extraire les informations qui vous intéressent, et tous vos calculs seront entièrement basés sur les structures de données créées par vous-même. En fait, dans la plupart de nos applications, nous créons nos propres structures de données, qui ne sont généralement pas aussi compliquées que l’arborescence DOM. En ce sens, je pense que les chances d'utiliser un analyseur DOM sont moins grandes que celles d'un analyseur SAX.
Dans les cas suivants, utiliser l’analyseur DOM est avantageux par rapport à l’analyseur SAX.
- Votre application doit accéder à des parties du document très différentes en même temps.
- Votre application peut probablement utiliser une structure de données interne presque aussi compliquée que le document lui-même.
- Votre application doit modifier le document à plusieurs reprises.
- Votre application doit stocker le document pendant un temps assez long via de nombreux appels de méthode.
Exemple (utilisez un analyseur DOM ou un analyseur SAX?):
Supposons qu'un enseignant dispose d'un document XML contenant toutes les informations personnelles des étudiants, ainsi que les remarques de ses étudiants dans sa classe, et qu'il attribue maintenant les notes finales aux étudiants à l'aide d'une application. . Ce qu'il veut produire, c'est une liste avec le SSN et les notes. Nous supposons également que dans sa candidature, l'instructeur n'utilise aucune structure de données, telle que des tableaux, pour stocker les informations personnelles de l'élève et les points. Si l'instructeur décide de donner des A à ceux qui ont obtenu la moyenne de la classe ou plus, et de donner des B aux autres, il aurait alors intérêt à utiliser un analyseur DOM dans sa candidature. La raison en est qu’il n’a aucun moyen de savoir quelle est la moyenne de la classe avant que l’ensemble du document ne soit traité. Ce qu'il a probablement besoin de faire dans sa candidature, c'est d'abord de parcourir tous les points des étudiants et de calculer la moyenne, puis de parcourir à nouveau le document et d'attribuer la note finale à chaque élève en comparant les points qu'il a obtenus à la moyenne de la classe. . Si, toutefois, l'instructeur adopte une politique de notation telle que les étudiants ayant obtenu 90 points ou plus se voient attribuer des A et que les autres se voient attribuer des B, il devrait alors probablement utiliser un analyseur syntaxique SAX. La raison en est que, pour attribuer à chaque élève une note finale, il n’a pas besoin d’attendre que tout le document soit traité. Il pouvait immédiatement attribuer une note à un étudiant une fois que l'analyseur SAX avait lu la note de cet étudiant. Dans l'analyse ci-dessus, nous avons supposé que l'instructeur n'avait créé aucune structure de données. Et s'il crée sa propre structure de données, telle qu'un tableau de chaînes pour stocker le SSN et un tableau d'entiers pour stocker les points? Dans ce cas, je pense que SAX est un meilleur choix, avant que cela puisse économiser aussi bien de la mémoire que du temps, tout en réalisant le travail. Eh bien, encore une considération sur cet exemple. Et si l’instructeur veut ne pas imprimer une liste mais enregistrer le document original avec la note de chaque élève mise à jour? Dans ce cas, un analyseur DOM devrait être un meilleur choix, quelle que soit la politique de classement qu'il adopte. Il n'a pas besoin de créer sa propre structure de données. Ce qu’il doit faire, c’est d’abord modifier l’arborescence DOM (c’est-à-dire définir la valeur sur le nœud 'grade'), puis enregistrer l’arborescence modifiée dans son ensemble. S'il choisit d'utiliser un analyseur SAX au lieu d'un analyseur DOM, il doit alors créer une structure de données presque aussi compliquée qu'un arbre DOM avant de pouvoir effectuer le travail.
Un exemple
Énoncé du problème: Écrivez un programme Java pour extraire toutes les informations sur les cercles qui sont des éléments d’un document XML donné. Nous supposons que chaque élément de cercle a trois éléments enfants (c'est-à-dire x, y et rayon) ainsi qu'un attribut de couleur. Un exemple de document est donné ci-dessous:
<?xml version="1.0"?>
<!DOCTYPE shapes [
<!ELEMENT shapes (circle)*>
<!ELEMENT circle (x,y,radius)>
<!ELEMENT x (#PCDATA)>
<!ELEMENT y (#PCDATA)>
<!ELEMENT radius (#PCDATA)>
<!ATTLIST circle color CDATA #IMPLIED>
]>
<shapes>
<circle color="BLUE">
<x>20</x>
<y>20</y>
<radius>20</radius>
</circle>
<circle color="RED" >
<x>40</x>
<y>40</y>
<radius>20</radius>
</circle>
</shapes>
Programme avec DOMparser
import Java.io.*;
import org.w3c.dom.*;
import org.Apache.xerces.parsers.DOMParser;
public class shapes_DOM {
static int numberOfCircles = 0; // total number of circles seen
static int x[] = new int[1000]; // X-coordinates of the centers
static int y[] = new int[1000]; // Y-coordinates of the centers
static int r[] = new int[1000]; // radius of the circle
static String color[] = new String[1000]; // colors of the circles
public static void main(String[] args) {
try{
// create a DOMParser
DOMParser parser=new DOMParser();
parser.parse(args[0]);
// get the DOM Document object
Document doc=parser.getDocument();
// get all the circle nodes
NodeList nodelist = doc.getElementsByTagName("circle");
numberOfCircles = nodelist.getLength();
// retrieve all info about the circles
for(int i=0; i<nodelist.getLength(); i++) {
// get one circle node
Node node = nodelist.item(i);
// get the color attribute
NamedNodeMap attrs = node.getAttributes();
if(attrs.getLength() > 0)
color[i]=(String)attrs.getNamedItem("color").getNodeValue();
// get the child nodes of a circle node
NodeList childnodelist = node.getChildNodes();
// get the x and y value
for(int j=0; j<childnodelist.getLength(); j++) {
Node childnode = childnodelist.item(j);
Node textnode = childnode.getFirstChild();//the only text node
String childnodename=childnode.getNodeName();
if(childnodename.equals("x"))
x[i]= Integer.parseInt(textnode.getNodeValue().trim());
else if(childnodename.equals("y"))
y[i]= Integer.parseInt(textnode.getNodeValue().trim());
else if(childnodename.equals("radius"))
r[i]= Integer.parseInt(textnode.getNodeValue().trim());
}
}
// print the result
System.out.println("circles="+numberOfCircles);
for(int i=0;i<numberOfCircles;i++) {
String line="";
line=line+"(x="+x[i]+",y="+y[i]+",r="+r[i]+",color="+color[i]+")";
System.out.println(line);
}
} catch (Exception e) {e.printStackTrace(System.err);}
}
}
Programme avec SAXparser
import Java.io.*;
import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;
import org.Apache.xerces.parsers.SAXParser;
public class shapes_SAX extends DefaultHandler {
static int numberOfCircles = 0; // total number of circles seen
static int x[] = new int[1000]; // X-coordinates of the centers
static int y[] = new int[1000]; // Y-coordinates of the centers
static int r[] = new int[1000]; // radius of the circle
static String color[] = new String[1000]; // colors of the circles
static int flagX=0; //to remember what element has occurred
static int flagY=0; //to remember what element has occurred
static int flagR=0; //to remember what element has occurred
// main method
public static void main(String[] args) {
try{
shapes_SAX SAXHandler = new shapes_SAX (); // an instance of this class
SAXParser parser=new SAXParser(); // create a SAXParser object
parser.setContentHandler(SAXHandler); // register with the ContentHandler
parser.parse(args[0]);
} catch (Exception e) {e.printStackTrace(System.err);} // catch exeptions
}
// override the startElement() method
public void startElement(String uri, String localName,
String rawName, Attributes attributes) {
if(rawName.equals("circle")) // if a circle element is seen
color[numberOfCircles]=attributes.getValue("color"); // get the color attribute
else if(rawName.equals("x")) // if a x element is seen set the flag as 1
flagX=1;
else if(rawName.equals("y")) // if a y element is seen set the flag as 2
flagY=1;
else if(rawName.equals("radius")) // if a radius element is seen set the flag as 3
flagR=1;
}
// override the endElement() method
public void endElement(String uri, String localName, String rawName) {
// in this example we do not need to do anything else here
if(rawName.equals("circle")) // if a circle element is ended
numberOfCircles += 1; // increment the counter
}
// override the characters() method
public void characters(char characters[], int start, int length) {
String characterData =
(new String(characters,start,length)).trim(); // get the text
if(flagX==1) { // indicate this text is for <x> element
x[numberOfCircles] = Integer.parseInt(characterData);
flagX=0;
}
else if(flagY==1) { // indicate this text is for <y> element
y[numberOfCircles] = Integer.parseInt(characterData);
flagY=0;
}
else if(flagR==1) { // indicate this text is for <radius> element
r[numberOfCircles] = Integer.parseInt(characterData);
flagR=0;
}
}
// override the endDocument() method
public void endDocument() {
// when the end of document is seen, just print the circle info
System.out.println("circles="+numberOfCircles);
for(int i=0;i<numberOfCircles;i++) {
String line="";
line=line+"(x="+x[i]+",y="+y[i]+",r="+r[i]+",color="+color[i]+")";
System.out.println(line);
}
}
}
En pratique: book.xml
<bookstore>
<book category="cooking">
<title lang="en">Everyday Italian</title>
<author>Giada De Laurentiis</author>
<year>2005</year>
<price>30.00</price>
</book>
</bookstore>
- DOM présente le document XML comme une arborescence suivante (- === -).
- DOM est la norme W3C.
- L'analyseur DOM fonctionne sur le modèle d'objet de document.
- DOM occupe plus de mémoire, préféré pour les petits documents XML
- DOM est facile à naviguer en avant ou en arrière.
- SAX présente le document XML comme un événement basé sur comme
start element:abc,end element:abc. - SAX n'est pas une norme W3C, elle a été développée par un groupe de développeurs.
- SAX n'utilise pas de mémoire, ce qui est préférable pour les documents XML volumineux.
- La navigation en arrière n'est pas possible car elle traite les documents de manière séquentielle.
- Un événement se produit sur un nœud/élément et donne tous les sous-nœuds (nodus en latin, "nœud").
start element: bookstore
start element: book with an attribute category equal to cooking
start element: title with an attribute lang equal to en
Text node, with data equal to Everyday Italian
....
end element: title
.....
end element: book
end element: bookstore
DOM correspond à Document Object Model et représente un document XML sous forme d'arborescence, chaque élément représentant des branches d'arborescence. DOM Parser crée une représentation de fichier XML dans l’arborescence en mémoire, puis l’analyse; il a donc besoin de plus de mémoire et il est conseillé d’augmenter la taille de segment de mémoire pour l’analyseur DOM afin d’éviter Java.lang.OutOfMemoryError: espace de segment de mémoire Java. L'analyse d'un fichier XML à l'aide d'un analyseur DOM est assez rapide si le fichier XML est petit, mais si vous essayez de lire un fichier XML volumineux à l'aide d'un analyseur DOM, il y a plus de chances que cela prenne beaucoup de temps, voire que vous ne puissiez pas le charger complètement, simplement parce que il faut beaucoup de mémoire pour créer XML Dom Tree. Java prend en charge l'analyse DOM et vous pouvez analyser les fichiers XML dans Java à l'aide de l'analyseur DOM. Les classes DOM sont dans le package w3c.dom tandis que DOM Parser for Java est dans le package JAXP (Java API for XML Parsing).
SAX XML Parser en Java
SAX signifie API simple pour l'analyse XML. Il s’agit d’une analyse XML basée sur les événements qui analyse étape par étape le fichier XML et qui convient donc parfaitement aux fichiers XML volumineux. SAX XML Parser déclenche un événement lorsqu'il rencontre l'ouverture d'une balise, d'un élément ou d'un attribut et que l'analyse fonctionne en conséquence. Il est recommandé d'utiliser l'analyseur SAX XML pour analyser des fichiers xml volumineux dans Java, car il ne nécessite pas de charger un fichier XML entier dans Java et il peut lire un gros fichier XML par petites parties. . Java prend en charge l'analyseur SAX et vous pouvez analyser n'importe quel fichier xml dans Java à l'aide de SAX Parser. J'ai présenté un exemple de lecture de fichier xml à l'aide de SAX Parser ici. L’un des inconvénients de l’utilisation de SAX Parser dans Java est que la lecture d’un fichier XML dans Java à l'aide de SAX Parser nécessite davantage de code par rapport à DOM Parser.
Différence entre DOM et SAX XML Parser
Voici quelques différences de haut niveau entre l'analyseur DOM et l'analyseur SAX en Java:
1) L’analyseur DOM charge l’ensemble du document XML en mémoire alors que SAX ne charge qu’une petite partie du fichier XML en mémoire.
2) L’analyseur DOM est plus rapide que SAX car il permet d’accéder à tout le document XML en mémoire.
3) L'analyseur SAX dans Java convient mieux à un fichier XML volumineux qu'un analyseur DOM, car il ne nécessite pas beaucoup de mémoire.
4) L’analyseur DOM fonctionne sur le modèle d’objet document alors que SAX est un analyseur XML basé sur les événements.
En savoir plus: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz2uz1bJQqZ
SAX et DOM sont utilisés pour analyser le document XML. Les deux présentent des avantages et des inconvénients et peuvent être utilisés dans notre programmation en fonction de la situation.
SAXO:
Analyse noeud par noeud
Ne stocke pas le XML en mémoire
Nous ne pouvons pas insérer ou supprimer un nœud
Travers de haut en bas
DOM
Stocke l'intégralité du document XML en mémoire avant le traitement
Occupe plus de mémoire
Nous pouvons insérer ou supprimer des nœuds
Traverser dans n'importe quelle direction.
Si nous avons besoin de trouver un noeud et qu'il n'est pas nécessaire d'insérer ou de supprimer, nous pouvons utiliser SAX lui-même, sinon DOM à condition que nous ayons plus de mémoire.
1) L’analyseur DOM charge tout le document XML en mémoire alors que SAX ne charge qu’une petite partie du fichier XML en mémoire.
2) L’analyseur DOM est plus rapide que SAX car il permet d’accéder à tout le document XML en mémoire.
3) L'analyseur SAX dans Java convient mieux à un fichier XML volumineux qu'un analyseur DOM, car il ne nécessite pas beaucoup de mémoire.
4) L’analyseur DOM fonctionne sur le modèle d’objet document alors que SAX est un analyseur XML basé sur les événements.
En savoir plus: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz498y3vPFR