En realidad, Java admite 4 métodos para analizar XML de forma inmediata:
Analizador / generador de DOM: toda la estructura XML se carga en la memoria y puede utilizar 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 Sax ejecuta el documento y llama a los métodos de devolución de llamada del usuario. Existen métodos para iniciar / finalizar 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 programa solicita 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 de un documento. Usted lee el documento con una clase que implementa una interfaz para javax.xml.bind.Unmarshaller (obtiene una clase para esto de JAXBContext.newInstance). El contexto debe inicializarse con las clases utilizadas, pero solo tiene que especificar las clases raíz y no tener que 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 copiados descaradamente de algunas diapositivas de conferencias antiguas ;-)
Editar: Acerca de "¿qué API debo usar?". Bueno, depende: no todas las API tienen las mismas capacidades que ves, pero si tienes control sobre las clases que usas para mapear el documento XML, JAXB es mi solución personal favorita, realmente elegante y simple (aunque no la he usado para documentos realmente grandes, podría ser un poco complejo). SAX también es bastante fácil de usar y manténgase alejado de DOM si no tiene una buena razón para usarlo: API antigua y torpe en mi opinión. No creo que haya bibliotecas modernas de terceros que presenten algo especialmente útil que falte en el STL y las bibliotecas estándar tienen las ventajas habituales de estar extremadamente bien probadas, documentadas y estables.