Ejemplos JSON y Java con Gson

Gson es una librería java de google que facilita la conversión de clases java a cadenas JSON y viceversa, así como generar y analizar cadenas JSON sin necesidad de tener clases Java asociadas. Veamos algunos ejemplos que tienes al completo en JsonExamples

Preparar el entorno

Primero tienes que bajarte la librería gson y añadir el jar correspondiente en tu IDE favorito.

Teniendo beans Java preparados

toJson

Imagina que tienes un bean java como el siguiente (fíjate que no es un bean estrictamente hablando, puesto que no tiene getter, setter ni constructor por defecto, podemos ponerlos, pero Gson no los necesita).

package com.chuidiang.ejemplos.json;

import java.util.Date;

public class Data {

   public Data(String aString, int aInt, Integer aInteger, Date aDate) {
      super();
      this.aString = aString;
      this.aInt = aInt;
      this.aInteger = aInteger;
      this.aDate = aDate;
   }

   private String aString = "a String";
   private int aInt = 22;
   private Integer aInteger = new Integer(11);
   private Date aDate = new Date();

   @Override
   public String toString() {
      return "Data [aString=" + aString + ", aInt=" + aInt + ", aInteger="
            + aInteger + ", aDate=" + aDate + "]";
   }

}

y queremos convertir este bean a cadena JSON u obtener este bean a partir de cadenas JSON. Con Gson es fácil, solo necesitamos una instacia de la clase Gson y usar sus método toJson() y fromJson().

Gson gson = new Gson();

Si tenemos el bean instanciado y queremos convertirlo a una cadena JSON, el código es este

String json = gson.toJson(new Data("string", 10, null, new Date()));

que dará algo como

{"aString":"string","aInt":10,"aDate":"Feb 26, 2014 8:53:41 PM"}

Si tenemos una lista o un array de beans, la forma es igual de fácil

Data [] dataArray = new Data[3];
for (int i = 0; i < dataArray.length; i++) {
   dataArray[i] = new Data("a String " + i, i, new Integer(i + 2), new Date());
}

String json = gson.toJson(dataArray);

o bien, con una lista

List<Data> dataList = new LinkedList<>();
for (int i=0;i<3;i++) {
   dataList.add(new Data("a String " + i, i, new Integer(i + 2), new Date()));
}

String json = gson.toJson(dataList);

En ambos casos, obtendremos algo como esto

[{"aString":"a String 0","aInt":0,"aInteger":2,"aDate":"Feb 26, 2014 8:53:41 PM"}, 
 {"aString":"a String 1","aInt":1,"aInteger":3,"aDate":"Feb 26, 2014 8:53:41 PM"},
 {"aString":"a String 2","aInt":2,"aInteger":4,"aDate":"Feb 26, 2014 8:53:41 PM"}]

Para el formateo de fechas, podemos generar una instancia especial de Gson con el formato que queramos para las fechas, de esta forma

Gson gson = new GsonBuilder().setDateFormat("dd/MM/yy HH:mm:ss").create();
String json = gson.toJson(new Date());

que daría

"26/02/14 20:53:41"

fromJson

De forma similar, teniendo la cadena JSON, podemos obtener los beans correspondientes

String json = "{'aString':'from Parsed String','aInt':33,'aInteger':null,'aDate':'Feb 26, 2014 7:35:23 PM'}";

Data parsedData = gson.fromJson(json, Data.class);

símplemente debemos indicar como segundo parámetro qué clase queremos obtener. La conversión no falla, si en la cadena JSON hay más parámetros de la cuenta, se ignoran, si el bean tiene más atributos, no se rellenan.

Sin bean Java

Si no tenemos un bean java, quizás porque estamos analizando una cadena JSON que hemos obtenido de algún sitio o debemos generarla con datos recogidos de algún otro sitio, Gson nos ofrece las clases JsonPrimitive, JsonObject y JsonArray, todas ellas implementando la interfaz JsonElemnt

Construir cadena JSON

Para el caso de datos primitivos (boolean, String ...)

JsonPrimitive primitive = new JsonPrimitive(Boolean.TRUE);
String json = primitive.toString();

Devolvería un String con

true

Para un Objeto JSON, podemos hacer algo así

JsonObject object = new JsonObject();
object.addProperty("name", "Juan");
object.addProperty("age", 22);
object.addProperty("birthday", new Date().toString());

String json = object.toString();

que devolvería una cadena así

{"name":"Juan","age":22,"birthday":"Wed Feb 26 21:39:10 CET 2014"}

Por supuesto, podemos añadir addProperty("key", JSonElement) para añadir otro JSonObject o JsonArray dentro de nuestro objeto.

Para arrays, podemos hacer un código como este

JsonArray array = new JsonArray();
array.add(jsonElement1); // JsonPrimitive, JsonObject o JsonArray
array.add(jsonElement2);

String json = array.toString());

que daría un String del estilo

[{"name":"Juan","age":22,"birthday":"Wed Feb 26 21:39:10 CET 2014"},
 {"name":"Juan","age":22,"birthday":"Wed Feb 26 21:39:10 CET 2014"}]

Parsear una cadena JSON

Si tenemos la cadena JSON, podemos analizarla usando estos objetos JsonElement. Por ejemplo, si la cadena tiene una primitiva

JsonParser parser = new JsonParser();
      
JsonElement elementPimitive = parser.parse("true");
if (elementPimitive.isJsonPrimitive() &&
    elementPimitive.getAsJsonPrimitive().isBoolean()){
    boolean value = elementPimitive.getAsBoolean();
}

Instanciamos un JsonParser. El método parse() de de JsonParser devuevle un JsonElement. Este elemento tiene métodos para interrogar de qué tipos es, como isJsonPrimitive() y métodos para obtenerlo como ese tipo concreto, como getAsJsonPrimitive() y una vez indentificado exactamente de qué tipo es el valor que hay dentro, métodos para obtener dicho valor, como getAsBoolean()

Con una cadena tipo JsonObject, omitimos aquí los if para saber exactamente el tipo de JsonElement que es, el código sería así

JsonElement elementObject = parser.parse("{'name':'Juan','age':22,'birthday':'Wed Feb 26 20:39:53 CET 2014'}");
String name = elementObject.getAsJsonObject().get("name").getAsString());

que nos devolvería el name

Juan

Finalmente, para arrays, podemos hacer así

JsonElement arrayElement = parser.parse(
   "[{'name':'Juan','age':22,'birthday':'Wed Feb 26 20:44:23 CET 2014'},"
   + "{'name':'Juan','age':22,'birthday':'Wed Feb 26 20:39:53 CET 2014'}]");
System.out.println(arrayElement.getAsJsonArray().size());
int age = arrayElement.getAsJsonArray().get(0).getAsJsonObject().get("age").getAsInt();

Nuevamente nos hemos saltado las comprobaciones. Esto nos devolverá el tamaño del array y la edad del primer elemento.