Procesamiento de Documentos XML con Java: DOM y SAX

El procesamiento de documentos XML es fundamental en muchas aplicaciones modernas para manejar datos estructurados. En Java, los modelos principales para procesar XML son DOM (Document Object Model) y SAX (Simple API for XML). Ambos ofrecen enfoques distintos, cada uno adecuado para diferentes escenarios.

En este artículo, exploraremos las características, diferencias y aplicaciones de DOM y SAX, junto con ejemplos prácticos para implementarlos en tus proyectos.

---

¿Qué es un Documento XML?

Un documento XML (Extensible Markup Language) organiza datos en una estructura jerárquica que permite representarlos de forma legible para máquinas y humanos. Ejemplo de un archivo XML:

<libros>
    <libro id="1">
        <titulo>Java Básico</titulo>
        <autor>Juan Pérez</autor>
        <precio>19.99</precio>
    </libro>
    <libro id="2">
        <titulo>Programación Avanzada</titulo>
        <autor>María Gómez</autor>
        <precio>29.99</precio>
    </libro>
</libros>

---

Modelos para Procesar XML: DOM y SAX

DOM (Document Object Model)

DOM es un modelo basado en un árbol en memoria que representa todo el documento XML.

Características:

• Carga el documento completo en memoria.
• Permite navegar, modificar y acceder directamente a cualquier nodo.
• Fácil de usar, pero consume más memoria, especialmente con documentos grandes.

Aplicaciones:

• Recomendado para documentos pequeños o cuando se necesita acceso aleatorio a los datos.

---

SAX (Simple API for XML)

SAX es un modelo basado en eventos. Lee el XML secuencialmente y genera eventos a medida que encuentra elementos, etiquetas o texto.

Características:

• No carga todo el documento en memoria.
• Más eficiente en memoria que DOM.
• No permite modificar el documento ni acceder a partes específicas sin volver a procesar.

Aplicaciones:

• Ideal para documentos grandes o cuando solo necesitas procesar partes del XML.

---

Diferencias entre DOM y SAX

Característica	DOM	SAX
Tipo de procesamiento	Basado en árbol en memoria	Basado en eventos
Uso de memoria	Alto, ya que carga todo el documento	Bajo, procesa secuencialmente
Acceso aleatorio	Sí	No
Facilidad de uso	Alta	Media
Modificación del XML	Sí	No

---

Procesamiento con DOM en Java

Para usar DOM, Java proporciona el paquete javax.xml.parsers.

Ejemplo: Leer y Mostrar un Documento XML con DOM

import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.File;

public class LeerXMLDOM {
    public static void main(String[] args) {
        try {
            // Crear el objeto DocumentBuilder
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();

            // Cargar el documento XML
            Document doc = builder.parse(new File("libros.xml"));
            doc.getDocumentElement().normalize();

            // Obtener los nodos "libro"
            NodeList listaLibros = doc.getElementsByTagName("libro");
            for (int i = 0; i < listaLibros.getLength(); i++) {
                Node libro = listaLibros.item(i);
                if (libro.getNodeType() == Node.ELEMENT_NODE) {
                    Element elemento = (Element) libro;
                    System.out.println("ID: " + elemento.getAttribute("id"));
                    System.out.println("Título: " + elemento.getElementsByTagName("titulo").item(0).getTextContent());
                    System.out.println("Autor: " + elemento.getElementsByTagName("autor").item(0).getTextContent());
                    System.out.println("Precio: " + elemento.getElementsByTagName("precio").item(0).getTextContent());
                    System.out.println();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

---

Procesamiento con SAX en Java

Para usar SAX, Java proporciona el paquete org.xml.sax.

Ejemplo: Leer un Documento XML con SAX

import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.File;

public class LeerXMLSAX {
    public static void main(String[] args) {
        try {
            // Crear el objeto SAXParser
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser saxParser = factory.newSAXParser();

            // Definir el manejador
            DefaultHandler handler = new DefaultHandler() {
                boolean esTitulo = false;
                boolean esAutor = false;
                boolean esPrecio = false;

                @Override
                public void startElement(String uri, String localName, String qName, Attributes attributes) {
                    if (qName.equalsIgnoreCase("titulo")) {
                        esTitulo = true;
                    } else if (qName.equalsIgnoreCase("autor")) {
                        esAutor = true;
                    } else if (qName.equalsIgnoreCase("precio")) {
                        esPrecio = true;
                    }
                }

                @Override
                public void characters(char[] ch, int start, int length) {
                    if (esTitulo) {
                        System.out.println("Título: " + new String(ch, start, length));
                        esTitulo = false;
                    } else if (esAutor) {
                        System.out.println("Autor: " + new String(ch, start, length));
                        esAutor = false;
                    } else if (esPrecio) {
                        System.out.println("Precio: " + new String(ch, start, length));
                        esPrecio = false;
                    }
                }

                @Override
                public void endElement(String uri, String localName, String qName) {
                    if (qName.equalsIgnoreCase("libro")) {
                        System.out.println();
                    }
                }
            };

            // Procesar el fichero XML
            saxParser.parse(new File("libros.xml"), handler);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

---

¿Qué Modelo Deberías Usar?

Usa DOM si:

• Necesitas modificar el contenido del documento XML.
• El tamaño del XML es pequeño o moderado.
• Necesitas acceso aleatorio a nodos específicos.

Usa SAX si:

• Trabajas con documentos XML grandes.
• Solo necesitas procesar partes específicas del documento.
• La eficiencia en memoria es una prioridad.

---

Conclusión

El procesamiento de documentos XML en Java ofrece flexibilidad mediante los modelos DOM y SAX, cada uno con sus ventajas y limitaciones. Elegir el modelo adecuado dependerá de los requisitos de tu proyecto, como el tamaño del fichero y el tipo de operaciones que necesitas realizar. Con los ejemplos proporcionados aquí, tendrás una base sólida para comenzar a trabajar con XML en Java. ¡Manos a la obra!