Como todos sabemos, hay más y más métodos para analizar XML ahora, pero solo hay cuatro métodos principales, a saber: Dom, Sax, JDOM y DOM4J
La siguiente es la primera en dar la dirección de descarga del paquete JAR para estos cuatro métodos
DOM: Viene en el Java JDK actual, en el paquete xml-apis.jar
Sax: http://sourceforge.net/projects/sax/
Jdom: http://jdom.org/downloads/index.html
Dom4j: http://sourceforge.net/projects/dom4j/
1. Introducción y análisis de ventajas y desventajas
1. DOM (modelo de objeto de documento)
DOM es el estándar W3C oficial para representar documentos XML de una manera independiente de la plataforma y el idioma. DOM es una colección de nodos o fragmentos de información organizados en una jerarquía. Esta jerarquía permite a los desarrolladores buscar información específica en el árbol. Analizar esta estructura generalmente requiere cargar todo el documento y construir la jerarquía antes de que se pueda hacer cualquier trabajo. Dado que se basa en el nivel de información, el DOM se considera basado en árboles o basado en objetos.
【ventaja】
① Permitir que las aplicaciones realicen cambios en los datos y la estructura.
② El acceso es bidireccional, y puede navegar por el árbol en cualquier momento, obtener y operar cualquier parte de los datos.
【defecto】
① Por lo general, todo el documento XML debe cargarse para construir la jerarquía, lo que consume muchos recursos.
2. Sax (API simple para XML)
Las ventajas del procesamiento de SAX son muy similares a las ventajas de la transmisión. El análisis puede comenzar de inmediato, en lugar de esperar a que se procesen todos los datos. Y, dado que la aplicación solo verifica los datos al leerlos, no necesita almacenar los datos en la memoria. Esta es una gran ventaja para documentos grandes. De hecho, la aplicación ni siquiera tiene que analizar todo el documento; Puede dejar de analizar cuando se cumple una determinada condición. En términos generales, Sax es mucho más rápido que su reemplazo de DOM.
Elige DOM o SAX? Para los desarrolladores que necesitan escribir su propio código para procesar documentos XML, elegir un modelo de análisis DOM o SAX es una decisión de diseño muy importante. DOM utiliza el método para establecer una estructura de árbol para acceder a los documentos XML, mientras que SAX utiliza un modelo de evento.
El analizador DOM convierte un documento XML en un árbol que contiene su contenido y puede atravesar el árbol. La ventaja de analizar un modelo con DOM es que es fácil de programar. Los desarrolladores solo necesitan llamadas instrucciones para hacer árboles y luego usar las API de navegación para acceder a los nodos de árbol requeridos para completar la tarea. Es fácil de agregar y modificar elementos en el árbol. Sin embargo, dado que todo el documento XML debe procesarse cuando se usa el analizador DOM, los requisitos de rendimiento y memoria son relativamente altos, especialmente cuando se encuentran grandes archivos XML. Debido a sus capacidades transversales, los analizadores DOM a menudo se usan en servicios donde los documentos XML requieren cambios frecuentes.
El analizador de saxo adopta un modelo basado en eventos. Puede activar una serie de eventos al analizar un documento XML. Cuando se encuentra una etiqueta determinada, puede activar un método de devolución de llamada para decirle al método que se ha encontrado la etiqueta. El SAX generalmente requiere baja memoria porque permite a los desarrolladores decidir las etiquetas que desean procesar. Especialmente cuando los desarrolladores solo necesitan procesar parte de los datos contenidos en el documento, la capacidad de expansión de SAX se refleja mejor. Sin embargo, la codificación es difícil al usar el analizador SAX, y es difícil acceder a múltiples datos diferentes en el mismo documento al mismo tiempo.
【Ventajas】
① No es necesario esperar a que se procesen todos los datos y el análisis puede comenzar de inmediato.
② Verifique los datos solo cuando lea los datos, y no necesita ser guardado en la memoria.
③ Puede dejar de analizar cuando se cumple una determinada condición, sin tener que analizar todo el documento.
④ Alta eficiencia y rendimiento, y pueden analizar documentos más grandes que la memoria del sistema.
【defecto】
① La aplicación debe ser responsable de la lógica de procesamiento de la etiqueta (como mantener la relación padre/niño, etc.), cuanto más complejo sea el documento, más complicado es el programa.
② La navegación unidireccional no puede localizar la jerarquía de documentos, y es difícil acceder a diferentes partes de los datos del mismo documento al mismo tiempo, y no admite XPATH.
3. JDOM (modelo de objeto de documento basado en Java)
El propósito de JDOM es ser un modelo de documento específico de Java, que simplifica la interacción con XML y es más rápido que usar DOM. Dado que es el primer modelo específico de Java, JDOM ha sido promovido y promovido enérgicamente. Considerando terminar utilizándolo como una "extensión estándar de Java" a través de "solicitud de especificación Java JSR-102". El desarrollo de JDOM se ha iniciado desde principios de 2000.
JDOM y DOM son principalmente diferentes en dos aspectos. Primero, JDOM solo usa clases concretas y no interfaces. Esto simplifica la API de alguna manera, pero también limita la flexibilidad. En segundo lugar, la API utiliza una gran cantidad de clases de colecciones, que simplifica el uso de desarrolladores de Java que ya están familiarizados con estas clases.
La documentación de JDOM establece que su propósito es "usar 20% (o menos) de esfuerzo para resolver problemas de Java/XML del 80% (o más)" (asumido como 20% basado en la curva de aprendizaje). Por supuesto, JDOM es útil para la mayoría de las aplicaciones Java/XML, y la mayoría de los desarrolladores encuentran que las API son mucho más fáciles de entender que DOM. JDOM también incluye controles bastante extensos sobre el comportamiento del programa para evitar que los usuarios hagan nada sin sentido en XML. Sin embargo, todavía requiere que comprenda completamente XML para hacer algo más allá de lo básico (o incluso comprender los errores en algunos casos). Este puede ser un trabajo más significativo que aprender una interfaz DOM o JDOM.
Jdom en sí no contiene un analizador. Por lo general, utiliza un analizador SAX2 para analizar y validar los documentos XML de entrada (aunque también puede tomar representaciones DOM previamente construidas como entrada). Contiene algunos convertidores para emitir representaciones JDOM en transmisiones de eventos Sax2, modelos DOM o documentos de texto XML. JDOM es de código abierto lanzado bajo la variante de licencia Apache.
【ventaja】
①Utilice clases de concreto en lugar de interfaces, simplificando la API DOM.
② Se utilizan una gran cantidad de clases de recolección de Java para facilitar a los desarrolladores de Java.
【defecto】
① No hay buena flexibilidad.
② Pal de bajo rendimiento.
4. DOM4J (Modelo de objeto de documento para Java)
Aunque DOM4J representa un resultado de desarrollo completamente independiente, inicialmente fue una rama inteligente de JDOM. Incorpora muchas características más allá de las representaciones básicas de documentos XML, que incluyen soporte integrado de XPath, soporte de esquema XML y procesamiento basado en eventos para documentos grandes o transmitidos. También proporciona la opción de crear una representación de documentos, que tiene acceso paralelo a través de la API DOM4J y la interfaz DOM estándar. Ha estado en desarrollo desde la segunda mitad de 2000.
Para admitir todas estas características, DOM4J utiliza interfaces y métodos de clase base abstracta. DOM4J utiliza ampliamente la clase de colecciones en la API, pero en muchos casos también proporciona algunas alternativas para permitir un mejor rendimiento o un método de codificación más directo. El beneficio directo es que, si bien DOM4J paga el precio de una API más compleja, proporciona una flexibilidad mucho mayor que JDOM.
Al agregar flexibilidad, la integración de XPath y los objetivos del gran procesamiento de documentos, DOM4J es lo mismo que JDOM: facilidad de uso y operación intuitiva para los desarrolladores de Java. También se compromete a convertirse en una solución más completa que JDOM, logrando el objetivo de lidiar con todos los problemas de Java/XML en la naturaleza. Al completar este objetivo, enfatiza menos énfasis en prevenir un comportamiento de aplicación incorrecto que JDOM.
DOM4J es una API Java XML muy, muy excelente, con un rendimiento excelente, funciones potentes y extremadamente fácil de usar. También es un software de código abierto. Hoy en día, puede ver que más y más software Java está utilizando DOM4J para leer y escribir XML. Vale la pena mencionar particularmente que incluso el JAXM de Sun está usando DOM4J.
【ventaja】
① La clase de recolección de Java se usa ampliamente para facilitar a los desarrolladores de Java y proporcionar algunos métodos alternativos para mejorar el rendimiento.
②Pupport xpath.
③ Tiene un buen rendimiento.
【defecto】
① La interfaz se usa ampliamente, y la API es relativamente compleja.
2. Comparación
1. DOM4J tiene el mejor rendimiento, e incluso Jaxm de Sun usa DOM4J. Actualmente, muchos proyectos de código abierto usan DOM4J en grandes cantidades, como el famoso Hibernate también usa DOM4J para leer archivos de configuración XML. Si no se considera la portabilidad, entonces se usa DOM4J.
2. JDOM y DOM funcionan mal durante las pruebas de rendimiento, la memoria se desborda al probar 10 m documentos, pero portátiles. También vale la pena considerar DOM y JDOM en el caso de una pequeña documentación. Si bien los desarrolladores de JDOM han declarado que esperan centrarse en los problemas de rendimiento antes del lanzamiento oficial, desde el punto de vista de rendimiento, realmente no lo recomienda. Además, DOM sigue siendo una muy buena opción. La implementación DOM se usa ampliamente en una variedad de lenguajes de programación. También es la base de muchos otros estándares relacionados con XML, ya que son recomendaciones oficialmente W3C (a diferencia de los modelos Java no basados en el estándar), por lo que también puede ser necesaria en algunos tipos de proyectos (como usar DOM en JavaScript).
3. Sax funciona mejor, lo que depende de su método de análisis específico: basado en eventos. Un saxo detecta una próxima transmisión XML, pero no se carga en la memoria (por supuesto, cuando se lea la secuencia XML, algunos documentos se ocultarán temporalmente en la memoria).
Mi opinión: si el documento XML es grande y no considera los problemas de portabilidad, se recomienda usar DOM4J; Si el documento XML es pequeño, se recomienda usar JDOM; Si necesita ser procesado a tiempo sin guardar los datos, se recomienda considerar el saxo. Pero pase lo que pase, la misma oración es: lo mejor es lo correcto. Si el tiempo lo permite, se recomienda que pruebe estos cuatro métodos y elija uno que le convenga.
Iii. Ejemplo
Para ahorrar espacio, estos cuatro métodos y diferencias en la creación de documentos XML no se dan aquí por el momento. Solo se proporciona el código para analizar documentos XML. Si se requiere un proyecto completo (documentos XML de construcción + comparación de pruebas XML + de análisis).
Aquí está el siguiente contenido XML como ejemplo para analizar:
<? xml versión = "1.0" encoding = "utf-8"?> <sers> <user Id = "0"> <name> Alexia </name> <ge> 23 </edad> <sexo> femenino </ sexo> </serem> <user Id = "1"> <name> edward </name> <ge> 24 </be> <sexo> masculino </ sexo </ sexo> </serve> <ser ID = "2" 2 "2" <ge> 23 </dge> <sexo> femenino </ sexo> </serem> <user Id = "3"> <name> wh </name> <ge> 24 </dge> <exe> masculino </ sexo> </serem> </sersoners>
Primero defina la interfaz para el análisis del documento XML:
/*** @Author Alexia** Defina la interfaz para el análisis del documento XML*/Public Interface XMLDocument {/*** PARSE XML Document** @param FileName* Archivo Nombre de ruta completa*/public void parserxml (String filename);} 1. Ejemplo de DOM
paquete com.xml; import java.io.filenotfoundexception; import java.io.fileOutputStream; import java.io.ioexception; import java.io.printwriter; import javax.xml.parsers.documentbuilder; import javax.xml.parsers.documentbuilder; javax.xml.parsers.parserconfigurationException; import javax.xml.transform.outputKeys; import javax.xml.transform.transformer; import javax.xml.transform.transformerConfigurationException; import javax.xml.transform.transformerException; import; javax.xml.transform.transformerFactory; import javax.xml.transform.dom.domsource; import javax.xml.transform.stream.streamresult; import og.w3c.dom.document; import org.w3c.dom.element; import org.w3c.dom.node; importar org.w3c.c.dom.dom.dom.dom org.xml.Sax.SaxException;/** * @Author Alexia * * DOM PARSING XML Documento */public class DomDemo implementa xmlDocument {Documento privado Documento; public void parserxml (string filename) {try {documentBuilderFactory dbf = documentBuilderFactory.newinStance (); DocumentBuilder db = dbf.newDocumentBuilder (); Documento documento = db.parse (nombre de archivo); Nodelist users = document.getChildNodes (); for (int i = 0; i <users.getLength (); i ++) {nodo user = users.item (i); Nodelist userInfo = user.getChildNodes (); for (int j = 0; j <userInfo.getLength (); j ++) {nodo nodo = userInfo.item (j); Nodelist usermeta = node.getChildNodes (); for (int k = 0; k <usermeta.getLength (); k ++) {if (usermeta.item (k) .getNodeName ()! = "#text") system.out.println (usermeta.item (k) .getNodenEnnodeNeN } System.out.println (); }}} Catch (FileNotFoundException e) {E.PrintStackTrace (); } catch (parserconfigurationException e) {E.PrintStackTrace (); } Catch (SaxException e) {E.PrintStackTrace (); } Catch (SaxException e) {E.PrintStackTrace (); } Catch (SaxException e) {E.PrintStackTrace (); } catch (ioException e) {E.PrintStackTrace (); }}} 2. Ejemplo de saxo
paquete com.xml; import java.io.fileInputStream; import java.io.filenotfoundexception; import java.io.fileOutputStream; import java.io.ioException; import java.io.inputstream; import java.io.outputStream; import java.io.stringwriter; import; javax.xml.parsers.parserConfigurationException; import javax.xml.parsers.saxparser; import javax.xml.parsers.saxparserFactory; import javax.xml.transform.outputkeys; import javax.xml.transform.result; import javax.xmll.transformer; importar; importador; importador; importador; javax.xml.transform.transformerConFigurException; import javax.xml.transform.sax.saxtransformerFactory; import javax.xml.transform.sax.transformerHandler; import javax.xml.transform.stream.streamResult; import org.xml.sax.sax.. org.xml.Sax.SaxException; import org.xml.sax.helpers.attributesImpl; import org.xml.sax.helpers.defaulthandler;/** * @author alexia * * sax parsing xml documento */public classxDemo implementos xmldocumento {público void parserxml (sorteo de parsaje) SaxParserFactory saxfac = saxparserFactory.newinstance (); intente {saxparser saxparser = saxfac.newsaxparser (); InputStream es = nuevo FileInputStream (nombre de archivo); saxparser.parse (es, nuevo mySaxHandler ()); } catch (parserconfigurationException e) {E.PrintStackTrace (); } Catch (SaxException e) {E.PrintStackTrace (); } catch (FileNotFoundException e) {E.PrintStackTrace (); } catch (ioException e) {E.PrintStackTrace (); }}} class mySaxHandler extiende DeFaulthandler {boolean Hasattribute = false; Atributos atributos = nulo; public void startDocument () lanza SaxException {// System.out.println ("El documento ha comenzado a imprimir"); } public void endDocument () lanza SaxException {// System.out.println ("El documento ha finalizado la impresión"); } public void startelement (string uri, string localName, string qname, atributes atributes) lanza saxException {if (qname.equals ("users")) {return; } if (qname.equals ("usuario")) {return; } if (attributes.getLength ()> 0) {this.attributes = atributes; this.hasattribute = true; }} public void endelement (string uri, string localName, string qname) lanza saxException {if (Hasattribute && (attributes! = null)) {for (int i = 0; i <atributes.getLenglengment.; i ++) {system.out.print (atributes.getqname (0) + ":" + atributes.getvalue (0); }}} public void caracteres (char [] ch, int inicio, int longitud) arroja saxexception {system.out.print (nueva cadena (ch, inicio, longitud)); }} 3. Ejemplo de JDOM
paquete com.xml; import java.io.filenotfoundException; import java.io.fileOutputStream; import java.io.ioException; import java.util.list; importar org.jdom2.Document; import org.jdom2.element; import org.jdom2.jdomexception; import org.jdom2.output.xmloutputter;/** * @Author Alexia * * JDom Parsing XML Documentos * */public Class JDomDemo implementa xmlDocument {public void parserxml (string fileName) {saxBuilder builder = new saxBuilder (); intente {documento documento = builder.build (nombre de archivo); Elemento users = document.getRootElement (); List userList = users.getChildren ("usuario"); for (int i = 0; i <userList.size (); i ++) {element user = (element) userList.get (i); List userInfo = user.getChildren (); for (int j = 0; j <userInfo.size (); j ++) {system.out.println ((((elemento) userInfo.get (j)). getName () + ":" + ((elemento) userInfo.get (j)). getValue ()); } System.out.println (); }} Catch (JDomException e) {E.PrintStackTrace (); } catch (ioException e) {E.PrintStackTrace (); }}} 4. Ejemplo dom4j
paquete com.xml; import java.io.file; import java.io.filewriter; import java.io.ioException; import java.io.writer; import java.util.iterator; import org.dom4j.document; import org.dom4j.DocumentException; import org.dom4j.documenthelper; import og.dom.Ement; org.dom4j.io.saxreader; import org.dom4j.io.xmlwriter;/** * @author alexia * * dom4j parse xml documento */public class dom4jdemo implements xmlDocument {public void parserxml (string fileNeMame) {archivo inputxml = nuevo archivo); Saxreader saxreader = new saxreader (); intente {documento documento = saxreader.read (inputxml); Elemento users = document.getRootElement (); para (iterator i = users.ElementIterator (); i.hasnext ();) {elemento user = (element) i.next (); for (iterator j = user.elementIterator (); J.HasNext ();) {element node = (elemento) J.Next (); System.out.println (node.getName () + ":" + node.gettext ()); } System.out.println (); }} catch (DocumentException e) {System.out.println (e.getMessage ()); }}}Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.