¿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.

Según 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 nodos secundarios en lugar de cargar todos los nodos al mismo tiempo. Pero en el caso del análisis de DOM , cargará todos los nodos y creará el modelo de árbol.

Es mi entendimiento correcto?

Corrígeme si me equivoco o explícame el modelo de árbol basado en eventos de una manera más simple.

Bueno, estás cerca.

En SAX, los eventos se desencadenan cuando se analiza el XML. Cuando el analizador analiza el XML y encuentra un inicio de etiqueta (por ejemplo, ), desencadena el evento tagStarted (el nombre real del evento puede diferir). Del mismo modo, cuando el final de la etiqueta se cumple durante el análisis ( ), desencadena 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. Todo el XML se analiza 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 integrados en los diversos 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 para X ML): es un procesador basado en flujo. Solo tiene una pequeña parte en la memoria en cualquier momento y “huele” la secuencia XML implementando el código de callback para eventos como tagStarted() etc. No usa casi memoria, pero no puede hacer cosas “DOM”, como usar xpath o árboles transversales.

DOM ( M odel objeto de objeción de D ): Usted carga todo en la memoria: es un cerdo de memoria masivo. Puede soplar 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 objeto) (Á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 eliminar 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 tags y evaluar la información dentro de las tags. 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 tal como lo lee, es decir, analiza nodo por nodo.

  • Sin 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.

  • Use el analizador SAX cuando el contenido de la memoria sea 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 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 consumir 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 en el árbol.

El enfoque DOM generalmente se usa para estructuras XML pequeñas (donde lo pequeño depende de la cantidad de caballos de fuerza y ​​memoria que tenga su plataforma) que pueden necesitar modificarse y consultarse de diferentes maneras una vez que se hayan 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 por usted para descifrar la estructura del documento y preparar potencialmente muchos objetos para todos los nodos, atributos, etc., SAX se los deja completamente a usted.

Lo que básicamente hace es leer la entrada de la parte superior e invocar los métodos de callback que usted proporciona cuando ocurren ciertos “eventos”. Un evento puede estar golpeando una etiqueta de apertura, un atributo en la etiqueta, encontrando texto dentro de un elemento o encontrando una etiqueta final.

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

Si bien este enfoque del procesamiento de XML es mucho más tedioso, también puede ser muy poderoso. Imagine que desea extraer los títulos de los artículos de noticias de un feed de blog. Si lee este XML usando DOM, cargará todos los contenidos del artículo, todas las imágenes, etc. que están contenidas en el XML en la memoria, incluso si ni siquiera está interesado en él.

Con SAX puedes simplemente verificar si el nombre del elemento es (por ejemplo) “título” siempre que se invoque tu método de evento “startTag”. Si es así, sabes que necesitas agregar lo que el próximo evento “elementText” te ofrezca. Cuando recibe la llamada al evento “endTag”, comprueba nuevamente si este es el elemento de cierre del “título”. Después de eso, simplemente ignora todos los demás elementos, hasta que la entrada finaliza o aparece otro “startTag” con un nombre de “título”. Y así…

De esta forma, puede leer megabytes y megabytes de XML, simplemente extrayendo la pequeña cantidad de datos que necesita.

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

Por lo tanto, en general, SAX es adecuado para analizar 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 total flexibilidad en el cambio de estructura y contenido, a expensas de una mayor demanda de recursos.

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

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

  • El modelo de objetos del documento (DOM) es un modelo de datos abstracto que describe una estructura de documento jerárquica basada en árbol; un árbol de documento consta de nodos , a saber, nodo de elemento, atributo y texto (y algunos otros). Los nodos tienen padres, hermanos e hijos y se pueden recorrer, etc., todas las cosas a las que estás acostumbrado al 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. Un archivo HTML o XML contiene una versión “escrita” o “aplanada” de un árbol de documento abstracto.

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

Ahora llegamos a la naturaleza de los analizadores sintácticos. Una forma de analizarlo sería leer todo el documento y recursivamente construir una estructura de árbol en la memoria, y finalmente exponer el resultado completo para el 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 adolece de problemas de escalabilidad y se vuelve muy costoso para documentos grandes.

Por otro lado, el análisis basado en eventos , como lo hace SAX, mira el archivo de forma lineal y simplemente hace call-backs al usuario cada vez que encuentra una pieza estructural de datos, como “este elemento comenzó”, “ese elemento terminó” , “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 haga todo el trabajo de procesamiento (proporcionando call-backs). Para volver a su pregunta original, el término “basado en eventos” se refiere a los eventos de análisis que el analizador plantea a medida que 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 Q & A para esta pregunta:

Responder a las preguntas

¿Por qué necesitamos el analizador XML?

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

¿Cuál es mejor, SAX o DOM?

Tanto el analizador SAX como el 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 una mejor velocidad, analizadores DOM o SAX?

El analizador 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 componentes de un árbol (que es un documento DOM) como interfaz de documento, interfaz de nodo, interfaz NodeList, interfaz de elemento, interfaz Attr, etc. Por el contrario, sin embargo, una API basada en eventos proporciona interfaces en los controladores. Hay cuatro interfaces de controlador, interfaz ContentHandler, interfaz DTDHandler, 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 los componentes de un documento de entrada como eventos, y le dice al cliente lo que lee mientras lee a través del documento de entrada. UN

  • El analizador DOM siempre sirve a la aplicación cliente con todo el documento sin importar cuánto realmente lo necesite 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 a métodos en la aplicación del 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 “callback” 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 debería ser rápido (eficiente en tiempo), eficiente en el uso del espacio, rico en funcionalidades 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 no es eficiente cuando el documento es enorme , y lleva un poco de tiempo aprender cómo trabajar con él. Un analizador SAX, sin embargo, es mucho más eficiente en el uso del espacio en el caso de un documento de entrada grande (porque no crea una estructura interna). Además, funciona 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 usuarios mismos tienen que ocuparse de 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 tu aplicación.

¿Cuáles son algunas aplicaciones del mundo real donde el uso del analizador SAX es ventajoso en comparación con el analizador DOM y viceversa? ¿Cuál es la aplicación habitual 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 contiguos de entrada. No necesita todo el documento antes de poder hacer 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 mismo. De hecho, en la mayoría de nuestras aplicaciones, creamos estructuras de datos propias que, por lo general, no son tan complicadas como el árbol DOM. Desde este punto de vista, 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 ampliamente separadas del documento al mismo tiempo.
  • Su aplicación probablemente use una estructura interna de datos que es casi tan complicada como el documento en sí.
  • Su aplicación tiene que modificar el documento repetidamente.
  • Su aplicación tiene que almacenar el documento por una cantidad significativa de tiempo a través de muchas llamadas a métodos.

Ejemplo (¿usa 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 alumnos hicieron en su clase, y ahora está asignando calificaciones finales para los estudiantes que usan 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 matrices, para almacenar la información personal del alumno y los puntos. Si el instructor decide otorgar A a aquellos que obtuvieron el promedio de la clase o superior, 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 necesite hacer en su aplicación, es primero revisar todos los puntos de los estudiantes y calcular el promedio, y luego revisar el documento nuevamente y asignar la calificación final a cada estudiante al comparar 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 asignó A y a los otros se les asignó B, entonces probablemente sea mejor usar un analizador SAX. La razón es que para asignar a cada alumno una calificación final, no necesita esperar a que se procese todo el documento. Podría asignar inmediatamente una calificación a un alumno una vez que el analizador SAX lea la calificación de este alumno. En el análisis anterior, asumimos que el instructor no creó ninguna estructura de datos propia. ¿Qué pasa si él crea su propia estructura de datos, como una matriz de cadenas para almacenar el SSN y una matriz de enteros para guardar los puntos? En este caso, creo que SAX es una mejor opción, antes de que esto también pudiera ahorrar memoria y tiempo, pero hacer el trabajo. Bueno, una consideración más en este ejemplo. ¿Qué sucede si lo que el instructor desea hacer no es imprimir una lista, sino guardar el documento original de nuevo con la calificación de cada alumno actualizado? En este caso, un analizador DOM debería ser una mejor opción sin importar la política de calificación que esté adoptando. Él no necesita crear ninguna estructura de datos propia. Lo que tiene que hacer es primero modificar 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, entonces en este caso tiene que crear una estructura de datos que es casi tan complicada como un árbol DOM antes de poder hacer el trabajo.

Un ejemplo

Declaración del problema : escriba un progtwig 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. Un documento de muestra se proporciona a continuación:

        ]>   20 20 20   40 40 20   

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

Progtwig 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 ax element is seen set the flag as 1 flagX=1; else if(rawName.equals("y")) // if ay element is seen set the flag as 2 flagY=1; else if(rawName.equals("radius")) // if a radius element is seen set the flag as 3 flagR=1; } // override the endElement() method public void endElement(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  element x[numberOfCircles] = Integer.parseInt(characterData); flagX=0; } else if(flagY==1) { // indicate this text is for  element y[numberOfCircles] = Integer.parseInt(characterData); flagY=0; } else if(flagR==1) { // indicate this text is for  element r[numberOfCircles] = Integer.parseInt(characterData); flagR=0; } } // override the endDocument() method public void endDocument() { // when the end of document is seen, just print the circle info System.out.println("circles="+numberOfCircles); for(int i=0;i 

En la práctica: book.xml

   Everyday Italian Giada De Laurentiis 2005 30.00   
  • 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 Document Object Model.
  • DOM ocupa más memoria, preferida para documentos XML pequeños
  • DOM es fácil de navegar hacia adelante o hacia atrás.

enter image description here


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

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 

DOM representa el modelo de objeto de documento y representa un documento XML en formato de árbol en el que cada elemento que representa twigs de árbol. DOM Parser crea una representación en árbol en 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 dynamic para el analizador DOM para evitar Java.lang.OutOfMemoryError: espacio de almacenamiento Java. Analizar el archivo XML usando el analizador DOM es bastante rápido si el archivo XML es pequeño, pero si intenta leer un archivo XML grande usando el analizador DOM, hay más posibilidades de que demore mucho tiempo o incluso que no pueda cargarlo completamente simplemente porque 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 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).

Analizador SAX XML en Java

SAX significa API simple para análisis XML. Este es un análisis XML basado en eventos y analiza paso a paso el archivo XML, que es muy adecuado para grandes archivos XML. SAX XML Parser desencadena el evento cuando se encuentra con la etiqueta de apertura, elemento o atributo y el análisis funciona en consecuencia. Se recomienda utilizar el analizador XML de SAX para analizar grandes archivos xml en Java, ya que no requiere cargar archivos XML completos en Java y puede leer un gran archivo XML en partes pequeñas. Java brinda soporte para el analizador SAX y usted puede analizar cualquier archivo xml en Java usando SAX Parser. He cubierto un ejemplo de cómo leer un archivo xml usando SAX Parser aquí. Una desventaja del uso de SAX Parser en Java es que leer un archivo XML en Java utilizando 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 tiene acceso 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 Document Object Model 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 se pueden usar en nuestra progtwigción dependiendo de la situación

SAXÓFONO:

  1. Parses nodo por nodo

  2. No almacena el XML en la memoria

  3. No podemos insertar o eliminar un nodo

  4. Atravesar 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. Atraviesa en cualquier dirección.

Si necesitamos encontrar un nodo y no es necesario insertarlo o eliminarlo, podemos ir con SAX, 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 tiene acceso 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 Document Object Model 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

Intereting Posts