Pink Floyd en El Majahual.

Creditos de: wilbertharaujo


Buenisimo... !!!!

Json en Java

En el post anterior me referia a xml y el manejo que castor-xml nos proporciona para simplificar las cosas, dentro del mismo post esta el siguiente comentario:

DrMartin dijo....

"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."

Efectivamente Json es la manera en que los componentes de la capa de presentación de las aplicaciones web se estan comunicando con los servidores, se ha convertido en un estandar e incluso los componentes javascript que antes tenian dicha interacción atravez de xml ahora dan soporte para Json, el soporte de librerias (frameworks) como JQuery es extremadamente bueno.

Con todo esto la duda que tuve es como generar Json de manera eficiente desde Java, pues bueno en http://json.org/ esta la respuesta, revisando algunas de las librerias que en dicho sitio se presentan inmediatamente me llamo la atención GSon que promete ser "A Java library to convert JSON to Java objects and vice-versa", revisando un poco me pareción muy intuitivo (demasiado) su uso, un método muy sencillo en donde se encapsula la escritura de Json:

public static String Object2Json(Object obj){
return new Gson().toJson(obj);
}

y la lectura de un Json así:

@SuppressWarnings("unchecked")
public static Object Json2Object(String json, Class clazz){
return new Gson().fromJson(json, clazz);
}

Por supuesto que si queremos utilizar colecciones dentro de nuestros objetos debemos darle un manejo mucho mas especializado tal como se describe en la documentación de Gson, los métodos que he colocado funcionarán para POJOs (aunque yo lo probe con unos mapas y en la escritura todo bien, el problema fue en la lectura pero por el manejo que se debe de dar para las colecciones).

Otra libreria que me parecio interesante aunque no cumple toda la funcionalidad que Gson es FlexJson, su uso tambien es muy sencillo, para escribir un Json no se necesita mas que:

public static String Object2Json(Object obj){
return new JSONSerializer().exclude("*.class").serialize(obj);
}

o si necesitamos un Json con estructura para ExtJs:

public static String Object2JsonExtJs(Object obj,String alias){
return new JSONSerializer().exclude("*.class").serialize(alias, obj);
}

Esta libreria da soporte para anotaciones y su documentación es bastante completa.

Existen muchas otras librerias pero estas dos me parecieron (al menos para mis futuras necesidades) las más utiles.

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í.