Quelle est la différence entre SAX et DOM?

En quelques mots...

SAX (Smise UNPI pour XML): Est un flux à base de processeur. Vous n'avez qu'une infime partie de la mémoire à tout moment et vous "renifler" le flux de données XML par la mise en œuvre de rappel code pour des événements comme tagStarted() etc. Il n'utilise presque pas de mémoire, mais vous ne pouvez pas faire "DOM" choses", comme l'utilisation de xpath ou parcourir les arbres.

DOM (Document Oobjet Model): Vous chargez le tout dans la mémoire - c'est un grand dévoreur de mémoire. Vous pouvez souffler la mémoire avec la même taille moyenne des documents. Mais vous pouvez utiliser xpath et parcourir l'arbre etc.

Vous sont correctes dans votre compréhension de la DOM base de modèle. Le fichier XML sera chargé comme un tout et tout son contenu sera construite comme une représentation en mémoire de l'arbre du document représente. Cela peut prendre du temps et de la mémoire du temps, en fonction de la taille du fichier d'entrée est. L'avantage de cette approche est que vous pouvez facilement requête de toute partie du document, et de manipuler librement tous les nœuds de l'arbre.

Les DOM approche est généralement utilisée pour de petites structures XML (où les petites dépend de la puissance et de la mémoire de votre plate-forme a), qui peuvent avoir besoin d'être modifié et interrogés de différentes façons, une fois qu'ils ont été chargés.

SAX sur l'autre main est conçu pour traiter le XML d'entrée de pratiquement n'importe quelle taille. Au lieu de le framework XML de faire le travail dur pour vous dans la compréhension de la structure du document et la préparation potentiellement un grand nombre d'objets pour tous les nœuds, les attributs, etc., SAX complètement les feuilles que vous.

Ce qu'il fait est de lire les commentaires de la haut et invoquer des méthodes de rappel que vous fournissez lors de certains "événements" de se produire. Un événement pourrait être frappé dans une balise d'ouverture, un attribut dans la balise, recherche de texte à l'intérieur d'un élément ou à venir à travers une balise de fin.

SAX obstinément lit l'entrée et vous dit ce qu'il voit dans ce mode. C'est à vous de conserver tous les renseignements dont vous avez besoin. Cela signifie généralement que vous construisez une sorte de machine d'état.

Bien que cette approche de traitement XML est beaucoup plus fastidieux, il peut être très puissant, trop. Imaginez que vous voulez il suffit d'extraire les titres des articles de presse à partir d'un blog d'alimentation. Si vous lisez ce document XML à l'aide de DOM il serait de charger tout le contenu de l'article, toutes les images etc. qui sont contenues dans le fichier XML en mémoire, même si vous n'êtes pas intéressé par elle.

Avec SAX, vous pouvez simplement vérifier si le nom de l'élément est e. g.) "titre" à chaque fois que votre "startTag de l'événement" la méthode est appelée. Si oui, vous savez que vous avez besoin d'ajouter que la prochaine "elementText" événement offre à vous. Lorsque vous recevez le "endTag" cas d'appel, vous vérifiez de nouveau si ce n'est l'élément de fermeture de la "titre". Après cela, il suffit d'ignorer tous les autres éléments, jusqu'à ce que l'entrée se termine, ou d'une autre "startTag" avec un nom de "titre" vient le long. Et ainsi de suite...

Vous avez pu lire au travers de mégaoctets et mégaoctets de XML de cette manière, l'extraction de la petite quantité de données dont vous avez besoin.

Le côté négatif de cette approche est, bien sûr, que vous avez besoin de faire beaucoup plus de livre-rester soi-même, selon ce que les données dont vous avez besoin pour l'extraction et le degré de complexité de la structure XML. En outre, vous ne peut naturellement pas modifier la structure de l'arborescence XML, car vous ne l'avez dans la main comme un tout.

Donc, en général, SAX est adapté pour le peignage à travers potentiellement de grandes quantités de données que vous recevez avec une "requête" à l'esprit, mais n'a pas besoin de modifier, tandis que DOM est plus destiné à vous donner une totale flexibilité dans l'évolution de la structure et du contenu, au détriment de la hausse de la demande de ressources.

Je vais donner des Q&A-orienté de réponse à cette question:

Répondre à des Questions

Pourquoi avons-nous besoin de parser XML?

Nous avons besoin de parser XML parce que nous ne voulons pas faire tout en notre application à partir de zéro, et nous avons besoin d'une "aide" de programmes ou de bibliothèques pour faire quelque chose de très bas niveau, mais très nécessaire pour nous. Ces bas-niveau, mais les choses nécessaires inclure de vérifier le bien-formation, de la validation du document par rapport à sa DTD ou un schéma (juste pour la validation des parsers), la résolution de référence de caractère, la compréhension des sections CDATA, et ainsi de suite. Parseurs XML sont à "l'aide" des programmes et qu'ils vont faire tous ces travaux. Avec analyseur XML, nous sommes à l'abri de beaucoup de ces difficultés et de nous concentrer sur nous-mêmes juste de programmation de haut niveau par le biais de l'API est mis en œuvre par les analyseurs syntaxiques, et ainsi gagner de la programmation de l'efficacité.

Lequel est le mieux, SAX ou DOM ?

Les deux SAX et DOM parser ont leurs avantages et leurs inconvénients. Quel est le meilleur doit dépendre des caractéristiques de votre application (veuillez vous référer aux quelques questions ci-dessous).

Analyseur peut améliorer la vitesse, DOM ou SAX analyseurs?

Analyseur SAX pouvez obtenir la meilleure vitesse.

Quelle est la différence entre des arbres, de l'API et de l'événement en fonction de l'API?

Un arbre basé sur l'API est centrée autour d'une structure de l'arbre et, par conséquent, fournit des interfaces des composants de l'arbre (qui est un document DOM) comme Document d'interface,interface de Nœud, NodeList interface, interface de l'Élément, l'Attribut de l'interface et ainsi de suite. Par contraste, toutefois, un événement basé sur l'API fournit des interfaces pour les maîtres-chiens. Il y a quatre gestionnaire d'interfaces, l'interface ContentHandler, DTDHandler interface, EntityResolver interface et ErrorHandler interface.

Quelle est la différence entre un DOM et l'Analyseur de Parser SAX?

Parseurs DOM et SAX analyseurs de travail de différentes façons:

• Un DOM parser crée une arborescence dans la mémoire à partir de l'entrée
  le document, puis attend les demandes du client. Mais un parser SAX
  ne crée pas de structure interne. Au lieu de cela, il prend l'
  les occurrences de composants d'un document d'entrée comme des événements, et dit
  le client de ce qu'il lit comme on lit à travers le document d'entrée. Un

• DOM parser est toujours au service de l'application client avec l'ensemble de la
  document peu importe combien est réellement nécessaire par le client. Mais un
  Analyseur SAX sert le client demande toujours seulement avec des pièces de
  le document à un moment donné.

• Avec DOM parser, les appels de méthode dans
  application client doivent être explicites et forme une sorte de chaîne. Mais
  avec le SAX, certaines méthodes de certains (généralement écrasé par le client) sera
  être invoquée automatiquement (implicitement) d'une manière qui est appelé
  "callback" lorsque certains événements se produisent. Ces méthodes n'ont pas
  pour être appelé explicitement par le client, mais nous pourrions les appeler
  explicitement.

Comment pouvons-nous décider sur le analyseur est bon?

Idéalement un bon analyseur doit être rapide (efficace),de l'espace efficace, riche en fonctionnalités et facile à utiliser. Mais en réalité, aucun des principaux analyseurs ont toutes ces caractéristiques en même temps. Par exemple, un DOM Parser est riche en fonctionnalité (parce qu'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 de l'espace lorsque le document est énorme, et il faut un peu de temps à apprendre comment travailler avec elle. Un Analyseur SAX, cependant, est beaucoup plus efficace de l'espace en cas de gros document d'entrée (car il ne crée pas de structure interne). Qui plus est, il fonctionne plus rapidement et est plus facile à apprendre que DOM Parser parce que son API est très simple. Mais à partir de la fonctionnalité de point de vue, il offre moins de fonctions, ce qui signifie que les utilisateurs eux-mêmes ont à prendre soin de plus, comme la création de leurs propres structures de données. Par la manière, ce qui est 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 où l'utilisation d'analyseur SAX est
avantageux que l'aide DOM parser et vice-versa? Quels en sont les
demande de DOM et l'analyseur de parser SAX?

Dans les cas suivants, à l'aide de parser SAX est plus avantageux qu'à l'aide de DOM parser.

• Le document d'entrée est trop grande pour la mémoire disponible (en fait, dans ce cas SAX est votre seul choix)
• Vous pouvez traiter le document en petits blocs contigus de l'entrée. Vous n'avez pas besoin de l'ensemble du document avant de vous peut faire un travail utile
• Vous voulez juste utiliser l'analyseur pour extraire l'information d'intérêt, et tous vos calcul sera entièrement basé sur les structures de données créé par vous-même. En fait, dans la plupart de nos applications, nous avons créer des structures de données de notre propre qui ne sont généralement pas aussi compliqué que l'arborescence DOM. À partir de ce sens, je pense, la possibilité de l'utilisation d'un DOM parser est inférieure à celle de l'aide d'un analyseur SAX.

Dans les cas suivants, à l'aide de DOM parser est plus avantageux qu'à l'aide de parser SAX.

• Votre application a besoin d'accéder largement séparément les parties du document en même temps.
• Votre application peut probablement utiliser une structure de données interne qui est presque aussi compliqué que le document lui-même.
• Votre demande de modifier le document à plusieurs reprises.
• Votre demande pour stocker le document d'une quantité importante de temps grâce à de nombreux appels de méthode.

Exemple (Utilisation d'un analyseur de modèle DOM ou SAX parser?):

Supposons que le professeur dispose d'un document XML contenant toutes les informations personnelles des étudiants aussi bien que les points de son les étudiants de sa classe, et il est maintenant en attribuant des notes finales des élèves à l'aide d'une application. Ce qu'il veut, pour produire, une liste avec le SSN et les grades. Aussi, nous supposons que, dans sa demande, l'instructeur de l'utilisation pas de structure de données tels que des tableaux pour stocker l'élève des renseignements personnels et les points.
Si l'enseignant décide de donner Un de ceux qui a gagné la classe moyenne ou au-dessus, et de donner un B pour les autres, alors il vaut mieux utiliser un DOM parser dans son application. La raison en est qu'il n'a aucun moyen de savoir de combien est la classe moyenne avant que l'ensemble du document est traitée. Ce qu'il a probablement besoin de le faire dans son application, est d'abord de regarder à travers tous les étudiants de points et de calculer la moyenne, et puis regardez à travers le document de nouveau et d'attribuer la note finale de chaque étudiant en comparant les points qu'il a gagné à la classe moyenne.
Si, toutefois, l'enseignant adopte une telle politique d'évaluation que les étudiants qui ont obtenu 90 points ou plus, sont affectés à Un et les autres sont affectés B, alors probablement qu'il vaut mieux utiliser un parser SAX. La raison en est, pour assigner à chaque élève une note finale, il n'a pas besoin d'attendre pour l'ensemble du document à traiter. Il pourrait immédiatement attribuer un grade à un étudiant une fois que l'analyseur SAX lit la note de l'élève.
Dans l'analyse ci-dessus, nous avons supposé que l'instructeur n'a créé aucune structure de données de son propre. Si il crée sa propre structure de données, tel qu'un tableau de chaînes de caractères pour stocker le SSN et un tableau d'entiers à sto re les points ? Dans ce cas, je pense que SAX est un meilleur choix, avant ce qui pourrait sauver à la fois la mémoire et du temps en tant que bien, mais faire le travail.
Eh bien, on a plus de considération sur cet exemple. Si ce que l'instructeur veut faire, c'est de ne pas imprimer une liste, mais pour enregistrer le document d'origine est de retour avec le grade de chaque élève à jour ? Dans ce cas, un DOM parser doit être un meilleur choix, peu importe ce que la politique d'évaluation, il est en train d'adopter. Il n'a pas besoin de créer une structure de données de son propre. Ce qu'il faut faire, c'est d'abord de modifier l'arborescence du DOM (c'est à dire, réglez la valeur de la "qualité" nœud) puis sauvegarder l'ensemble de l'arbre modifié. S'il choisit d'utiliser un parser SAX au lieu d'un DOM parser, alors dans ce cas il doit créer une structure de données qui est presque aussi compliqué que de faire une arborescence DOM avant qu'il puisse faire le travail.

Un Exemple

Énoncé du problème: Écrire un programme Java pour extraire tous les
informations sur les cercles qui sont des éléments dans un document XML donné.
Nous supposons que chaque cercle élément a trois éléments enfants(c, 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);
         }
   }


}

DOM est synonyme de Modèle d'Objet de Document et ce qu'il représente d'un Document XML en forme d'arbre dont chaque élément représente les branches des arbres. DOM Parser crée une Mémoire de représentation en arborescence du fichier XML, puis de l'analyse, de sorte qu'il exige plus de mémoire et sa conseillé d'avoir une augmentation de la taille du tas de DOM parser afin d'éviter de Java.lang.OutOfMemoryError:java heap space . L'analyse du fichier XML à l'aide de DOM parser est assez rapide si le fichier XML est petite, mais si vous essayez de lire un gros fichier XML à l'aide de DOM parser il n'y a plus de chances que cela va prendre beaucoup de temps ou peut même ne pas être en mesure de charger complètement tout simplement parce qu'il nécessite beaucoup de mémoire pour créer XML Arborescence Dom. Java fournit un soutien DOM Analyse et vous pouvez convertir des fichiers XML en Java à l'aide de DOM parser. DOM les classes sont en w3c.dom package DOM Parser for Java est en JAXP (Java API for XML Parsing) package.

SAX Parser XML en Java

SAX est pour Simple API for XML Parsing. C'est un événement à partir de l'Analyse XML et analyser fichier XML, étape par étape, de manière beaucoup plus adapté pour les gros Fichiers XML. SAX Parser XML feux de l'événement quand il a rencontré la balise d'ouverture de l'élément ou de l'attribut et de l'analyse des œuvres en conséquence. Il est recommandé d'utiliser SAX parser XML pour l'analyse des fichiers xml en Java, car il n'a pas besoin de charger un fichier XML en Java et il peut lire un gros fichier XML dans de petites pièces. Java fournit un support pour parser SAX et vous pouvez convertir tout fichier xml en Java à l'aide d'Analyseur SAX, j'ai couvert exemple de lecture de fichier xml Parser SAX ici. Un inconvénient de l'utilisation d'Analyseur SAX en java est que la lecture d'un fichier XML en Java à l'aide d'Analyseur SAX nécessite plus de code en comparaison de DOM Parser.

Différence entre les DOM et SAX Parser XML

Voici quelques différences de niveau entre les DOM et l'analyseur de Parser SAX en Java:

1) DOM analyseur de charge de tout document xml en mémoire lors d'un SAX charge uniquement une petite partie du fichier XML en mémoire.

2) DOM parser est plus rapide que SAX, car il accès à tout document XML en mémoire.

3) analyseur SAX en Java est mieux adapté pour les gros fichier XML que DOM Parser, car il n'a pas besoin de beaucoup de mémoire.

4) DOM analyseur fonctionne sur le Modèle d'Objet de Document tout en SAX est un événement basé sur xml parser.

Lire la suite: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz2uz1bJQqZ

1) DOM analyseur de charge de tout document XML en mémoire lors d'un SAX charge uniquement une petite partie du fichier XML en mémoire.

2) DOM parser est plus rapide que SAX, car il accès à tout document XML en mémoire.

3) analyseur SAX en Java est mieux adapté pour les gros fichier XML que DOM Parser, car il n'a pas besoin de beaucoup de mémoire.

4) DOM analyseur fonctionne sur le Modèle d'Objet de Document tout en SAX est un événement basé sur XML parser.

Lire la suite: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz498y3vPFR