¿Cuál es la diferencia entre SAX y DOM?

Leí algunos artículos sobre los analizadores XML y encontré SAX y DOM .

SAX está basado en eventos y DOM es un modelo de árbol. No entiendo las diferencias entre estos conceptos.

Por lo que he entendido, basado en eventos significa que algún tipo de evento le sucede al nodo. Al igual que cuando uno hace clic en un nodo en particular, dará todos los subnodos en lugar de cargar todos los nodos al mismo tiempo. Pero en el caso del análisis DOM , cargará todos los nodos y creará el modelo de árbol.

¿Es correcto mi entendimiento?

Por favor, corríjame si estoy equivocado o explíqueme el modelo de árbol y basado en eventos de una manera más simple.

Bueno, estas cerca.

En SAX, los eventos se desencadenan cuando se analiza el XML . Cuando el analizador analiza el XML y encuentra una etiqueta que comienza (p <something>. Ej. ), Activa el tagStartedevento (el nombre real del evento puede diferir). De manera similar, cuando se cumple el final de la etiqueta al analizar ( </something>), se dispara tagEnded. El uso de un analizador SAX implica que necesita manejar estos eventos y dar sentido a los datos devueltos con cada evento.

En DOM, no hay eventos activados durante el análisis. Se analiza el XML completo y se genera y devuelve un árbol DOM (de los nodos en el XML). Una vez analizado, el usuario puede navegar por el árbol para acceder a los diversos datos previamente incrustados en los distintos nodos en el XML.

En general, DOM es más fácil de usar, pero tiene una sobrecarga de analizar todo el XML antes de que pueda comenzar a usarlo.

En pocas palabras ...

SAX ( S imple A PI for X ML): es un procesador basado en transmisión. Solo tiene una pequeña parte en la memoria en cualquier momento y "olfatea" el flujo XML al implementar código de devolución de llamada para eventos como tagStarted()etc. Casi no usa memoria, pero no puede hacer cosas de "DOM", como usar xpath o atravesar arboles

DOM ( D ocument O bject M odel ): se carga todo en la memoria, es un gran problema de memoria. Puede volar la memoria incluso con documentos de tamaño mediano. Pero puedes usar xpath y atravesar el árbol, etc.

Aquí en palabras más simples:

DOM

• Analizador de modelo de árbol (basado en objetos) (Árbol de nodos).

• DOM carga el archivo en la memoria y luego analiza el archivo.

• Tiene restricciones de memoria ya que carga todo el archivo XML antes de analizarlo.

• DOM es de lectura y escritura (puede insertar o eliminar nodos).

• Si el contenido XML es pequeño, prefiera el analizador DOM.

• La búsqueda hacia atrás y hacia adelante es posible para buscar las etiquetas y evaluar la información dentro de las etiquetas. Entonces esto le da la facilidad de navegación.

• Más lento en el tiempo de ejecución.

SAXÓFONO

• Analizador basado en eventos (secuencia de eventos).

• SAX analiza el archivo a medida que lo lee, es decir, analiza nodo por nodo.

• No hay restricciones de memoria, ya que no almacena el contenido XML en la memoria.

• SAX es de solo lectura, es decir, no puede insertar o eliminar el nodo.

• Utilice el analizador SAX cuando el contenido de la memoria sea grande.

• SAX lee el archivo XML de arriba a abajo y no es posible la navegación hacia atrás.

• Más rápido en tiempo de ejecución.

Tiene razón en su comprensión del modelo basado en DOM. El archivo XML se cargará como un todo y todos sus contenidos se construirán como una representación en memoria del árbol que representa el documento. Esto puede llevar mucho tiempo y memoria, dependiendo de qué tan grande sea el archivo de entrada. El beneficio de este enfoque es que puede consultar fácilmente cualquier parte del documento y manipular libremente todos los nodos del árbol.

El enfoque DOM generalmente se usa para estructuras XML pequeñas (donde pequeñas dependen de la cantidad de potencia y memoria que tenga su plataforma) que pueden necesitar modificarse y consultarse de diferentes maneras una vez que se han cargado.

SAX, por otro lado, está diseñado para manejar entradas XML de prácticamente cualquier tamaño. En lugar de que el marco XML haga el trabajo duro por usted para descubrir la estructura del documento y preparar potencialmente muchos objetos para todos los nodos, atributos, etc., SAX se lo deja completamente a usted.

Lo que básicamente hace es leer la entrada desde arriba e invocar los métodos de devolución de llamada que proporciona cuando ocurren ciertos "eventos". Un evento puede estar golpeando una etiqueta de apertura, un atributo en la etiqueta, encontrar texto dentro de un elemento o encontrarse con una etiqueta final.

SAX lee obstinadamente la entrada y le dice lo que ve de esta manera. Depende de usted mantener toda la información del estado que necesite. Por lo general, esto significa que construirá algún tipo de máquina de estado.

Si bien este enfoque para el procesamiento de XML es mucho más tedioso, también puede ser muy poderoso. Imagina que solo quieres extraer los títulos de los artículos de noticias de un blog. Si lees este XML usando DOM, cargaría todo el contenido del artículo, todas las imágenes, etc. que están contenidas en el XML en la memoria, aunque ni siquiera te interese.

Con SAX puede verificar si el nombre del elemento es (por ejemplo) "título" cada vez que se llama a su método de evento "startTag". Si es así, sabe que debe agregar lo que le ofrezca el próximo evento "elementText". Cuando recibe la llamada al evento "endTag", verifica nuevamente si este es el elemento de cierre del "título". Después de eso, simplemente ignora todos los elementos adicionales, hasta que finalice la entrada u otra "etiqueta de inicio" con un nombre de "título". Y así...

Puede leer megabytes y megabytes de XML de esta manera, simplemente extrayendo la pequeña cantidad de datos que necesita.

El lado negativo de este enfoque es, por supuesto, que necesita hacer mucho más contabilidad, dependiendo de qué datos necesita extraer y cuán complicada es la estructura XML. Además, naturalmente no puede modificar la estructura del árbol XML, porque nunca lo tiene en su conjunto.

Por lo tanto, en general, SAX es adecuado para combinar cantidades potencialmente grandes de datos que recibe con una "consulta" específica en mente, pero no necesita modificar, mientras que DOM está más orientado a brindarle flexibilidad total para cambiar la estructura y los contenidos, a expensas de mayor demanda de recursos.

Estás comparando manzanas y peras. SAX es un analizador que analiza estructuras de DOM serializadas. Hay muchos analizadores diferentes, y "basado en eventos" se refiere al método de análisis.

Quizás sea necesario un pequeño resumen:

• El modelo de objeto de documento (DOM) es un modelo de datos abstractos que describe una estructura de documento jerárquica basada en un árbol; un árbol de documentos consta de nodos , a saber, elementos, atributos y nodos de texto (y algunos otros). Los nodos tienen padres, hermanos e hijos y pueden atravesarse, etc., todas las cosas a las que está acostumbrado haciendo JavaScript (que por cierto no tiene nada que ver con el DOM).

• Una estructura DOM puede ser serializada , es decir, escrita en un archivo, utilizando un lenguaje de marcado como HTML o XML. Por lo tanto, un archivo HTML o XML contiene una versión "escrita" o "aplanada" de un árbol de documentos abstractos.

• Para que una computadora manipule, o incluso muestre, un árbol DOM de un archivo, tiene que deserializar o analizar el archivo y reconstruir el árbol abstracto en la memoria. Aquí es donde entra el análisis.

Ahora llegamos a la naturaleza de los analizadores sintácticos. Una forma de analizar sería leer todo el documento y construir recursivamente una estructura de árbol en la memoria, y finalmente exponer todo el resultado al usuario. (Supongo que podría llamar a estos analizadores "analizadores DOM"). Eso sería muy útil para el usuario (creo que eso es lo que hace el analizador XML de PHP), pero tiene problemas de escalabilidad y se vuelve muy costoso para documentos grandes.

Por otro lado, el análisis basado en eventos , como lo hizo SAX, mira el archivo linealmente y simplemente realiza devoluciones de llamadas al usuario cada vez que encuentra una pieza estructural de datos, como "este elemento comenzó", "ese elemento terminó" , "algo de texto aquí", etc. Esto tiene el beneficio de que puede continuar para siempre sin preocuparse por el tamaño del archivo de entrada, pero es mucho más bajo porque requiere que el usuario realice todo el trabajo de procesamiento real (al proporcionar devoluciones de llamada). Para volver a su pregunta original, el término "basado en eventos" se refiere a los eventos de análisis que el analizador genera cuando atraviesa el archivo XML.

El artículo de Wikipedia tiene muchos detalles sobre las etapas del análisis SAX.

Proporcionaré una respuesta general orientada a preguntas y respuestas para esta pregunta:

Respuesta a preguntas

¿Por qué necesitamos un analizador XML?

Necesitamos un analizador XML porque no queremos hacer todo en nuestra aplicación desde cero, y necesitamos algunos programas o bibliotecas "auxiliares" para hacer algo de muy bajo nivel pero muy necesario para nosotros. Estas cosas de bajo nivel pero necesarias incluyen verificar la buena formabilidad, validar el documento contra su DTD o esquema (solo para validar analizadores), resolver la referencia de caracteres, comprender las secciones CDATA, etc. Los analizadores XML son programas de "ayuda" y harán todos estos trabajos. Con el analizador XML, estamos protegidos de muchas de estas complejidades y podríamos concentrarnos solo en la programación de alto nivel a través de las API implementadas por los analizadores, y así ganar eficiencia en la programación.

¿Cuál es mejor, SAX o DOM?

Tanto el analizador SAX como DOM tienen sus ventajas y desventajas. Cuál es mejor debería depender de las características de su aplicación (consulte algunas preguntas a continuación).

¿Qué analizador puede obtener mejores analizadores de velocidad, DOM o SAX?

El analizador SAX puede obtener una mejor velocidad.

¿Cuál es la diferencia entre API basada en árbol y API basada en eventos?

Una API basada en árbol se centra en una estructura de árbol y, por lo tanto, proporciona interfaces en los componentes de un árbol (que es un documento DOM), como la interfaz de documento, la interfaz de nodo, la interfaz de NodeList, la interfaz de Element, la interfaz de Attr, etc. Sin embargo, por el contrario, una API basada en eventos proporciona interfaces en los controladores. Hay cuatro interfaces de controlador, la interfaz ContentHandler, la interfaz DTDHandler, la interfaz EntityResolver y la interfaz ErrorHandler.

¿Cuál es la diferencia entre un analizador DOM y un analizador SAX?

Los analizadores DOM y los analizadores SAX funcionan de diferentes maneras:

• Un analizador DOM crea una estructura de árbol en la memoria del documento de entrada y luego espera las solicitudes del cliente. Pero un analizador SAX no crea ninguna estructura interna. En cambio, toma las ocurrencias de componentes de un documento de entrada como eventos, y le dice al cliente lo que lee mientras lee el documento de entrada. UNA

• El analizador DOM siempre sirve a la aplicación del cliente con todo el documento, sin importar cuánto sea realmente necesario para el cliente. Pero un analizador SAX sirve la aplicación cliente siempre solo con partes del documento en un momento dado.

• Con el analizador DOM, las llamadas a métodos en la aplicación cliente deben ser explícitas y formar una especie de cadena. Pero con SAX, algunos métodos determinados (generalmente anulados por el cliente) se invocarán automáticamente (implícitamente) de una manera que se llama "devolución de llamada" cuando ocurren ciertos eventos. El cliente no tiene que llamar explícitamente estos métodos, aunque podríamos llamarlos explícitamente.

¿Cómo decidimos qué analizador es bueno?

Idealmente, un buen analizador debe ser rápido (eficiente en tiempo), eficiente en espacio, rico en funcionalidad y fácil de usar. Pero en realidad, ninguno de los analizadores principales tiene todas estas características al mismo tiempo. Por ejemplo, un analizador DOM es rico en funcionalidad (porque crea un árbol DOM en la memoria y le permite acceder a cualquier parte del documento repetidamente y le permite modificar el árbol DOM), pero es poco eficiente cuando el documento es enorme , y lleva un poco de tiempo aprender a trabajar con él. Sin embargo, un analizador SAX es mucho más eficiente en el espacio en caso de un gran documento de entrada (porque no crea una estructura interna). Además, se ejecuta más rápido y es más fácil de aprender que DOM Parser porque su API es realmente simple. Pero desde el punto de vista de la funcionalidad, proporciona menos funciones, lo que significa que los propios usuarios deben cuidar más, como crear sus propias estructuras de datos. Por cierto, ¿qué es un buen analizador? Creo que la respuesta realmente depende de las características de su aplicación.

¿Cuáles son algunas aplicaciones del mundo real en las que usar el analizador SAX es ventajoso que usar el analizador DOM y viceversa? ¿Cuáles son las aplicaciones habituales para un analizador DOM y para un analizador SAX?

En los siguientes casos, usar el analizador SAX es ventajoso que usar el analizador DOM.

• El documento de entrada es demasiado grande para la memoria disponible (en este caso, SAX es su única opción)
• Puede procesar el documento en pequeños fragmentos de entrada contiguos. No necesita todo el documento antes de poder hacer un trabajo útil.
• Solo desea usar el analizador para extraer la información de interés, y todos sus cálculos se basarán completamente en las estructuras de datos creadas por usted mismo. En realidad, en la mayoría de nuestras aplicaciones, creamos estructuras de datos propias que generalmente no son tan complicadas como el árbol DOM. Desde este sentido, creo, la posibilidad de usar un analizador DOM es menor que la de usar un analizador SAX.

En los siguientes casos, usar el analizador DOM es ventajoso que usar el analizador SAX.

• Su aplicación necesita acceder a partes del documento ampliamente separadas al mismo tiempo.
• Es probable que su aplicación utilice una estructura de datos interna que es casi tan complicada como el documento mismo.
• Su aplicación tiene que modificar el documento repetidamente.
• Su aplicación tiene que almacenar el documento durante un período de tiempo significativo a través de muchas llamadas a métodos.

Ejemplo (¿Usar un analizador DOM o un analizador SAX?):

Suponga que un instructor tiene un documento XML que contiene toda la información personal de los estudiantes, así como los puntos que sus estudiantes hicieron en su clase, y ahora está asignando calificaciones finales para los estudiantes usando una aplicación. Lo que quiere producir es una lista con el SSN y las calificaciones. También suponemos que en su aplicación, el instructor no utiliza ninguna estructura de datos, como las matrices, para almacenar la información personal del alumno y los puntos. Si el instructor decide dar A a aquellos que obtuvieron el promedio de la clase o más, y dar B a los demás, entonces será mejor que use un analizador DOM en su aplicación. La razón es que no tiene forma de saber cuánto es el promedio de la clase antes de que se procese todo el documento. Lo que probablemente deba hacer en su solicitud es primero revisar todos los estudiantes puntos y calcular el promedio, y luego revisar el documento nuevamente y asignar la calificación final a cada estudiante comparando los puntos que obtuvo con el promedio de la clase. Sin embargo, si el instructor adopta una política de calificación tal que los estudiantes que obtuvieron 90 puntos o más, se les asigne A y a los demás se les asigne B, entonces probablemente sea mejor que use un analizador SAX. La razón es que, para asignar a cada estudiante una calificación final, no necesita esperar a que se procese todo el documento. Podría asignarle inmediatamente una calificación a un estudiante una vez que el analizador SAX lea la calificación de este estudiante. En el análisis anterior, asumimos que el instructor no creó ninguna estructura de datos propia. ¿Qué pasa si crea su propia estructura de datos, como un conjunto de cadenas para almacenar el SSN y un conjunto de enteros para almacenar los puntos? En este caso, Creo que SAX es una mejor opción, antes de que esto también pueda ahorrar memoria y tiempo, pero hacer el trabajo. Bueno, una consideración más en este ejemplo. ¿Qué sucede si lo que quiere hacer el instructor no es imprimir una lista, sino volver a guardar el documento original con la calificación de cada alumno actualizada? En este caso, un analizador DOM debería ser una mejor opción sin importar la política de calificación que esté adoptando. No necesita crear ninguna estructura de datos propia. Lo que debe hacer es modificar primero el árbol DOM (es decir, establecer el valor en el nodo 'grado') y luego guardar todo el árbol modificado. Si elige usar un analizador SAX en lugar de un analizador DOM, en este caso tiene que crear una estructura de datos que sea casi tan complicada como un árbol DOM antes de poder hacer el trabajo. pero haz el trabajo. Bueno, una consideración más en este ejemplo. ¿Qué sucede si lo que quiere hacer el instructor no es imprimir una lista, sino volver a guardar el documento original con la calificación de cada alumno actualizada? En este caso, un analizador DOM debería ser una mejor opción sin importar la política de calificación que esté adoptando. No necesita crear ninguna estructura de datos propia. Lo que debe hacer es modificar primero el árbol DOM (es decir, establecer el valor en el nodo 'grado') y luego guardar todo el árbol modificado. Si elige usar un analizador SAX en lugar de un analizador DOM, en este caso tiene que crear una estructura de datos que sea casi tan complicada como un árbol DOM antes de poder hacer el trabajo. pero haz el trabajo. Bueno, una consideración más en este ejemplo. ¿Qué sucede si lo que quiere hacer el instructor no es imprimir una lista, sino volver a guardar el documento original con la calificación de cada alumno actualizada? En este caso, un analizador DOM debería ser una mejor opción sin importar la política de calificación que esté adoptando. No necesita crear ninguna estructura de datos propia. Lo que debe hacer es modificar primero el árbol DOM (es decir, establecer el valor en el nodo 'grado') y luego guardar todo el árbol modificado. Si elige usar un analizador SAX en lugar de un analizador DOM, en este caso tiene que crear una estructura de datos que sea casi tan complicada como un árbol DOM antes de poder hacer el trabajo. pero para guardar el documento original con la calificación de cada estudiante actualizada? En este caso, un analizador DOM debería ser una mejor opción sin importar la política de calificación que esté adoptando. No necesita crear ninguna estructura de datos propia. Lo que debe hacer es modificar primero el árbol DOM (es decir, establecer el valor en el nodo 'grado') y luego guardar todo el árbol modificado. Si elige usar un analizador SAX en lugar de un analizador DOM, en este caso tiene que crear una estructura de datos que sea casi tan complicada como un árbol DOM antes de poder hacer el trabajo. pero para guardar el documento original con la calificación de cada estudiante actualizada? En este caso, un analizador DOM debería ser una mejor opción sin importar la política de calificación que esté adoptando. No necesita crear ninguna estructura de datos propia. Lo que debe hacer es modificar primero el árbol DOM (es decir, establecer el valor en el nodo 'grado') y luego guardar todo el árbol modificado. Si elige usar un analizador SAX en lugar de un analizador DOM, en este caso tiene que crear una estructura de datos que sea casi tan complicada como un árbol DOM antes de poder hacer el trabajo. nodo) y luego guarde todo el árbol modificado. Si elige usar un analizador SAX en lugar de un analizador DOM, en este caso tiene que crear una estructura de datos que sea casi tan complicada como un árbol DOM antes de poder hacer el trabajo. nodo) y luego guarde todo el árbol modificado. Si elige usar un analizador SAX en lugar de un analizador DOM, en este caso tiene que crear una estructura de datos que sea casi tan complicada como un árbol DOM antes de poder hacer el trabajo.

Un ejemplo

Planteamiento del problema : escriba un programa Java para extraer toda la información sobre círculos que son elementos en un documento XML dado. Suponemos que cada elemento del círculo tiene tres elementos secundarios (es decir, x, y y radio), así como un atributo de color. A continuación se muestra un documento de muestra:

<?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> 

Programa con 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);}

    }

}

Programa con 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 la práctica: 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 presenta el documento xml como la siguiente estructura de árbol en la memoria.
• DOM es el estándar W3C.
• El analizador DOM funciona en el Modelo de Objetos del Documento.
• DOM ocupa más memoria, preferido para documentos XML pequeños
• DOM es fácil de navegar, ya sea hacia adelante o hacia atrás.

• SAX presenta el documento XML como evento basado como start element:abc, end element:abc.
• SAX no es el estándar W3C, fue desarrollado por un grupo de desarrolladores.
• SAX no usa memoria, preferido para documentos XML grandes.
• La navegación hacia atrás no es posible ya que procesa secuencialmente los documentos.
• El evento le sucede a un nodo / elemento y le da todos los subnodos (latín nodus, 'nudo').

Este documento XML, cuando se pasa a través de un analizador SAX, generará una secuencia de eventos como el siguiente :

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 significa Modelo de objeto de documento y representa un documento XML en formato de árbol en el que cada elemento representa ramas de árbol. DOM Parser crea una representación en árbol de memoria del archivo XML y luego lo analiza, por lo que requiere más memoria y es recomendable tener un tamaño de almacenamiento dinámico aumentado para el analizador DOM para evitar Java.lang.OutOfMemoryError: espacio de almacenamiento dinámico de Java. Analizar el archivo XML usando el analizador DOM es bastante rápido si el archivo XML es pequeño, pero si intentas leer un archivo XML grande usando el analizador DOM, hay más posibilidades de que tome mucho tiempo o incluso no pueda cargarlo completamente simplemente porque Se requiere mucha memoria para crear XML Dom Tree. Java proporciona compatibilidad con el análisis DOM y puede analizar archivos XML en Java utilizando el analizador DOM. Las clases DOM están en el paquete w3c.dom, mientras que DOM Parser para Java está en el paquete JAXP (Java API for XML Parsing).

SAX XML Parser en Java

SAX significa API simple para análisis XML. Este es un análisis XML basado en eventos y analiza el archivo XML paso a paso, muy adecuado para archivos XML grandes. SAX XML Parser dispara un evento cuando encuentra una etiqueta, elemento o atributo de apertura y el análisis funciona en consecuencia. Se recomienda utilizar el analizador XML SAX para analizar archivos xml grandes en Java porque no requiere cargar un archivo XML completo en Java y puede leer un archivo XML grande en partes pequeñas. Java proporciona soporte para el analizador SAX y puede analizar cualquier archivo xml en Java usando SAX Parser, he cubierto un ejemplo de lectura de archivos xml usando SAX Parser aquí. Una desventaja de usar SAX Parser en Java es que leer un archivo XML en Java usando SAX Parser requiere más código en comparación con DOM Parser.

Diferencia entre DOM y SAX XML Parser

Aquí hay algunas diferencias de alto nivel entre el analizador DOM y el analizador SAX en Java:

1) El analizador DOM carga todo el documento xml en la memoria, mientras que SAX solo carga una pequeña parte del archivo XML en la memoria.

2) El analizador DOM es más rápido que SAX porque accede a todo el documento XML en la memoria.

3) El analizador SAX en Java es más adecuado para archivos XML grandes que DOM Parser porque no requiere mucha memoria.

4) El analizador DOM funciona en el Modelo de Objetos del Documento, mientras que SAX es un analizador XML basado en eventos.

Leer más: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz2uz1bJQqZ

Tanto SAX como DOM se utilizan para analizar el documento XML. Ambos tienen ventajas y desventajas y pueden usarse en nuestra programación dependiendo de la situación.

SAXÓFONO:

1. Analiza nodo por nodo

2. No almacena el XML en la memoria

3. No podemos insertar o eliminar un nodo

4. Recorrido de arriba a abajo

DOM

1. Almacena todo el documento XML en la memoria antes de procesar

2. Ocupa más memoria

3. Podemos insertar o eliminar nodos

4. Atravesar en cualquier dirección.

Si necesitamos encontrar un nodo y no necesitamos insertarlo o eliminarlo, podemos usar SAX en sí mismo, de lo contrario, DOM siempre que tengamos más memoria.

1) El analizador DOM carga todo el documento XML en la memoria, mientras que SAX solo carga una pequeña parte del archivo XML en la memoria.

2) El analizador DOM es más rápido que SAX porque accede a todo el documento XML en la memoria.

3) El analizador SAX en Java es más adecuado para archivos XML grandes que DOM Parser porque no requiere mucha memoria.

4) El analizador DOM funciona en el Modelo de Objetos del Documento, mientras que SAX es un analizador XML basado en eventos.

Leer más: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz498y3vPFR