xml parsing - arquitectura - ¿Cuál es la diferencia entre SAX y DOM?

que es el dom (10)

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) SAX Parser en Java es más adecuado para archivos XML grandes que DOM Parser porque no requiere mucha memoria.

4) El analizador DOM funciona en Document Object Model mientras que SAX es un analizador XML basado en eventos.

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

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, los eventos basados en eventos significan que ocurre algún tipo de evento en el nodo. Al igual que cuando uno hace clic en un nodo en particular, le dará a todos los subnodos en lugar de cargar todos los nodos al mismo tiempo. Pero en el caso de análisis de DOM cargará todos los nodos y creará el modelo de árbol.

¿Mi entendimiento es correcto?

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

Aquí en palabras más simples:

DOM

Modelo de árbol analizador (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 analizar.
DOM es de lectura y escritura (puede insertar o borrar nodos).
Si el contenido XML es pequeño, entonces 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. Así que esto 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 se puede insertar o eliminar el nodo.
Use el analizador SAX cuando el contenido de la memoria es grande.
SAX lee el archivo XML de arriba a abajo y la navegación hacia atrás no es posible.
Más rápido en el tiempo de ejecución.

Bueno, usted está cerca.

En SAX, los eventos se activan cuando se analiza el XML. Cuando el analizador analiza el XML y encuentra un inicio de etiqueta (por ejemplo, <something> ), se dispara el evento tagStarted (el nombre real del evento puede diferir). De forma similar, cuando se cumple el final de la etiqueta durante el análisis ( </something> ), activa 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 todo el XML 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.

DOM representa el modelo de objetos 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 de un archivo XML y luego lo analiza, por lo que requiere más memoria y es recomendable tener un mayor tamaño de almacenamiento dinámico para el analizador DOM para evitar Java.lang.OutOfMemoryError: java heap space. El análisis del archivo XML con el analizador DOM es bastante rápido si el archivo XML es pequeño, pero si intenta leer un archivo XML grande con el analizador DOM, hay más posibilidades de que lleve mucho tiempo o incluso que no pueda cargarlo completamente simplemente porque se requiere mucha memoria para crear XML Dom Tree. Java proporciona soporte para el análisis de DOM y puede analizar archivos XML en Java usando el analizador de DOM. Las clases de DOM están en el paquete w3c.dom mientras que el DOM Parser para Java está en el paquete JAXP (API de Java para el análisis de XML).

SAX XML Parser en Java

SAX significa API simple para el análisis XML. Este es un análisis XML basado en eventos y analiza el archivo XML, paso a paso, tan adecuado para archivos XML grandes. SAX XML Parser activa el evento cuando encuentra una etiqueta, elemento o atributo de apertura y el análisis funciona en consecuencia. Se recomienda usar el analizador XML SAX para analizar grandes archivos xml 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 de SAX y puede analizar cualquier archivo xml en Java usando el analizador de SAX. He cubierto un ejemplo de cómo leer el archivo xml con el analizador de SAX aquí. Una desventaja de usar SAX Parser en Java es que leer un archivo XML en Java con 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) SAX Parser en Java es más adecuado para archivos XML grandes que DOM Parser porque no requiere mucha memoria.

4) El analizador DOM funciona en Document Object Model mientras que SAX es un analizador xml basado en eventos.

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

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 objeto de documento.
DOM ocupa más memoria, preferido para documentos XML pequeños
DOM es fácil de navegar hacia adelante o hacia atrás.

SAX presenta el documento xml como evento basado como start element:abc , end element:abc .
SAX no es un 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 sucede a un nodo / elemento y proporciona todos los subnodos (Latin nodus, ''knot'').

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

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

En pocas palabras ...

SAX ( S simple A PI para X ML): es un procesador basado en flujo. Solo tiene una pequeña parte en la memoria en cualquier momento y "olfatea" la secuencia XML al implementar el código de devolución de llamada para eventos como tagStarted() etc. No utiliza casi ninguna memoria, pero no puede hacer cosas de "DOM", como el uso Árboles de xpath o travesía.

DOM ( D ocument O bject M odel): carga todo el contenido en la memoria, es un montón de memoria masiva. Puede soplar la memoria incluso con documentos de tamaño mediano. Pero puedes usar xpath y atravesar el árbol, etc.

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

Tal vez un pequeño resumen está en orden:

El modelo de objeto de documento (DOM) es un modelo de datos abstractos que describe una estructura de documento jerárquica basada en árboles; 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 ser recorridos, etc., todas las cosas a las que estás acostumbrado a hacer JavaScript (que por cierto no tiene nada que ver con el DOM).
Una estructura DOM puede ser serializada , es decir, escrita en un archivo, usando 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 desde un archivo, debe 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. Una manera de analizar sería leer todo el documento y construir de forma recursiva una estructura de árbol en la memoria, y finalmente exponer el resultado completo 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 de forma lineal y simplemente devuelve llamadas al usuario cada vez que encuentra un dato estructural, como "este elemento comenzó", "ese elemento terminó" , "algo de texto aquí", etc. Esto tiene la ventaja de que puede durar para siempre sin preocuparse por el tamaño del archivo de entrada, pero es mucho más bajo porque requiere que el usuario haga 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 de SAX.

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

Respuesta a las preguntas

¿Por qué necesitamos analizador XML?

Necesitamos el analizador XML porque no queremos hacer todo desde cero en nuestra aplicación, y necesitamos algunos programas "auxiliares" o bibliotecas para hacer algo de muy bajo nivel pero muy necesario para nosotros. Estos elementos de bajo nivel pero necesarios incluyen la verificación de la buena formación, la validación del documento con su DTD o esquema (solo para validar los analizadores), la resolución de referencias de caracteres, la comprensión de las secciones CDATA, etc. Los analizadores XML son tales programas "auxiliares" y realizarán todos estos trabajos. Con el analizador XML, estamos protegidos de muchas de estas complejidades y podríamos concentrarnos solo en la programación a 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 SAX como DOM parser tienen sus ventajas y desventajas. Cuál es mejor debe depender de las características de su aplicación (consulte algunas de las preguntas a continuación).

¿Qué analizador puede obtener mejor velocidad, los analizadores DOM o SAX?

El analizador de SAX puede obtener una mejor velocidad.

¿Cuál es la diferencia entre la API basada en árbol y la 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 elemento, la interfaz de Attr, etc. Sin embargo, en contraste, una API basada en eventos proporciona interfaces en los manejadores. Hay cuatro interfaces de controlador, la interfaz de ContentHandler, la interfaz de DTDHandler, la interfaz de EntityResolver y la interfaz de 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 desde el documento de entrada y luego espera las solicitudes del cliente. Pero un analizador SAX no crea ninguna estructura interna. En su lugar, toma los eventos de los componentes de un documento de entrada como eventos y le dice al cliente lo que lee a medida que lee el documento de entrada. UNA
El analizador DOM siempre sirve a la aplicación cliente con todo el documento, sin importar cuánto necesite realmente el cliente. Pero un analizador SAX sirve a la aplicación cliente siempre solo con partes del documento en un momento dado.
Con el analizador DOM, las llamadas de método en la aplicación cliente tienen que ser explícitas y forman un tipo de cadena. Pero con SAX, algunos métodos determinados (generalmente anulados por el cient) se invocarán automáticamente (implícitamente) de una manera que se llama "devolución de llamada" cuando ocurren ciertos eventos. Estos métodos no tienen que ser llamados explícitamente por el cliente, 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 ineficiente en espacio 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 el caso de un documento de gran 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 tienen que 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 donde usar el analizador SAX es ventajoso que usar el analizador DOM y viceversa? ¿Cuáles son las aplicaciones habituales para un analizador DOM y 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 trozos contiguos de entrada. No necesita el documento completo antes de poder realizar un trabajo útil
Solo desea utilizar 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. 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 que 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 propio documento.
Tu aplicación tiene que modificar el documento repetidamente.
Su aplicación debe almacenar el documento durante un tiempo considerable a través de muchas llamadas de 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 que usan una aplicación. Lo que él quiere producir, es una lista con el SSN y las calificaciones. También asumimos que en su aplicación, el instructor no utiliza ninguna estructura de datos como matrices para almacenar la información personal del estudiante y los puntos. Si el instructor decide otorgar A a los que obtuvieron el promedio de la clase o superior, y otorgar B a los demás, entonces es 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 puntos de los estudiantes y calcular el promedio, y luego revisar nuevamente el documento 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 a los estudiantes que obtuvieron 90 puntos o más, se les asigna A y a los demás se les asigna B, entonces es 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. Inmediatamente podría asignar una calificación a un estudiante una vez que el analizador de SAX lea la calificación de este estudiante. En el análisis anterior, asumimos que el instructor no creó su propia estructura de datos. ¿Qué sucede si crea su propia estructura de datos, como una matriz de cadenas para almacenar el SSN y una matriz de números enteros para guardar los puntos? En este caso, creo que SAX es una mejor opción, antes de que esto pueda ahorrar memoria y tiempo también, y hacer el trabajo. Bueno, una consideración más en este ejemplo. ¿Qué pasa si lo que el instructor quiere hacer es no imprimir una lista, sino 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 primero modificar el árbol DOM (es decir, establecer el valor en el nodo ''calificación'') y luego guardar todo el árbol modificado. Si elige usar un analizador SAX en lugar de un analizador DOM, entonces, en este caso, tiene que crear una estructura de datos que sea casi tan complicada como un árbol DOM antes de poder realizar el trabajo.

Un ejemplo

Declaración del problema : escriba un programa Java para extraer toda la información sobre los círculos que son elementos en un documento XML determinado. 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); } } }

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

SAXÓFONO:

Analiza nodo por nodo
No almacena el XML en la memoria
No podemos insertar o eliminar un nodo
Travesía de arriba a abajo

DOM

Almacena todo el documento XML en la memoria antes de procesarlo
Ocupa mas memoria
Podemos insertar o eliminar nodos.
Recorrer en cualquier dirección.

Si necesitamos encontrar un nodo y no es necesario insertar o eliminar, podemos usar el propio SAX, de lo contrario DOM siempre que tengamos más memoria.

Usted es correcto en su comprensión del modelo basado en DOM. El archivo XML se cargará en su totalidad y todos sus contenidos se construirán como una representación en memoria del árbol que representa el documento. Esto puede consumir tiempo y memoria, según el tamaño del 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 se usa normalmente para estructuras XML pequeñas (donde la pequeña depende de la cantidad de potencia y memoria que tenga su plataforma) que pueden necesitar ser modificadas y consultadas de diferentes maneras una vez que se han cargado.

Por otro lado, SAX 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 averiguar la estructura del documento y preparar potencialmente muchos objetos para todos los nodos, atributos, etc., SAX lo deja completamente a usted.

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

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

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

Con SAX puede verificar si el nombre del elemento es (por ejemplo, "título" cuando se llama a su método de evento "startTag". Si es así, sabe que necesita agregar lo que le ofrezca el próximo evento "elementText". Cuando recibe la llamada de evento "endTag", verifique de nuevo 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, o aparezca otra "etiqueta de inicio" con un nombre de "título". Y así...

Podría 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 usted mismo necesita hacer mucho más mantenimiento de libros, dependiendo de los datos que necesite extraer y de la complejidad de la estructura XML. Además, naturalmente, no puede modificar la estructura del árbol XML, porque nunca lo tiene en la mano como un todo.

Entonces, en general, SAX es adecuado para combinar cantidades potencialmente grandes de datos que recibe teniendo en cuenta una "consulta" específica, pero no es necesario que se modifique, mientras que DOM está más orientado a brindarle total flexibilidad para cambiar la estructura y los contenidos, a expensas. de mayor demanda de recursos.