Procesando XML en Java [Xerces]

Procesar archivos XML usando Xerces

Para procesar el archivo XML del ejemplo anterior, también utilizaremos DOM y un bean de la clase Descargas.java. Este tipo de procedimientos es mucho más sencillo, y se compone básicamente de los siguientes pasos:

• Parsear el archivo XML (crear el objeto Document)
• Obtener los datos del documento XML
• Imprimir los datos del documento

En este caso, la clase que realizar el parseo de XML es ProcesarXML.java, y en su constructor invocamos los métodos que realizan los 3 pasos anteriores:

public ProcesarXML() {
    listadoDescargas = new ArrayList();
    // A. Parsear el archivo XML
    parsearArchivoXml();
    // B. Obtener datos del documento XML
    parsearDocumento();
    // C. Imprimir los resultados
    imprimirResultados();
}

Pero veamos más a fondo lo que hacen cada uno de estos métodos. Por ejemplo, el método parsearArchivoXml():

public void parsearArchivoXml() {
    // 1. Obteher el objeto DocumentBuilderFactory
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    try {
        // 2. Usar DocumentBuilderFactory para crear un DocumentBuilder
        DocumentBuilder db = dbf.newDocumentBuilder();
        // 3. Parsear a partir de un archivo
        dom = db.parse("descargas.xml");
    } catch (ParserConfigurationException pce) {
    // bla, bla, bla, catchapunchis...
}

1. Crea un objeto DocumentBuilderFactory con el que se crearán el documento XML, pero antes…
2. … se utiliza para crear un objeto DocumentBuilder, el cual mediante el…
3. … método parse() genera un documento a partir de un archivo.

Ahora vamos con el método más importante, parsearDocumento(), el cual extrae los datos del documento XML y los almacena en beans de la clase Descargas:

public void parsearDocumento() {
    // 1. Obtener el documento raiz
    Element docEle = dom.getDocumentElement();
    // 2. Obtener un nodelist de elementos <descarga>
    NodeList nl = docEle.getElementsByTagName("descarga");
    if (nl != null && nl.getLength() > 0) {
        for (int i = 0; i < nl.getLength(); i++) {
            // a. Obtener el elemento
            Element elemento = (Element) nl.item(i);
            // b. Obtener el objeto empleado
            Descargas descarga = obtenerDescarga(elemento);
            // c. Aniadirlo a la lista
            listadoDescargas.add(descarga);
        }
    }
}

1. Se crea un objeto Element, apartir del documento XML
2. Se crea un objeto NodeList, el cual contiene una lista de los nodos <descarga>, que luego serán procesados uno a uno en un ciclo for:
   1. Se obtiene el elmento que el nodo actual represente
   2. Se genera un bean Descarga con la información de dicho elemento (utilizando el método obtenerDescarga())
   3. Se agrega a la lista de beans

Pero… ¿cómo extrae los datos el método obtenerDescarga()? Veamos:

public Descargas obtenerDescarga(Element elemento) {
    int id = Integer.parseInt(elemento.getAttribute("id"));
    String titulo = obtenerTexto(elemento, "titulo");
    String ruta = obtenerTexto(elemento, "ruta");
    int hits = obtenerEntero(elemento, "hits");
    // Crear un objeto Descargas con los datos recibidos
    Descargas d = new Descargas(id, titulo, ruta, hits);
    return d;
}
private String obtenerTexto(Element elemento, String nombreEtiqueta) {
    String texto = null;
    NodeList nl = elemento.getElementsByTagName(nombreEtiqueta);
    if (nl != null && nl.getLength() > 0) {
        Element el = (Element) nl.item(0);
        texto = el.getFirstChild().getNodeValue();
    }
    return texto;
}

Observemos cómo, utilizando el método getAttribute podemos obtener el valor de un atributo de un elemento. Así, si por ejemplo tenemos el elemento <descarga id=”20″></descarga>, la instrucción elemento.getAttribute(“id”) devolverá una cadena cuyo valor es: 20. Más adelante, en el método obtenerTexto, podemos observar cómo obtener el valor de los nodos hijos de un elemento (usando el método getNodeValue()). Así, si por ejemplo tenemos un elemento de este tipo <padre><hijo>gay</hijo></padre>, tendríamos que hacer lo siguiente para determinar el valor de la etiqueta <hijo>:

• Crear un objeto NodeList, que contenga el listado de etiquetas <hijo> (puesto que un padre puede tener muchos hijos, por desgracia). [ NodeList nl = el.getElementsByTagName("hijo");]
• Crear un elemento por cada hijo; aunque en este ejemplo solo necesitamos el primer hijo [Element el = (Element) nl.item(0);]
• Obtener los datos del hijo [texto = el.getFirstChild().getNodeValue();] y al final, nos daríamos cuenta que el hijo es gay Vaya decepción…

Lo demás, es decir, imprimir los resultados no creo que tenga que explicarlo demasiado. Se utiliza un método toString() sobrecargado para imprimirlos en la consola:

public void imprimirResultados() {
    Iterator it = listadoDescargas.iterator();
    while (it.hasNext())
        System.out.println(it.next().toString());
}

Importante: cómo ejecutar los ejemplos

Puesto que estos ejercicios en java utilizan la librería xerces, es necesario descargarla de la página oficial. Luego de tener el archivo .jar, podríamos compilarlo y ejecutarlo usando los siguientes comandos:

#en linux
javac -cp .:/ruta/xercesImpl.jar GenerarXML.java
java -cp .:/ruta/xercesImpl.jar GenerarXML
javac -cp .:/ruta/xercesImpl.jar ProcesarXML.java
java -cp .:/ruta/xercesImpl.jar ProcesarXML
#en windows
javac -cp “.;c:\xercesImpl.jar” GenerarXML.java
java -cp “.;c:\xercesImpl.jar” GenerarXML
javac -cp “.;c:\xercesImpl.jar” ProcesarXML.java
java -cp “.;c:\xercesImpl.jar” ProcesarXML

Enlaces interesantes y descarga de código…

• Descargar código fuente de los ejemplos
• XML en Java – APIs y Parsers
  
• Página oficial de xerces [descargas]
• Parsers XML
• Ejemplo escritura con xerces
• Ejemplo lectura con xerces

23 Comentarios | deja el tuyo