¿Cuál es la mejor biblioteca para el análisis de XML en java

Estoy buscando en la biblioteca de Java para analizar XML (configuración compleja y archivos de datos), busqué en Google un poco pero no pude encontrar otro que no sea dom4j (Parece que están trabajando en V2). He echado un vistazo a la configuración de commons pero no hice ‘Me gustó’, otros proyectos de apache en XML parecen estar en hibernación. No he evaluado dom4j solo, pero solo quería saber: ¿Java tiene otra (buena) biblioteca de análisis XML de código abierto? y ¿cómo es tu experiencia con dom4j?

Después de la respuesta de @ Voo, permítame preguntarle a otro: ¿Debería usar Java en las clases creadas o en cualquier biblioteca como dom4j? ¿Cuáles son las ventajas?

En realidad, Java admite 4 métodos para analizar XML de la caja:

DOM Parser / Builder: toda la estructura XML se carga en la memoria y puede usar los conocidos métodos DOM para trabajar con ella. DOM también le permite escribir en el documento con transformaciones Xslt. Ejemplo:

public static void parse() throws ParserConfigurationException, IOException, SAXException { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setValidating(true); factory.setIgnoringElementContentWhitespace(true); DocumentBuilder builder = factory.newDocumentBuilder(); File file = new File("test.xml"); Document doc = builder.parse(file); // Do something with the document here. } 

Analizador SAX: solo para leer un documento XML. El analizador de Sax recorre el documento y llama a los métodos de callback del usuario. Hay métodos para el inicio / finalización de un documento, elemento, etc. Están definidos en org.xml.sax.ContentHandler y hay una clase auxiliar vacía DefaultHandler.

 public static void parse() throws ParserConfigurationException, SAXException { SAXParserFactory factory = SAXParserFactory.newInstance(); factory.setValidating(true); SAXParser saxParser = factory.newSAXParser(); File file = new File("test.xml"); saxParser.parse(file, new ElementHandler()); // specify handler } 

StAx Reader / Writer: Esto funciona con una interfaz orientada al flujo de datos. El progtwig pregunta por el siguiente elemento cuando está listo como un cursor / iterador. También puedes crear documentos con él. Leer documento:

 public static void parse() throws XMLStreamException, IOException { try (FileInputStream fis = new FileInputStream("test.xml")) { XMLInputFactory xmlInFact = XMLInputFactory.newInstance(); XMLStreamReader reader = xmlInFact.createXMLStreamReader(fis); while(reader.hasNext()) { reader.next(); // do something here } } } 

Escribir documento:

 public static void parse() throws XMLStreamException, IOException { try (FileOutputStream fos = new FileOutputStream("test.xml")){ XMLOutputFactory xmlOutFact = XMLOutputFactory.newInstance(); XMLStreamWriter writer = xmlOutFact.createXMLStreamWriter(fos); writer.writeStartDocument(); writer.writeStartElement("test"); // write stuff writer.writeEndElement(); } } 

JAXB: la implementación más reciente para leer documentos XML: es parte de Java 6 en v2. Esto nos permite serializar objetos Java desde un documento. Lees el documento con una clase que implementa una interfaz para javax.xml.bind.Unmarshaller (obtienes una clase para esto de JAXBContext.newInstance). El contexto debe inicializarse con las clases utilizadas, pero solo debe especificar las clases raíz y no debe preocuparse por las clases referenciadas estáticas. Utiliza anotaciones para especificar qué clases deben ser elementos (@XmlRootElement) y qué campos son elementos (@XmlElement) o atributos (@XmlAttribute, ¡qué sorpresa!)

 public static void parse() throws JAXBException, IOException { try (FileInputStream adrFile = new FileInputStream("test")) { JAXBContext ctx = JAXBContext.newInstance(RootElementClass.class); Unmarshaller um = ctx.createUnmarshaller(); RootElementClass rootElement = (RootElementClass) um.unmarshal(adrFile); } } 

Escribir documento:

 public static void parse(RootElementClass out) throws IOException, JAXBException { try (FileOutputStream adrFile = new FileOutputStream("test.xml")) { JAXBContext ctx = JAXBContext.newInstance(RootElementClass.class); Marshaller ma = ctx.createMarshaller(); ma.marshal(out, adrFile); } } 

Ejemplos descaradamente copiados de algunas diapositivas de conferencias antiguas 😉

Editar: Acerca de “¿Qué API debería usar?”. Bueno, eso depende, no todas las API tienen las mismas capacidades que las que ves, pero si tienes control sobre las clases que usas para mapear el documento XML JAXB es mi solución favorita, realmente elegante y simple (aunque no la he usado para documentos realmente grandes, podría ser un poco complejo). SAX es bastante fácil de usar también y solo mantente alejado de DOM si no tienes una buena razón para usarlo: API vieja y torpe en mi opinión. No creo que existan bibliotecas modernas de terceros que incluyan algo especialmente útil que falte en el STL y las bibliotecas estándar tienen las ventajas habituales de ser extremadamente probadas, documentadas y estables.

Java admite dos métodos para analizar XML de forma inmediata.

SAXParser

Puede usar este analizador si desea analizar grandes archivos XML y / o no desea usar mucha memoria.

http://download.oracle.com/javase/6/docs/api/javax/xml/parsers/SAXParserFactory.html

Ejemplo: http://www.mkyong.com/java/how-to-read-xml-file-in-java-sax-parser/

DOMParser

Puede usar este analizador si necesita hacer consultas XPath o necesita tener el DOM completo disponible.

http://download.oracle.com/javase/6/docs/api/javax/xml/parsers/DocumentBuilderFactory.html

Ejemplo: http://www.mkyong.com/java/how-to-read-xml-file-in-java-dom-parser/

El punto de Nikita es excelente: no confundas lo maduro con lo malo. XML no ha cambiado mucho.

JDOM sería otra alternativa a DOM4J.

No necesita una biblioteca externa para analizar XML en Java. Java viene con implementaciones integradas para SAX y DOM por edades.

Si desea una API similar a DOM, es decir, una donde el analizador XML convierte el documento en un árbol de nodos Elemento y Atributo, entonces hay al menos cuatro para elegir: DOM en sí, JDOM, DOM4J y XOM. La única razón posible para usar DOM es porque se percibe como un estándar y se proporciona en el JDK: en todos los demás aspectos, los demás son todos superiores. Mi propia preferencia, por su combinación de simplicidad, potencia y rendimiento, es XOM.

Y, por supuesto, hay otros estilos de procesamiento: interfaces de analizador de bajo nivel (SAX y StAX), interfaces de enlace de objetos de datos (JAXB) y lenguajes declarativos de alto nivel (XSLT, XQuery, XPath). Lo mejor para usted depende de los requisitos de su proyecto y su gusto personal.

Para gente interesada en usar JDOM, pero temerosa de que no se haya actualizado por un tiempo (especialmente sin aprovechar los generics de Java), hay un fork llamado CoffeeDOM que aborda exactamente estos aspectos y moderniza la API de JDOM, lea más aquí:

http://cdmckay.org/blog/2011/05/20/introducing-coffeedom-a-jdom-fork-for-java-5/

y descárguelo de la página del proyecto en:

https://github.com/cdmckay/coffeedom

VTD-XML es la libra de análisis XML de trabajo pesado … es mejor que otros en prácticamente todos los sentidos … aquí hay un documento de 2013 que analiza todos los marcos de procesamiento XML disponibles en la plataforma Java …

http://sdiwc.us/digitlib/journal_paper.php?paper=00000582.pdf