Quelle est la différence entre SAX et DOM?

J'ai lu quelques 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 d'arbre - je ne comprends pas les différences entre ces concepts.

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

Ma compréhension est-elle correcte?

Veuillez me corriger si je me trompe ou m'expliquer de manière plus simple le modèle basé sur les événements et l'arborescence.

Eh bien, tu es proche.

Dans SAX, les événements sont déclenchés lorsque le XML est analysé . Lorsque l'analyseur analyse le XML et rencontre une balise commençant (par exemple <something>), il déclenche l' tagStartedévénement (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>), elle se déclenche tagEnded. L'utilisation d'un analyseur 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'analyse. Le XML entier est analysé et une arborescence DOM (des nœuds dans le XML) est générée et renvoyée. 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 a une surcharge d'analyse de tout le XML avant de pouvoir commencer à l'utiliser.

En quelques mots ...

SAX ( S imple A PI for X ML): est un processeur basé sur le flux. Vous n'avez qu'une petite partie en mémoire à tout moment et vous "reniflez" le flux XML en implémentant du code de rappel pour des événements comme tagStarted()etc. Il n'utilise presque pas de mémoire, mais vous ne pouvez pas faire de choses "DOM", comme utiliser xpath ou traverse des arbres.

DOM ( D ocument O bjet M odèle): Vous chargez le tout en mémoire - c'est un porc de mémoire massif. Vous pouvez souffler de la mémoire avec des documents même de taille moyenne. Mais vous pouvez utiliser xpath et parcourir l'arbre, etc.

Ici en termes plus simples:

DOM

• Analyseur de modèle d'arbre (basé sur les objets) (arbre de nœuds).

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

• A 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 l'analyseur DOM.

• Une recherche en arrière et en avant est possible pour rechercher les balises et évaluer les informations à l'intérieur des balises. Cela donne donc la facilité de navigation.

• Plus lent au moment de l'exécution.

SAXO

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

• SAX analyse le fichier tel qu'il le lit, c'est-à-dire analyse nœud par nœud.

• 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 nœud.

• 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 vers l'arrière n'est pas possible.

• Plus rapide au moment de l'exécution.

Vous avez raison dans votre compréhension du modèle basé sur 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 le document représente. Cela peut prendre du temps et de la mémoire, selon 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 dépend de la puissance et de la mémoire de votre plate-forme) qui peuvent avoir besoin d'être modifiées et interrogées de différentes manières une fois qu'elles ont été chargées.

SAX, d'autre part, est conçu pour gérer l'entrée XML de pratiquement n'importe quelle taille. Au lieu que le cadre XML fasse le travail difficile pour vous en déterminant la structure du document et en préparant potentiellement beaucoup d'objets pour tous les nœuds, attributs, etc., SAX vous laisse complètement cela.

Ce qu'il fait est essentiellement de lire l'entrée par le haut et d'appeler les méthodes de rappel que vous fournissez lorsque certains "événements" se produisent. Un événement peut frapper une balise d'ouverture, un attribut dans la balise, trouver du texte à l'intérieur d'un élément ou tomber sur une balise de fin.

SAX lit obstinément l'entrée et vous dit ce qu'il voit de cette façon. C'est à vous de conserver toutes les informations d'état dont vous avez besoin. Habituellement, cela signifie que vous construirez 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 souhaitiez simplement extraire les titres des articles de presse d'un blog. Si vous lisez ce XML en utilisant DOM, il chargerait tout le contenu de l'article, toutes les images, etc. qui sont contenues dans le XML en mémoire, 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 ajouter tout ce que le prochain événement "elementText" vous offrira. Lorsque vous recevez l'appel d'événement «endTag», vous vérifiez à nouveau s'il s'agit de l'élément de fermeture du «titre». Après cela, vous ignorez simplement tous les autres éléments, jusqu'à ce que l'entrée se termine ou qu'un autre "startTag" portant le nom de "title" apparaisse. Etc...

Vous pouvez lire des mégaoctets et des mégaoctets de XML de cette façon, en extrayant simplement la petite quantité 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, selon les données que vous devez extraire et 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 passer en revue les quantités potentiellement importantes de données que vous recevez avec une "requête" spécifique à l'esprit, mais n'a pas besoin d'être modifiée, tandis que DOM vise plus à vous donner une flexibilité totale dans le changement de structure et de contenu, au détriment de la demande accrue 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 différents et "basé sur les événements" fait référence à la méthode d'analyse.

Peut-être qu'un petit récapitulatif s'impose:

• 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 et arborescente; une arborescence de documents se compose 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 sœurs et des enfants et peuvent être parcourus, etc., tout ce que vous avez l'habitude de faire de 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, en utilisant un langage de balisage comme HTML ou XML. Un fichier HTML ou XML contient ainsi une version "écrite" ou "aplatie" d'une arborescence de documents abstraits.

• Pour qu'un ordinateur manipule ou même affiche une arborescence DOM à partir d'un fichier, il doit désérialiser ou analyser le fichier et reconstruire l'arborescence abstraite en mémoire. C'est là qu'intervient l'analyse.

Nous arrivons maintenant à la nature des analyseurs. Une façon d'analyser serait de lire l'intégralité du document et de créer de manière récursive une structure arborescente en mémoire, et enfin d'exposer le résultat entier à l'utilisateur. (Je suppose que vous pourriez appeler ces analyseurs "analyseurs DOM".) Ce 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 cher pour les gros documents.

D'un autre côté, l' analyse basée sur les événements , comme le fait SAX, examine le fichier de manière linéaire et effectue simplement des rappels à l'utilisateur chaque fois qu'il rencontre une donnée structurelle, comme "cet élément a commencé", "cet élément s'est terminé" , "du texte ici", etc. Cela a l'avantage de pouvoir durer indéfiniment sans se soucier de la taille du fichier d'entrée, mais c'est beaucoup plus bas car cela oblige l'utilisateur à effectuer tout le travail de traitement réel (en fournissant rappels). Pour revenir à votre question d'origine, le terme "basé sur des événements" fait référence aux événements d'analyse que l'analyseur déclenche lors de sa traversée du fichier XML.

L' article de Wikipedia contient de nombreux détails sur les étapes de l'analyse 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 de l'analyseur XML parce que nous ne voulons pas tout faire dans notre application à partir de zéro, et nous avons besoin de quelques programmes ou bibliothèques "d'aide" pour faire quelque chose de très bas niveau mais très nécessaire pour nous. Ces choses de bas niveau mais nécessaires comprennent la vérification de la bonne forme, la validation du document par rapport à sa DTD ou son schéma (juste pour valider les analyseurs), la résolution de la référence de caractère, la compréhension des sections CDATA, etc. Les analyseurs XML ne sont que de tels programmes "auxiliaires" et ils feront tous ces travaux. Avec l'analyseur XML, nous sommes protégés de beaucoup de ces complexités et nous pourrions nous concentrer uniquement sur la programmation de haut niveau grâce aux API implémentées par les analyseurs, et ainsi gagner en efficacité de programmation.

Lequel est le meilleur, SAX ou DOM?

Les analyseurs SAX et DOM 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, analyseurs DOM ou SAX?

L'analyseur SAX peut obtenir une meilleure vitesse.

Quelle est la différence entre une API basée sur un arbre et une API basée sur un événement?

Une API basée sur l'arborescence est centrée sur une structure arborescente et fournit donc des interfaces sur les composants d'une arborescence (qui est un document DOM) tels que l'interface Document, l'interface Node, l'interface NodeList, l'interface Element, l'interface Attr, etc. En revanche, cependant, 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 lorsqu'il lit le document d'entrée. UNE

• L'analyseur DOM sert toujours l'application cliente avec tout le document, quel que soit le montant réellement requis par le client. Mais un analyseur SAX sert l'application client toujours uniquement avec des morceaux 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 remplacées par le client) seront invoquées automatiquement (implicitement) d'une manière qui est appelée "rappel" lorsque certains événements se produisent. Ces méthodes ne doivent pas ê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 doit ê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 fonctionnalités 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 à n'importe quelle partie du document à plusieurs reprises et vous permet de modifier l'arborescence DOM), mais son espace est inefficace lorsque le document est énorme , et cela prend un peu de temps pour apprendre à travailler avec. Un analyseur SAX, cependant, est beaucoup plus efficace en cas de gros document d'entrée (car il ne crée aucune structure interne). De plus, il s'exécute plus rapidement et est plus facile à apprendre que DOM Parser car son API est vraiment simple. Mais du point de vue de la fonctionnalité, il offre moins de fonctions, ce qui signifie que les utilisateurs eux-mêmes doivent en prendre plus en charge, 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 les applications du monde réel où l'utilisation de l'analyseur SAX est avantageuse par rapport à l'utilisation de l'analyseur DOM et vice versa? Quelles sont les applications habituelles pour un analyseur DOM et pour un analyseur SAX?

Dans les cas suivants, l'utilisation de l'analyseur SAX est avantageuse par rapport à l'utilisation de l'analyseur DOM.

• Le document d'entrée est trop volumineux 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 souhaitez simplement utiliser l'analyseur pour extraire les informations d'intérêt, 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 point de vue, je pense que la possibilité d'utiliser un analyseur DOM est inférieure à celle d'utiliser un analyseur SAX.

Dans les cas suivants, l'utilisation de l'analyseur DOM est avantageuse par rapport à l'utilisation de l'analyseur SAX.

• Votre application doit accéder simultanément à des parties du document largement séparées.
• Votre application peut probablement utiliser une structure de données interne qui est 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 une durée significative via de nombreux appels de méthode.

Exemple (utiliser un analyseur DOM ou un analyseur SAX?):

Supposons qu'un instructeur dispose d'un document XML contenant toutes les informations personnelles des élèves ainsi que les points soulevés par ses élèves dans sa classe, et il attribue maintenant des notes finales aux élèves à l'aide d'une application. Ce qu'il veut produire, c'est une liste avec le SSN et les grades. 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 des A à ceux qui ont obtenu la moyenne de la classe ou plus, et de donner des B aux autres, alors il vaut mieux utiliser un analyseur DOM dans sa demande. La raison en est qu'il n'a aucun moyen de connaître la moyenne de la classe avant que le document entier ne soit traité. Ce qu'il doit probablement faire dans sa candidature, c'est d'abord regarder à travers tous les points et calculer la moyenne, puis parcourez à nouveau le document et attribuez la note finale à chaque élève en comparant les points qu'il a gagnés à la moyenne de la classe. Si, cependant, l'instructeur adopte une telle politique de notation que les étudiants qui ont obtenu 90 points ou plus, se voient attribuer des A et les autres des B, alors il vaut probablement mieux utiliser un analyseur SAX. La raison en est que pour attribuer une note finale à chaque étudiant, il n'a pas besoin d'attendre que l'intégralité du document soit traité. Il pourrait immédiatement attribuer une note à un étudiant une fois que l'analyseur SAX aura 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 propre. Et s'il crée sa propre structure de données, comme 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 ne puisse également économiser de la mémoire et du temps, tout en faisant le travail. Eh bien, encore une considération sur cet exemple. Que faire si l'instructeur ne veut pas imprimer une liste, mais sauvegarder 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 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'est-à-dire définir la valeur du nœud «grade»), puis enregistrer l'intégralité de l'arborescence modifiée. S'il choisit d'utiliser un analyseur SAX au lieu d'un analyseur DOM, alors dans ce cas, il doit créer une structure de données qui est presque aussi compliquée qu'un arbre DOM avant de pouvoir faire le travail. encore faire le travail. Eh bien, encore une considération sur cet exemple. Que faire si l'instructeur ne veut pas imprimer une liste, mais sauvegarder 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 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'est-à-dire définir la valeur du nœud «grade»), puis enregistrer l'intégralité de l'arbre modifié. S'il choisit d'utiliser un analyseur SAX au lieu d'un analyseur DOM, alors dans ce cas, il doit créer une structure de données qui est presque aussi compliquée qu'un arbre DOM avant de pouvoir faire le travail. encore faire le travail. Eh bien, encore une considération sur cet exemple. Que faire si l'instructeur ne veut pas imprimer une liste, mais sauvegarder 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 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'est-à-dire définir la valeur du nœud «grade»), puis enregistrer l'intégralité de l'arborescence modifiée. S'il choisit d'utiliser un analyseur SAX au lieu d'un analyseur DOM, alors dans ce cas, il doit créer une structure de données qui est presque aussi compliquée qu'un arbre DOM avant de pouvoir faire le travail. mais pour sauvegarder 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 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'est-à-dire définir la valeur du nœud «grade»), puis enregistrer l'intégralité de l'arborescence modifiée. S'il choisit d'utiliser un analyseur SAX au lieu d'un analyseur DOM, alors dans ce cas, il doit créer une structure de données qui est presque aussi compliquée qu'un arbre DOM avant de pouvoir faire le travail. mais pour sauvegarder 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 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'est-à-dire définir la valeur du nœud «grade»), puis enregistrer l'intégralité de l'arborescence modifiée. S'il choisit d'utiliser un analyseur SAX au lieu d'un analyseur DOM, alors dans ce cas, il doit créer une structure de données qui est presque aussi compliquée qu'un arbre DOM avant de pouvoir faire le travail. nœud), puis enregistrez l'arborescence entièrement modifiée. S'il choisit d'utiliser un analyseur SAX au lieu d'un analyseur DOM, alors dans ce cas, il doit créer une structure de données qui est presque aussi compliquée qu'un arbre DOM avant de pouvoir faire le travail. nœud), puis enregistrez l'arborescence entièrement modifiée. S'il choisit d'utiliser un analyseur SAX au lieu d'un analyseur DOM, alors dans ce cas, il doit créer une structure de données qui est presque aussi compliquée qu'un arbre DOM avant de pouvoir faire 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 dans 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> 

Programmer 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 l' arborescence suivante en mémoire.
• 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 vers l'avant ou vers l'arrière.

• SAX présente le document XML comme événement basé comme start element:abc, end element:abc.
• SAX n'est pas la norme W3C, il a été développé par un groupe de développeurs.
• SAX n'utilise pas de mémoire, préféré pour les documents XML volumineux.
• La navigation vers l'arrière n'est pas possible car elle traite séquentiellement les documents.
• 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 passé par un analyseur SAX, générera une séquence d'événements comme le suivant :

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 signifie Document Object Model et il représente un document XML au format arborescent dont chaque élément représente des branches d'arbres. DOM Parser crée une représentation d'arborescence In Memory du fichier XML, puis l'analyse, il nécessite donc plus de mémoire et il est conseillé d'augmenter la taille de segment de mémoire de DOM afin d'éviter Java.lang.OutOfMemoryError: java heap space. L'analyse du fichier XML à l'aide de l'analyseur DOM est assez rapide si le fichier XML est petit, mais si vous essayez de lire un gros fichier XML à l'aide de l'analyseur DOM, il y a plus de chances que cela prenne du temps ou même qu'il ne puisse pas le charger complètement simplement parce que il nécessite beaucoup de mémoire pour créer XML Dom Tree. Java fournit une prise en charge de l'analyse DOM et vous pouvez analyser des fichiers XML en Java à l'aide de l'analyseur 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 signifie API simple pour l'analyse XML. Il s'agit d'une analyse XML basée sur les événements et elle analyse pas à pas le fichier XML, ce qui convient parfaitement aux fichiers XML volumineux. SAX XML Parser déclenche un événement lorsqu'il rencontre une balise d'ouverture, un élément ou un attribut et l'analyse fonctionne en conséquence. Il est recommandé d'utiliser l'analyseur XML SAX pour analyser de gros fichiers xml en Java car il ne nécessite pas de charger un fichier XML entier en Java et il peut lire un gros fichier XML en petites parties. Java fournit un support pour l'analyseur SAX et vous pouvez analyser n'importe quel fichier xml en Java à l'aide de l'analyseur SAX, j'ai couvert un exemple de lecture de fichier xml à l'aide de l'analyseur SAX ici. Un inconvénient de l'utilisation de SAX Parser en java est que la lecture de fichiers XML en Java à l'aide de SAX Parser nécessite plus 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 tout le document xml en mémoire tandis 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 accède à tout le document XML en mémoire.

3) L'analyseur SAX en Java convient mieux aux fichiers XML volumineux que l'analyseur DOM car il ne nécessite pas beaucoup de mémoire.

4) L'analyseur DOM fonctionne sur le modèle d'objet de document tandis 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 ont des avantages et des inconvénients et peuvent être utilisés dans notre programmation selon la situation

SAXO:

1. Analyse 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. Traversez dans toutes les directions.

Si nous avons besoin de trouver un nœud et que nous n'avons pas besoin d'insérer ou de supprimer, nous pouvons utiliser SAX lui-même, sinon DOM à condition d'avoir plus de mémoire.

1) L'analyseur DOM charge tout le document XML en mémoire tandis 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 accède à tout le document XML en mémoire.

3) L'analyseur SAX en Java convient mieux aux fichiers XML volumineux que l'analyseur DOM car il ne nécessite pas beaucoup de mémoire.

4) L'analyseur DOM fonctionne sur le modèle d'objet de document tandis 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