PHP posee una completa API para la manipulación de archivos XML. Sin embargo, algunas veces queremos hacer cosas muy simples y no vale la pena construir manualmente un script que sirva de parser de un archivo XML. En esos casos, podemos hacer uso de una función llamada xml2array.

La idea es bastante simple: le pasamos como argumento el string de un archivo XML y nos retorna un array asociativo con los datos del mismo. Los pasos son los siguientes:

0. Descargar la función

Lo primero es descargar la función de aquí. Copias el código PHP y lo pones en un archivo con nombre xml2array.php

1. Ejecutar la función [ejemplo]

Debemos usar la función file_get_contents para obtener el string con el XML que pasaremos como parámetro a la función. Suponiendo que tenemos este archivo XML:

<?xml version="1.0" encoding="iso-8859-1"?>
<distros type="linux">
    <nombre id="1">Gentoo</nombre>
    <nombre id="2">Arch</nombre>
    <nombre id="3">Exherbo</nombre>
</distros>

Podríamos usar xml2array así:

<?php
require("xml2array.php");
$contenido = file_get_contents('datos.xml');
$resultado = xml2array($contenido);
var_dump($resultado);
?>

El resultado sería el dump del array:

array(2) {
  ["distros"]=>
  array(1) {
    ["nombre"]=>
    array(6) {
      [0]=>
      string(6) "Gentoo"
      [1]=>
      string(4) "Arch"
      ["0_attr"]=>
      array(1) {
        ["id"]=>
        string(1) "1"
      }
      ["1_attr"]=>
      array(1) {
        ["id"]=>
        string(1) "2"
      }
      [2]=>
      string(7) "Exherbo"
      ["2_attr"]=>
      array(1) {
        ["id"]=>
        string(1) "3"
      }
    }
  }
  ["distros_attr"]=>
  array(1) {
    ["type"]=>
    string(5) "linux"
  }
}

Veamos un ejemplo un poco más avanzado. Vamos a procesar un documento XML que proporciona Mercado Libre con productos a la venta; además vamos a mostrar un listado HTML con dichos productos:

<?php
require("xml2array.php");
$contenido = file_get_contents('http://www.mercadolibre.com.co/jm/searchXml?as_categ_id=1648');
$resultado = xml2array($contenido);
$items = $resultado['response']['listing']['items']['item'];
foreach($items as $item)
    if(isset($item['title'])){
        echo "<p><a href='{$item['link']}'>";
        echo "<img src='{$item['image_url']}'/><br/>";
        echo "<b>{$item['title']}</b></a><br>";
        echo "<em>{$item['subtitle']}</em><br>";
        echo "<em>{$item['currency']}</em> {$item['price']}</p>";
    }
?>

Ejecutando el ejemplo anterior obtendremos algo como lo siguiente:

Descarga de los ejemplos

Puedes descargar los archivos usados en los ejemplos anteriores. Ten en cuenta que la versión de la función que está en la descarga es la última a la fecha (1 de febrero de 2010). Aunque funciona muy bien, los autores tienden a actualizarla, así que podrías echar un vistazo a la página oficial en busca de nuevas versiones.

Descargar código fuente

En este artículo utilizaré un pequeño ejemplo para explicar cómo manipular documentos XML usando XERCES Java Parser. En este primer ejemplo usaré el API DOM, y la utilizaremos para generar un archivo XML y guardarlo en disco, y posteriormente procesaremos (parsearemos) dicho archivo para leer su información.

Nota: Sino tienes claro qué es un parser XML, qué es un API XML para Java y cuáles están disponibles, o aún tienes algunas dudas en relación con Java y XML, puedes/debes leer este pequeño artículo.

Generación de archivos XML usando Xerces

En esta ocasión utilizaremos el API DOM para generar un archivo XML, que guardará información acerca de un listado de descargas ficticio. Como resultado, nuestra aplicación generará el siguiente documento XML:

<?xml version="1.0" encoding="ISO-8859-1"?>
<Descargas>
    <descarga id="1">
        <titulo>Libros Java</titulo>
        <ruta>http://casidiablo.net/libros.zip</ruta>
        <hits>2546</hits>
    </descarga>
    <descarga id="2">
        <titulo>Libros C Sharp</titulo>
        <ruta>http://casidiablo.net/libroscs.zip</ruta>
        <hits>1654</hits>
    </descarga>
</Descargas>

En el cual tenemos un elemento llamado descarga que contiene un atributo llamado id; además posee tres nodos hijos: titulo, ruta y hits. Teniendo en cuenta esto crearemos un pequeño bean (clase Descargas.java), que contiene dichos datos:

public class Descargas {
    //Variables
    private int id;
    private String titulo;
    private String ruta;
    private int hits;
    //Constructor de la clase
    public Descargas(int id, String titulo, String ruta, int hits){
        this.id = id;
        this.titulo = titulo;
        this.ruta = ruta;
        this.hits = hits;
    }
    //Metodos Setters y Getters
    public void setID(int id) {
        this.id = id;
    }
    public int getID() {
        return this.id;
    }
    //etc... (AL FINAL DEL ARTÍCULO PUEDES DESCARGAR EL EJEMPLO COMPLETO)
}

Más adelante utilizaremos la clase GenerarXML.java, quien se encargará de crear el archivo XML. De momento detallaremos los pasos básicos para realizar tareas de ese tipo:

• Crear los objetos a cargar en el documento XML (en nuestro ejemplo, objetos tipo Descargas)
• Crear un objeto Document que contendrá el documento XML
• Generar los datos XML para los objetos creados en primer paso
• Crear un archivo (o salida) XML

En nuestro ejemplo, la invocación a los métodos que realizan estas tareas se encuentra en el método main:

public static void main(String args[])
{
   GenerarXML generador = new GenerarXML();
   // A. Crear el objeto(s) a Descargas
   Descargas descarga = new Descargas(1, "Libros Java", "http://casidiablo.net/libros.zip", 2546);
   Descargas descarga2 = new Descargas(2, "Libros C Sharp", "http://casidiablo.net/libroscs.zip", 1654);
   // B. Generar un documento XML usando Document
   generador.generaDocumentoXML();
   // C. Generar XML para el/los objeto(s)
   generador.generarDocumentoXMLDescarga(descarga);
   generador.generarDocumentoXMLDescarga(descarga2);
   // D. Obtener el código XML
   String textoXML = generador.obtenerTextoXML();
   generador.guardarDocumentoXML(textoXML);
   System.out.println(textoXML);
}

Veamos con más profundidad cómo funciona el segundo paso (Crear un objeto Document que contendrá el documento XML):

public void generaDocumentoXML() {
    try {
        // 1. Crear objeto DocumentBuilderFactory
        DocumentBuilderFactory dbFactory = DocumentBuilderFactoryImpl.newInstance();
        // 2. A partir del objeto DocumentBuilderFactory crear un objeto DocumentBuilder
        DocumentBuilder docBuilder = dbFactory.newDocumentBuilder();
        // 3. Generar el documento XML
        documentoXML = docBuilder.newDocument();
    } catch (Exception e) {
        System.out.println("Error : " + e);
    }
    // 4. Crear el elemento "descargas"
    descarga = documentoXML.createElement(TAG_DESCARGAS);
    // 5. Agregar al documento principal
    documentoXML.appendChild(descarga);
}

1. Creamos un objeto DocumentBuilderFactory, utilizando la el método newInstance() de la clase DocumentBuilderFactoryImpl.
2. Creamos un objeto DocumentBuilder, con el que crearemos el objeto Document
3. Generamos el documento usando el método newDocument() de DocumentBuilder
4. Se crea el elemento raíz del documento XML y,
5. Se añade dicho elemento al objeto Document

Después de esto, ya tenemos listo nuestro objeto Document en donde crearemos el documento XML. El paso siguiente será alimentar el documento XML con la información de nuestros objetos, lo cual se hace en el método generarDocumentoXMLDescarga:

public void generarDocumentoXMLDescarga(Descargas descargas)
{
    Element elemento;
    Element item;
    // 1. Crear elemento
    elemento = documentoXML.createElement(TAG_DESCARGA);
    // 2. Asignar un atributo
    elemento.setAttribute(TAG_ID, ""+descargas.getID());
    // 3. Aniadir elemento al documento
    descarga.appendChild(elemento);
    // a. Crear item
    item = documentoXML.createElement(TAG_TITULO);
    // b. Asignar un dato al item
    item.appendChild(documentoXML.createTextNode(descargas.getTitulo()));
    // c. Aniadir el item
    elemento.appendChild(item);
    // todos los items se crean sigiuendo el patron a, b, c
    // el código fuente completo se encuentra
    //disponible para su descarga al final de este artículo
}

1. Se crea un elemento (<descarga>)
2. Se asigna un atributo al elemento (<descarga id=”xxx”>)
3. Se añade el elemento al documento XML; posteriormente tenemos la creación de items, para dicho elemento:
   a. Se crea el item (<titulo></titulo>)
   b. Se asigna un dato al item (<titulo>datos, muchos datos</titulo>)
   c. Se añade el item al elemento (<descarga id=”xxx”><titulo>datos, muchos datos</titulo></descarga>)

Para generar una salida del documento XML se utilizamos el método generaTextoXML() el cual devuelve un string que contiene el documento XML:

private String generaTextoXML() {
   StringWriter strWriter = null;
   XMLSerializer seliarizadorXML = null;
   OutputFormat formatoSalida = null;
   try {
      seliarizadorXML = new XMLSerializer();
      strWriter = new StringWriter();
      formatoSalida = new OutputFormat();
      // 1. Establecer el formato
      formatoSalida.setEncoding(XML_ENCODING);
      formatoSalida.setVersion(XML_VERSION);
      formatoSalida.setIndenting(true);
      formatoSalida.setIndent(4);
      // 2. Definir un objeto donde se generara el codigo
      seliarizadorXML.setOutputCharStream(strWriter);
      // 3. Aplicar el formato
      seliarizadorXML.setOutputFormat(formatoSalida);
      // 4. Serializar documento XML
      seliarizadorXML.serialize(documentoXML);
      strWriter.close();
   } catch (IOException ioEx) {
      System.out.println("Error : " + ioEx);
   }
   return strWriter.toString();
}

1. Utilizando un objeto de la clase OutputFormat, se asigna el tipo de codificación y versión del archivo XML, activamos la identación y la ponemos a 4 espacios
2. Un objeto XMLSerializer escribe los datos del documento XML sobre un objeto de flujo de salida, en este caso un objeto StringWriter.
3. Asignamos el tipo de formato que el objeto XMLSerializer generará
4. Generamos el documento XML

El string generado por generaTextoXML() podemos imprimirlo directamente en pantalla, o escribirlo en un archivo como lo hace el método guardarDocumentoXML():

public void guardarDocumentoXML(String texto) {
   try {
      OutputStream fout = new FileOutputStream(NOMBRE_ARCHIVO_XML);
      OutputStream bout = new BufferedOutputStream(fout);
      OutputStreamWriter out = new OutputStreamWriter(bout, JAVA_ENCODING);
      out.write(texto);
      out.flush();
      out.close();
   } catch (UnsupportedEncodingException e) {
   //etc, bla, bla, catchichurri
}

El método guardarDocumentoXML() un objeto FileOutputStream para escribir los datos del documento XML en un archivo (cuyo nombre define la variable NOMBRE_ARCHIVO_XML).

Continúa leyendo la segunda parte, en donde aprenderemos a Parsear archivos XML. Vamos parce!

El uso de XML es primordial al momento de desarrollar software, sobre todo empresarial, y Java por supuesto cuenta con APIs y Parsers que facilitan el trabajo con este tipo de documentos. A través de este pequeño artículo aprenderemos qué APIs y Parsers existen, y cual debemos escoger al momento de desarrollar una aplicación. En futuros artículos pondré algunos ejemplos. Pero, primero lo primero:

¿Qué es XML?

XML significa Extensible Markup Language, es un metalenguaje extensible de etiquetas desarrollado por el W3C. XML no es realmente un lenguaje en particular, sino una manera de definir lenguajes para diferentes necesidades. Y por tanto tiene algunas ventajas:

• Es extensible (una vez que un xml fue diseñado y puesto en producción, es posible extenderlo con la adición de nuevas etiquetas de modo que los antiguos consumidores puedan continuar utilizando el servicio sin complicación alguna).
• El analizador es un componente estándar, no es necesario crear un analizador específico para cada lenguaje. Esto posibilita el empleo de uno de los tantos disponibles. De esta manera se evitan bugs y se acelera el desarrollo de la aplicación.
• Si un tercero decide usar un documento creado en XML, es sencillo entender su estructura y procesarlo. Mejora la compatibilidad entre aplicaciones.

¿Qué es un XML Parser?

Al momento de desarollar una aplicación que necesite leer archivos XML, no es conveniente crear piezas de código que hagan éste tipo de tareas desde cero. Un parser XML es una librería de clases que ofrece al programador métodos para manipular documentos XML, además de abstraer el funcionamiento complejo o no particular de XML, incluyendo:

• Resuleve referencias
• Entiende las secciones CDATA
• Verificar si el documento está bien formado
• Validar el documento contra su DTD
• Asignar tipos y atributos

Los Parsers XML generalmente pueden usar una o más APIs XML para llevar a cabo su misión. Pero… ¿qué son las APIs XML?

APIs XML en Java

Escoger un API XML es quizás una de las más importantes decisiones que debes tomar, de acuerdo al proyecto que se está desarrollando. Muchos Parsers tienen la capacidad de usar una u otra, por lo que es relativamente sencillo cambiar de parser si es necesario; por otro lado, cambiar de API puede llegar a ser bastante doloroso, incluso podrías tener que reescribir todo. Así que, se cuidadoso al momento de escoger alguno. He aquí una lista de los más importantes:

• SAX: Simple API for XML, es de lejos la mejor API para XML. Es muy poco lo que no puedes hacer con dicha API. Las clases e interfaces de SAX modelan el parser, el flujo desde el cual los documentos son leídos, y la aplicación cliente recibe datos desde el parser. Sin embargo, ninguna clase modela el documento XML; en vez de ello, el parser provee el contenido a la aplicación cliente a través de una interfaz callback. Esto hace a SAX muy rápido y eficiente, puesto que no tiene que guardar el documento entero en la memoria. Esto hace que sea, por eficiencia, la única opción si deseas manipular documentos XML demasiado grandes.
• DOM: Document Object Model, es un API que modela un documento XML como un árbol. A diferencia de SAX, DOM puede leer y generar documentos XML. Cada documento XML es representado por un objeto Document. Toda operación (escribir ,leer, modificar, etc.) sobre dichos objetos se realiza a través de la invocación de métodos.
• JAXP: Java API for XML Processing, es el API estándar de Java que envuelve tanto a SAX como a DOM. Por tanto, al momento de iniciar un proyecto, no te preguntas si usar SAX o JAXP, o DOM o JAXP. SAX y DOM son parte de JAXP.
• Otras APIs para XML en Java son: JDOM, dom4j, XMLPull.

XML parsers para Java

Aquí un pequeño listado de los parsers más usados:

• XERCES: es parte de Apache XML Project, y es bastante completo. Además, soporta completamente a SAX, DOM y JAXP. Se distribuye bajo la licencia Apache 2.0, por lo cual tienes bastantes libertades al momento de usarlo.
• Crimson: actualmente Crimson posee casi todas las características de xerces (soporta SAX, DOM, XML 1.0 y JAXP), y también forma parte del proyecto Apache XML. Fue desarrollado por ingenieros de Sun que no estaban de acuerdo en cómo XERCES parseaba los documentos XML; y aunque en un principio huvo un inmenso afán entre los dos grupos de desarrolladores por hacer más rápido y eficiente su proyecto, actualmente son casi igual de rápidos y confiables. Aunque éste no es muy usado, hay que decirlo.
• Otros parsers son: Ælfred y Piccolo (no se si tenga que ver con Dragon Ball Z).

Enlaces interesantes…

• Página oficial de xerces
• Introduction to XML and XML With Java
• XML Parsers