Quelle est la différence entre SAX et DOM?

J’ai lu des articles sur les parsingurs XML et j’ai découvert SAX et DOM .

SAX est basé sur des événements et DOM est un modèle d’arborescence – Je ne comprends pas les différences entre ces concepts.

D’après ce que j’ai compris, basé sur les événements signifie qu’une sorte d’événement arrive au nœud. Comme quand on clique sur un nœud particulier, il donne tous les sous-nœuds plutôt que de charger tous les nœuds en même temps. Mais dans le cas de l’parsing de DOM, il va charger tous les nœuds et créer le modèle d’arbre.

Est-ce que ma compréhension est correcte?

S’il vous plaît corrigez-moi si je me trompe ou expliquez-moi de manière plus simple le modèle basé sur les événements et l’arborescence.

Eh bien, vous êtes proche.

Dans SAX, les événements sont déclenchés lors de l’parsing du XML. Lorsque l’parsingur parsing le XML et rencontre un sharepoint départ (par exemple, ), 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 atteinte lors de l’parsing ( ), elle déclenche tagEnded . L’utilisation d’un parsingur SAX implique que vous devez 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’parsing. L’ensemble du XML est analysé et un arbre DOM (des nœuds dans le XML) est généré et renvoyé. Une fois analysé, l’utilisateur peut naviguer dans l’arborescence pour accéder aux différentes données précédemment intégrées dans les différents nœuds du XML.

En général, DOM est plus facile à utiliser, mais il ne permet pas d’parsingr l’intégralité du XML avant de pouvoir l’utiliser.

En quelques mots …

SAX ( S imple A PI for X ML): est un processeur basé sur stream. Vous n’avez qu’une infime partie de la mémoire à tout moment et vous “sniffez” le stream XML en implémentant le code de rappel pour des événements comme tagStarted() etc. Il n’utilise presque pas de mémoire, mais vous ne pouvez pas faire xpath ou traverse des arbres.

DOM (Objet Documentaire): Vous chargez le tout en mémoire – c’est un gros morceau de mémoire. Vous pouvez souffler de la mémoire avec des documents de taille moyenne. Mais vous pouvez utiliser xpath et parcourir l’arbre, etc.

Voici des mots plus simples:

DOM

  • Analyseur de modèle d’arbre (basé sur l’object) (arbre de noeuds).

  • DOM charge le fichier dans la mémoire, puis parsing le fichier.

  • Contient des contraintes de mémoire car il charge l’intégralité du fichier XML avant l’parsing.

  • DOM est en lecture et écriture (peut insérer ou supprimer des nœuds).

  • Si le contenu XML est petit, alors préférez le parseur DOM.

  • La recherche en amont et en aval est possible pour rechercher les balises et évaluer les informations contenues dans les balises. Cela facilite donc la navigation.

  • Plus lent à l’exécution.

SAXO

  • Analyseur basé sur les événements (séquence d’événements).

  • SAX parsing le fichier à mesure qu’il le lit, c’est-à-dire qu’il parsing le nœud par nœud.

  • Pas de contraintes 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 est impossible d’insérer ou de supprimer le noeud.

  • Utilisez l’parsingur SAX lorsque le contenu de la mémoire est important.

  • SAX lit le fichier XML de haut en bas et la navigation en arrière n’est pas possible.

  • Plus rapide à l’exécution.

Vous avez raison dans votre compréhension du modè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’arborescence que représente le document. Cela peut prendre du temps et de la mémoire, 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 (où la petite taille dépend de la puissance et de la mémoire de votre plate-forme) qui peuvent nécessiter des modifications et des interrogations différentes après leur chargement.

D’autre part, SAX est conçu pour gérer les entrées XML de toute taille. Au lieu que le cadre XML fasse le travail difficile pour déterminer la structure du document et préparer potentiellement beaucoup d’objects pour tous les nœuds, atsortingbuts, etc., SAX vous le laisse complètement.

En gros, il lit les entrées depuis le 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 atsortingbut dans la balise, rechercher du texte à l’intérieur d’un élément ou traverser une balise de fin.

SAX lit obstinément l’entrée et vous dit ce qu’elle voit de cette manière. Il vous appartient de conserver toutes les informations d’état dont vous avez besoin. Habituellement, cela signifie que vous allez créer une sorte de machine à états.

Bien que cette approche du traitement XML soit beaucoup plus fastidieuse, elle peut également être très puissante. Imaginez que vous vouliez simplement extraire les titres d’articles d’actualité d’un stream de blog. Si vous lisez ce XML en utilisant DOM, il chargera en mémoire tous les contenus de l’article, toutes les images, etc. contenues dans le XML, même si cela ne vous intéresse même 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 oui, vous savez que vous devez append le prochain événement “elementText”. Lorsque vous recevez l’appel à l’événement “endTag”, vous vérifiez à nouveau s’il s’agit de l’élément de fermeture du “titre”. Après cela, il vous suffit d’ignorer tous les autres éléments, jusqu’à ce que l’entrée se termine ou qu’un autre “startTag” nommé “title” apparaisse. Etc…

Vous pouvez lire les mégaoctets et les mégaoctets de XML de cette façon, en extrayant simplement la minuscule quantité de données dont vous avez besoin.

Le côté négatif de cette approche est bien sûr que vous devez vous consacrer davantage à la comptabilité, en fonction des données à 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 en main dans son ensemble.

Donc, en général, SAX est adapté pour combiner des quantités potentiellement importantes de données que vous recevez avec une “requête” spécifique en tête, mais vous n’avez pas besoin de les modifier, tandis que DOM vise à vous donner toute la flexibilité nécessaire pour modifier la structure et le contenu. de plus forte demande de ressources.

Vous comparez des pommes et des poires. SAX est un parsingur analysant les structures DOM sérialisées. Il y a beaucoup d’parsingurs différents et “event-based” fait référence à la méthode d’parsing.

Peut-être un petit récapitulatif est dans l’ordre:

  • Le modèle d’object 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 documents est constitué de nœuds , à savoir des nœuds d’ élément, d’atsortingbut et de texte (et quelques autres). Les nœuds ont des parents, des frères et des soeurs et des enfants et peuvent être parcourus, etc., tout ce que vous avez l’habitude de faire avec JavaScript (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, en utilisant 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 documents abstrait.

  • Pour qu’un ordinateur manipule, voire affiche, un arbre DOM à partir d’un fichier, il doit désérialiser ou parsingr le fichier et reconstruire l’arbre abstrait en mémoire. C’est là qu’intervient l’parsing

Nous arrivons maintenant à la nature des parsingurs. Une façon d’parsingr serait de lire l’intégralité du document et de créer récursivement une arborescence en mémoire, puis d’exposer l’intégralité du résultat à l’utilisateur. (Je suppose que vous pourriez appeler ces parsingurs “parsingurs DOM”.) Ce serait très pratique pour l’utilisateur (je pense que c’est ce que fait l’parsingur XML de PHP), mais il souffre de problèmes d’évolutivité et devient très coûteux pour les documents volumineux.

D’autre part, l’parsing basée sur les événements , comme le fait SAX, examine le fichier linéairement et effectue simplement des rappels à l’utilisateur chaque fois qu’il rencontre une donnée structurelle, comme “cet élément a démarré”, “cet élément s’est terminé”. , “du texte ici”, etc. Cela a l’avantage de pouvoir durer éternellement sans se soucier de la taille du fichier d’entrée, mais c’est beaucoup moins grave car l’utilisateur doit faire tout le travail de traitement (en fournissant rappels). Pour revenir à votre question initiale, le terme “basé sur des événements” fait référence aux événements d’parsing syntaxique que l’parsingur déclenche lorsqu’il traverse le fichier XML.

L’ article de Wikipedia contient de nombreux détails sur les étapes de l’parsing SAX.

Je fournirai une réponse générale à cette question:

Réponse aux questions

Pourquoi avons-nous besoin d’un parsingur XML?

Nous avons besoin d’un parsingur XML parce que nous ne voulons pas tout faire dans notre application à partir de rien, et nous avons besoin de programmes “assistants” ou de bibliothèques pour faire quelque chose de très bas niveau mais très nécessaire pour nous. Ces éléments de bas niveau mais nécessaires incluent la vérification de la forme, la validation du document par rapport à sa DTD ou à son schéma (uniquement pour la validation des parsingurs), la résolution des références de caractères, la compréhension des sections CDATA, etc. Les parsingurs XML ne sont que des programmes “d’assistance” et ils feront tous ces travaux. Avec XML parser, nous sums à l’abri de beaucoup de ces complexités et nous pourrions nous concentrer sur la programmation à haut niveau grâce aux API implémentées par les parsingurs, et gagner ainsi en efficacité de programmation.

Lequel est le meilleur, SAX ou DOM?

Les parsingurs SAX et DOM ont tous deux leurs avantages et inconvénients. Le meilleur devrait dépendre des caractéristiques de votre application (veuillez vous référer aux questions ci-dessous).

Quel parsingur peut obtenir une meilleure vitesse, des parsingurs DOM ou SAX?

L’parsingur SAX peut être plus rapide.

Quelle est la différence entre les API basées sur arborescence et les API basées sur les événements?

Une API basée sur une arborescence est centrée autour d’une arborescence et fournit donc des interfaces sur les composants d’une arborescence (qui est un document DOM) tels que l’interface de document, l’interface de nœud, l’interface NodeList, l’interface Element, etc. En revanche, une API basée sur des é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 parsingur DOM et un parsingur SAX?

Les parsingurs DOM et les parsingurs SAX fonctionnent de différentes manières:

  • Un parsingur DOM crée une arborescence en mémoire à partir du document d’entrée, puis attend les demandes du client. Mais un parsingur 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 lorsqu’il lit le document en entrée. UNE

  • L’parsingur DOM sert toujours l’application cliente avec le document entier, quel que soit le besoin réel du client. Mais un parsingur SAX sert toujours l’application cliente uniquement avec des parties du document à un moment donné.

  • Avec un parsingur DOM, les appels de méthode dans l’application client doivent être explicites et former une sorte de chaîne. Mais avec SAX, certaines méthodes (généralement remplacées par le cient) seront invoquées automatiquement (implicitement) d’une manière appelée “callback” lorsque certains événements se produisent. Il n’est pas nécessaire que ces méthodes soient appelées explicitement par le client, bien que nous puissions les appeler explicitement.

Comment pouvons-nous décider quel parsingur est bon?

Idéalement, un bon parsingur devrait être rapide (efficace dans le temps), efficace en termes d’espace, riche en fonctionnalités et facile à utiliser. Mais en réalité, aucun parsingur principal ne possède toutes ces fonctionnalités en même temps. Par exemple, un parsingur DOM est riche en fonctionnalités (car il crée un arbre DOM en mémoire et vous permet d’accéder à n’importe quelle partie du document et de modifier l’arborescence DOM), mais l’espace est insuffisant lorsque le document est volumineux. , et cela prend un peu de temps pour apprendre à travailler avec elle. Un parsingur SAX, cependant, est beaucoup plus efficace dans le cas d’un document 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 sharepoint vue de la fonctionnalité, elle fournit moins de fonctions, ce qui signifie que les utilisateurs eux-mêmes doivent en prendre davantage en charge, par exemple en créant leurs propres structures de données. Au fait, qu’est-ce qu’un bon parsingur? Je pense que la réponse dépend vraiment des caractéristiques de votre application.

Quelles sont certaines des applications du monde réel où l’utilisation de l’parsingur syntaxique SAX est avantageuse que l’utilisation d’un parsingur DOM et vice versa? Quelles sont les applications habituelles pour un parsingur DOM et pour un parsingur SAX?

Dans les cas suivants, utiliser l’parsingur SAX est avantageux que d’utiliser l’parsingur DOM.

  • Le document d’entrée est trop gros pour la mémoire disponible (en fait, dans ce cas, SAX est votre seul choix)
  • Vous pouvez traiter le document en petits morceaux contigus d’entrée. Vous n’avez pas besoin de l’intégralité du document avant de pouvoir effectuer un travail utile
  • Vous voulez juste utiliser l’parsingur pour extraire les informations qui vous intéressent et tout votre calcul sera entièrement basé 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. De ce sharepoint vue, je pense que la probabilité d’utiliser un parsingur DOM est inférieure à celle de l’utilisation d’un parsingur SAX.

Dans les cas suivants, l’utilisation de l’parsingur DOM est avantageuse que l’utilisation de l’parsingur SAX.

  • Votre application doit accéder à des parties très distinctes du document 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 resockets.
  • Votre application doit stocker le document pendant une période de temps significative grâce à de nombreux appels de méthodes.

Exemple (utilisez un parsingur DOM ou un parsingur SAX?):

Supposons qu’un instructeur ait un document XML contenant toutes les informations personnelles des étudiants ainsi que les points que ses étudiants ont obtenus dans sa classe, et il atsortingbue maintenant des notes finales aux étudiants utilisant une application. Ce qu’il veut produire, c’est une liste avec le SSN et les notes. Nous supposons également que dans son application, l’instructeur n’utilise aucune structure de données telle que des tableaux pour stocker les informations personnelles de l’étudiant et les points. Si l’instructeur décide de donner un A à ceux qui ont obtenu la classe moyenne ou supérieure et de donner le B aux autres, alors il serait préférable d’utiliser un parsingur DOM dans son application. La raison en est qu’il n’a aucun moyen de savoir quelle est la moyenne de la classe avant que le document entier ne soit traité. Ce qu’il doit probablement faire dans son application, c’est d’abord parcourir tous les points des élèves et calculer la moyenne, puis parcourir à nouveau le document et atsortingbuer la note finale à chaque élève en comparant les points obtenus à la moyenne de la classe. . Si, toutefois, l’instructeur adopte une politique de notation telle que les étudiants qui ont obtenu 90 points ou plus se voient atsortingbuer un A et que les autres se voient atsortingbuer un B, alors il ferait probablement un parsingur SAX. La raison en est que, pour atsortingbuer à chaque élève une note finale, il n’a pas besoin d’attendre que l’ensemble du document soit traité. Il pourrait immédiatement atsortingbuer une note à un élève une fois que l’parsingur SAX lit la note de cet élève. Dans l’parsing ci-dessus, nous avons supposé que l’instructeur n’avait créé aucune structure de données. Que se passe-t-il s’il crée sa propre structure de données, par exemple 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 de la mémoire et du temps, tout en faisant le travail. Eh bien, une autre considération sur cet exemple. Que se passe-t-il si ce que l’instructeur veut faire est de ne pas imprimer une liste, mais de sauvegarder le document original avec la note de chaque élève à jour? Dans ce cas, un parsingur DOM devrait être un meilleur choix, quelle que soit la politique de notation 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.-à-d. Définir la valeur sur le nœud «grade»), puis enregistrer l’arbre modifié complet. S’il choisit d’utiliser un parsingur SAX au lieu d’un parsingur 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.-à-d. X, y et rayon) ainsi qu’un atsortingbut de couleur. Un exemple de document est donné ci-dessous:

        ]>   20 20 20   40 40 20   

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 Ssortingng color[] = new Ssortingng[1000]; // colors of the circles public static void main(Ssortingng[] 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(); // resortingeve all info about the circles for(int i=0; i 0) color[i]=(Ssortingng)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 

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 Ssortingng color[] = new Ssortingng[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(Ssortingng[] 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(Ssortingng uri, Ssortingng localName, Ssortingng rawName, Atsortingbutes atsortingbutes) { if(rawName.equals("circle")) // if a circle element is seen color[numberOfCircles]=atsortingbutes.getValue("color"); // get the color atsortingbute else if(rawName.equals("x")) // if ax element is seen set the flag as 1 flagX=1; else if(rawName.equals("y")) // if ay 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(Ssortingng uri, Ssortingng localName, Ssortingng 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) { Ssortingng characterData = (new Ssortingng(characters,start,length)).sortingm(); // get the text if(flagX==1) { // indicate this text is for  element x[numberOfCircles] = Integer.parseInt(characterData); flagX=0; } else if(flagY==1) { // indicate this text is for  element y[numberOfCircles] = Integer.parseInt(characterData); flagY=0; } else if(flagR==1) { // indicate this text is for  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 

En pratique: book.xml

   Everyday Italian Giada De Laurentiis 2005 30.00   
  • DOM présente le document XML comme l’ arborescence suivante en mémoire.
  • DOM est la norme W3C.
  • L’parsingur DOM fonctionne sur le modèle d’object de document.
  • DOM occupe plus de mémoire, de préférence pour les petits documents XML
  • DOM est facile à naviguer vers l’avant ou l’arrière.

entrer la description de l'image ici


  • SAX présente le document XML en tant qu’événement comme un start element:abc , end element:abc .
  • SAX n’est pas le standard W3C, il a été développé par un groupe de développeurs.
  • SAX n’utilise pas de mémoire, préférable pour les documents XML volumineux.
  • La navigation arrière n’est pas possible car elle traite les documents de manière séquentielle.
  • L’événement arrive à un nœud / élément et il donne tous les sous-nœuds (nodus latin, «nœud»).

Ce document XML, lorsqu’il est transmis par un parsingur SAX, générera une séquence d’événements tels que les suivants :

 start element: bookstore start element: book with an atsortingbute category equal to cooking start element: title with an atsortingbute lang equal to en Text node, with data equal to Everyday Italian .... end element: title ..... end element: book end element: bookstore 

DOM représente le modèle d’object de document et représente un document XML au format d’arborescence, chaque élément représentant des twigs d’arbre. DOM Parser crée une représentation In Arborescence du fichier XML, puis l’parsing, de sorte qu’il nécessite plus de mémoire et qu’il est conseillé d’augmenter la taille du segment de mémoire du DOM afin d’éviter Java.lang.OutOfMemoryError: espace de stockage Java. Analyser un fichier XML en utilisant un parsingur DOM est assez rapide si le fichier XML est petit mais si vous essayez de lire un fichier XML volumineux en utilisant un parsingur DOM, il y a plus de chances que cela prenne beaucoup de temps. Il faut beaucoup de mémoire pour créer XML Dom Tree. Java fournit un support d’parsing DOM et vous pouvez parsingr les fichiers XML en Java en utilisant l’parsingur DOM. Les classes DOM sont dans le package w3c.dom tandis que DOM Parser pour Java est dans le package JAXP (Java API for XML Parsing).

Analyseur XML SAX en Java

SAX est synonyme d’API simple pour l’parsing XML. Il s’agit d’une parsing syntaxique XML basée sur des événements et elle parsing pas à pas le fichier XML si adapté aux fichiers XML volumineux. SAX XML Parser déclenche un événement lorsqu’il a rencontré l’ouverture d’une balise, d’un élément ou d’un atsortingbut et que l’parsing fonctionne en conséquence. Il est recommandé d’utiliser l’parsingur XML SAX pour parsingr des fichiers XML volumineux en Java, car il ne nécessite pas de charger un fichier XML complet en Java et il peut lire un gros fichier XML en petites parties. Java prend en charge l’parsingur syntaxique SAX et vous pouvez parsingr n’importe quel fichier xml en Java à l’aide de SAX Parser, j’ai couvert l’exemple de la lecture d’un fichier XML à l’aide de SAX Parser ici. Un inconvénient de l’utilisation de SAX Parser dans Java est que la lecture d’un fichier XML en Java à l’aide de SAX Parser nécessite plus de code en comparaison de DOM Parser.

Différence entre DOM et SAX XML Parser

Voici quelques différences de haut niveau entre l’parsingur DOM et l’parsingur SAX en Java:

1) L’parsingur DOM charge en mémoire tout le document XML, tandis que SAX ne charge qu’une petite partie du fichier XML en mémoire.

2) L’parsingur de DOM est plus rapide que SAX car il accède à tout le document XML en mémoire.

3) L’parsingur syntaxique SAX en Java convient mieux à un fichier XML volumineux qu’à un parsingur DOM car il ne nécessite pas beaucoup de mémoire.

4) L’parsingur DOM fonctionne sur le modèle d’object de document tandis que SAX est un parsingur XML basé sur des événements.

En savoir plus: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz2uz1bJQqZ

SAX et DOM sont tous deux utilisés pour parsingr le document XML. Les deux ont des avantages et des inconvénients et peuvent être utilisés dans notre programmation en fonction de la situation

SAXO:

  1. Analyse le nœud par nœud

  2. Ne stocke pas le XML en mémoire

  3. Nous ne pouvons pas insérer ou supprimer un nœud

  4. Traversée de haut en bas

DOM

  1. Stocke l’intégralité du document XML en mémoire avant le traitement

  2. Occupe plus de mémoire

  3. Nous pouvons insérer ou supprimer des nœuds

  4. Traverser dans n’importe quelle direction.

Si nous devons trouver un nœud et n’a pas besoin d’insérer ou de supprimer, nous pouvons aller avec SAX lui-même sinon DOM, à condition que nous ayons plus de mémoire.

1) L’parsingur DOM charge un document XML entier en mémoire, tandis que SAX ne charge qu’une petite partie du fichier XML en mémoire.

2) Le parseur DOM est plus rapide que SAX car il accède à tout le document XML en mémoire.

3) L’parsingur syntaxique SAX en Java convient mieux à un fichier XML volumineux qu’à un parsingur DOM car il ne nécessite pas beaucoup de mémoire.

4) L’parsingur DOM fonctionne sur le modèle d’object de document tandis que SAX est un parsingur XML basé sur des événements.

En savoir plus: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz498y3vPFR