miércoles, 17 de junio de 2009

Java: Castor y XML - Mappings

Para continuar con lo prometido de Castor – XML

Como les comente, si lo que queremos es un xml con cierta complejidad, no bastará con utilizar los mentodos que coloque en el post anterior, pues dichos metodos solo nos sirven para un POJO (DTO, JavaBean........W como lo quieran llamar).

Para poder “convertir” una clase o un conjunto de clases “relacionadas” debemos maperlas dentro de un archivo que luego deberá ser cargado en el contexto de ejecución de castor, para esto explico brebemente las herramientas que las personas del proyecto java-castor nos proporcionan:

Mapping: esta clase permite cargar archivos y/u objetos (Reader) para realizar el java binding con castor, es decir, los mapeos que generemos deben ser cargados en una instancia de este objeto.

Marshaller: siver para realizar el paso de objetos a un xml

Unmarshaller: es el analogo a Marshaller, pasa un xml a objeto

XMLContext: esta clase es basicamente un Factory de objetos con algunas otras utilidades, posee metodos para crear objetos Marshaller, Unmarshaller y Mapping, esta clase es la que se recomienda utilizar para la creación de estos objetos, tambien en este objeto podemos precargar los mappeos (Objetos Mapping), realmente este objeto simplifica de manera significativa el parseo.

La clase que utilizaremos:

public class XMLDataBinding {

private XMLContext ctx;

public XMLDataBinding(){
this.ctx = new XMLContext();
}

public Object readXML(Reader xml, Class clazz) throws MarshalException, ValidationException, SAXException, IOException{
Unmarshaller unmarshaller = context.createUnmarshaller();
unmarshaller.setClass(clazz);
return unmarshaller.unmarshal(new InputSource(xml));
}

public static Object xml2Object(Reader xml, Class clazz) throws MarshalException, ValidationException{
return Unmarshaller.unmarshal(clazz, xml);
}

public String writeXML(Object object) throws MarshalException, ValidationException, IOException{
StringWriter writer = new StringWriter();
Marshaller marshaller = context.createMarshaller();
marshaller.setWriter(writer);
marshaller.marshal(object);
return writer.getBuffer().toString();
}

public static String object2XML(Object object) throws MarshalException, ValidationException{
StringWriter writer = new StringWriter();
Marshaller.marshal(object, writer);
return writer.getBuffer().toString();
}

public void addMappingToContext(Reader mappingFile) throws MappingException{
Mapping mapping = this.ctx.createMapping();
mapping.loadMapping(new InputSource(mappingFile));
this.ctx.addMapping(mapping);
}

public void addMappingToContext(InputStream mappingFile) throws MappingException{
Mapping mapping = this.ctx.createMapping();
mapping.loadMapping(new InputSource(mappingFile));
this.ctx.addMapping(mapping);
log.debug("Mapping loaded: " + mappingFile);
}

public XMLContext getXMLContext(){
return this.ctx;
}

}

Las clase que utilizaremos para convertirlas a xml son relativamente sencillas (sino nos aburrimos todos), lo haremos con dos clases unicamente:


public class Persona implements Serializable {

private static final long serialVersionUID = 1L;
private String nombre;
private String apellido;
private int edad;
private ArrayList telefonos;
private Automovil automovil;

public Persona(){
}

public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public List getTelefonos() {
return telefonos;
}
public void setTelefonos(ArrayList telefonos) {
this.telefonos = telefonos;
}

public Automovil getAutomovil() {
return automovil;
}

public void setAutomovil(Automovil automovil) {
this.automovil = automovil;
}

public String getNombreCompleto(){
return this.nombre + “ ” + this.apellido;
}

}

public class Automovil implements Serializable {
private static final long serialVersionUID = 1L;
private String marca;
private String modelo;
private String placa;

public Automovil(){

}

public String getMarca() {
return marca;
}
public void setMarca(String marca) {
this.marca = marca;
}
public String getModelo() {
return modelo;
}
public void setModelo(String modelo) {
this.modelo = modelo;
}
public String getPlaca() {
return placa;
}
public void setPlaca(String placa) {
this.placa = placa;
}
}

El mapeo es el siguiente:

Link de descarga aquí

Deben notar que la clase principal es test.castor.xml.contenedores.Persona y esta clase en el mapeo posee un tag map-to, este tag determina el nombre del tag root del xml resultante, tambien notar que los atributos type de cada tag field determinan el tipo de objeto que será creado (que puede ser un tipo primitivo de java o uno propio) y el atributo name establece el metodo accesor que será buscado en la clase (no el nombre del atributo, notar que nombreCompleto no exite en la clase), adicionalmente si poseemos collecciones de objetos (no mapas, pues estos se manipulan diferente) hay que adicionar un tag collection que contiene el tipo de colección que manipularemos (los tipos aceptados por castor-xml se encuentran en el dtd http://castor.org/mapping.dtd), el tag bind-xml (hijo de field) determina el nombre que en el xml poseera el atributo correspondiente a la clase.

La escritura del xml seria la siguiente:

Persona persona = new Persona();
persona.setNombre("nombre");
persona.setApellido("apellido");
persona.setEdad(100);
ArrayList telefonos = new ArrayList();
telefonos.add("12345");
telefonos.add("56789");
persona.setTelefonos(telefonos);
Automovil auto = new Automovil();
auto.setMarca("marca");
auto.setModelo("modelo");
auto.setPlaca("SV123465");
persona.setAutomovil(auto);
XMLDataBinding db = new XMLDataBinding();
db.addMappingToContext("test/castor/xml/PersonaMapping.xml");
System.out.println(db.writeXML(persona));

El xml que obtenemos como resultado es el siguiente:

Link de descarga aquí

El orden de los tags en el xml obtenido corresponde al orden establecido en el mapeo, es decir, si necesitamos un orden diferente de los tags en el xml no tenemos que modificar nada mas que el mapeo de nuestras clases al igual que si queremos que cambiar el nombre a algun tag, solo hay que modificar el mapping.

La lectura de un xml podriamos hacerla con el mismo xml que hemos generado y la misma instancia del objeto XMLDataBinding:

Persona p = (Persona)db.readXML(new StringReader(xml), Persona.class);

Castor-XML posee mas herramientas para la manipulación de xml, para el caso de handlers que permiten la transformación de objetos por ejemplo, ademas el proyecto castor proporciona muchas herramientas adicionales

La referencia oficial de castor-xml la encuentran aquí y las descargas las encuentran aquí.

4 comentarios:

  1. He escuchado que la nueva era de la información promete que el sustituto de XML sea JSON, he usado JSON hace poco y me parece que en efecto promete ser mas eficiente, pero sobre todo más ameno al programador ya que con solo ver su notación se sabe sobre que versa el flujo de datos.

    Muy buen post,

    Saludos.

    ResponderEliminar
  2. efectivamente json es mas "amigable" pero xml seguirá siendo (a mi entender) el "estandar" para los archivos de configuración y por mucho la forma de integrar aplicaciones mediante SOA....json es la mera..... para usarlo con ajax!!!

    ResponderEliminar
  3. hummm bueno si, la verdad para ser sincero, ahorita que conocí JSON ha sido usandolo con AJAX, por medio de el framework ExtJS, que por cierto es una gran cosa. Solo basta echarle un ojo a los ejemplos:
    ExtJS Samples

    ResponderEliminar
  4. para usar json sin muchas complicaciones en java esta esta "libreria" FlexJson

    ResponderEliminar