JAVA+XML = JDOM (Parte 2)
Introducción
En el articulo anterior a esta serie presentamos la API JDOM así como mostramos una aplicación que haciendo uso de dicha API permitía leer documentos XML con enorme facilidad. En este articulo, presentaremos nuevos métodos que nos ayudaran a crear documentos XML de una manera igualmente sencilla.
Ventajas de JDOM
- En JDOM no hace falta usar factorías ni otros modelos avanzados de programación para crear un Document, cosa que si hay que hacer en DOM.
- DOM no tiene una manera estándar de crear Document, cada parser tiene implementada sus métodos específicos, siendo nuestros programas dependientes del parser utilizado. Es muy cierto que para ello Sun ideo la API JAXP para solventar este problema, pero tiene el incoveniente de que no todos los parses tienen soporte JAXP.
- Como el Node de DOM es siempre construido a través del método factoría de su padre Document, se presenta el viejo problema del huevo y la gallina, ya que un Element tiene que ser construido con un Document, pero un Document no debería existir sin un Element que haga de root.
- Con SAX no la comparamos en este aspecto ya que dicha API es solo de lectura.
Métodos útiles
A continuación vamos a mostrar una serie de métodos que a mi juicio me parecen básicos.
clase Element:
Element(String nombre): Constructor para crear etiquetas, el parámetro será lógicamente el nombre de la etiqueta.
setText(String texto): para darle un contenido a dicha etiqueta.
addContent(Element hijo): el parámetro será el hijo que queremos que cuelgue de un determinado elemento.
addAttribute(String atributo,String valor): Para añadir un atributo.
removeAttribute(String atributo): Para borrar un determinado atributo.
clase Document:
Document(Element root): Constructor para crear un documento, el parámetro será el elemento que hará de root.
setRootElement(Element nuevoRoot): Para cambiar de elemento que haga de root.
La siguiente clase sirve para darle salida al Document ya sea en pantalla, fichero,... Los métodos que más nos interesan son:
clase XMLOutputter:
XMLOutputter(String sangria,Boolean nuevaLinea): En el primer parámetro indicaremos el String que queramos de sangría, y como segundo parámetro diremos si queremos o no meter nueva linea.
output(Document doc, OutputStream out): Lo utilizaremos para escribir el documento en un fichero dado.
Ten en cuenta que...
Si vamos a utilizar un Element y deseamos hacer una especie de plantilla, una idea sería crear una clase que extendiese a Element y personalizasemos ahí lo que quisieramos, para que quede claro lo que quiero decir valga este ejemplo:
<autor>
<nombre>Javier Teso</nombre>
<email>jte_job@hotmail.com</email>
<edad>23</edad>
</autor>
Vamos a hacer una plantilla personalizada con mis años, veamos:
import org.jdom.*;
public class Yo extends Element{
public Yo(int year) {
super("autor");
addContent(new Element("nombre").setText("Javier Teso"));
addContent(new Element("email").setText("jabotxa@latinmail.com"));
addContent(new Element("edad").setText(Integer.toString(year)));
}
}
asi en nuestro programa hariamos:
...
elementoCualquiera.addContent(new Autor(23));...
Proyecto Crear.java
Para verlo todo mas claro hagamos un documento XML desde cero.
import java.io.*;
import java.util.*;
import org.jdom.*;
import org.jdom.input.*;
import org.jdom.output.*;
public class Crear {
public static void main(String[] args) {
//Creamos un elemento root
Element root=new Element("javahispano");
//Creamos un hijo para el root
Element articulo=new Element("articulo");
Element titulo=new Element("titulo").setText("Articulo sobre Jdom");
titulo.setAttribute("valoracion","5");
Yo javi=new Yo(23);
//Fíjate bien en como podemos enlazar 2 hijos de una forma mas compacta
articulo.addContent(titulo).addContent(javi);
//Si quisieramos cambiar el elemento javi por otro javi con 24 años
Yo javimas=new Yo(24);
articulo.removeContent(javi);
articulo.addContent(javimas);
root.addContent(articulo);
Document doc=new Document(root);//Creamos el documento
//Vamos a almacenarlo en un fichero y ademas lo sacaremos por pantalla
try{
XMLOutputter out=new XMLOutputter(" ",true);
FileOutputStream file=new FileOutputStream("ejemplo.xml");
out.output(doc,file);
file.flush();
file.close();
out.output(doc,System.out);
}catch(Exception e){e.printStackTrace();}
}
}
Conclusión
Espero que a lo largo de estos dos artículos haya sido capaz de haceros llegar una idea de la funcionalidad que esta API nos ofrece, animamos a los lectores interesados que visiten la web del jdom: www.jdom.org para que descubran por si mismos otros aspectos de la API, como puede ser el trabajo con Namespaces, PI, ..., la verdad, creo que merece la pena.
domingo, marzo 3, 2002 at 1:00AM