Convertir un JSON a objetos y objetos a JSON con JSON-B, Gson y Jackson en Java

Escrito por el , actualizado el .
java planeta-codigo programacion
Comentarios

Java

Continuando la serie de pequeños artículos sobre cómo procesar JSON después de ver anteriormente otras dos formas, Generar, procesar y modificar documentos JSON con JSON-P en Java y Usar expresiones JSONPath para extraer datos de un JSON en Java, en este artículo hay una tercera.

En las dos primeras si los datos son muchos o son todos la tarea de recuperar los datos uno a uno requiere una buena cantidad de código. Dado que un JSON no son nada más que valores, arrays y mapas utilizando la estructuras de datos equivalentes de Java se puede hacer una correspondencia entre los datos del JSON a objetos POJO siguiendo ciertas convenciones.

Una vez que los datos han sido cargados en instancias de objetos se recuperan con los correspondientes métodos get que contengan las instancias, además dado que las propiedades de los objetos tiene un tipo se realiza la conversión adecuada para convertir el dato del JSON al tipo de la propiedad del objeto.

Hay tres librerías distintas populares para hacer este binding entre JSON y objetos. JSON-B, Gson y Jackson siendo la primera la más estándar en el lenguaje Java. En los siguientes ejemplos dada una cadena con JSON y la clase raíz a la que hacer la correspondencia de las propiedades se crea una instancia de Comprador y múltiples de Direccion. La correspondencia entre las propiedades del JSON y del objeto se hace en base al nombre.

Se utilizan los métodos toJson() tanto en JSON-B como en Gson y el método writeValueAsString() en Jackson para convertir a JSON y los métodos fromJson() y readValue() para convertir desde JSON a objetos. Estos métodos devuelven una instancia de la clase raíz indicada y acceder a las propiedades se hace con los correspondientes getter.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package io.github.picodotdev.blogbitix.javajson;

...

public class Main {

    public static void main(String[] args) throws Exception {
        Comprador comprador = buildComprador();
        ...

        // JSON-B
        JsonbConfig config = new JsonbConfig().withAdapters(new JsonbLocalDateAdapter());
        Jsonb jsonb = JsonbBuilder.create(config);

        json = jsonb.toJson(comprador);
        comprador = jsonb.fromJson(json, Comprador.class);
        System.out.printf("JSON-B: %s%n", json);
        System.out.printf("JSON-B (comprador): %s, %s, %d%n", comprador.getNombre(), comprador.getFechaNacimiento(), comprador.getDirecciones().size());

        // Gson
        GsonBuilder builder = new GsonBuilder();
        builder.registerTypeAdapter(LocalDate.class, new GsonLocalDateTypeAdapter());
        Gson gson = builder.create();;

        json = gson.toJson(comprador);
        comprador = gson.fromJson(json, Comprador.class);
        System.out.printf("Gson: %s%n", json);
        System.out.printf("Gson (comprador): %s, %s, %d%n", comprador.getNombre(), comprador.getFechaNacimiento(), comprador.getDirecciones().size());

        // Jackson
        ObjectMapper mapper = new ObjectMapper();
        SimpleModule module = new SimpleModule();
        module.addSerializer(LocalDate.class, new JacksonLocalDateSerializer());
        module.addDeserializer(LocalDate.class, new JacksonLocalDateDeserializer());
        mapper.registerModule(module);

        json = mapper.writeValueAsString(comprador);
        comprador = mapper.readValue(json, Comprador.class);
        System.out.printf("Jackson: %s%n", json);
        System.out.printf("Jackson (comprador): %s, %s, %d%n", comprador.getNombre(), comprador.getFechaNacimiento(), comprador.getDirecciones().size());
        
        ...
    }

    private static Comprador buildComprador() {
        Comprador comprador = new Comprador();
        comprador.setNombre("Juan");
        comprador.setFechaNacimiento(LocalDate.now());
        comprador.getDirecciones().add(buildDireccion());
        comprador.getDirecciones().add(buildDireccion());
        return comprador;
    }

    private static Direccion buildDireccion() {
        return new Direccion("calle", "ciudad", "codigoPostal", "pais");
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package io.github.picodotdev.blogbitix.javajson;

...

public class Comprador {

    private String nombre;
    private LocalDate fechaNacimiento;
    private List<Direccion> direcciones;

    public Comprador() {
        direcciones = new ArrayList<>();
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public LocalDate getFechaNacimiento() {
        return fechaNacimiento;
    }

    public void setFechaNacimiento(LocalDate fechaNacimiento) {
        this.fechaNacimiento = fechaNacimiento;
    }

    public List<Direccion> getDirecciones() {
        return direcciones;
    }

    public void setDirecciones(List<Direccion> direcciones) {
        this.direcciones = direcciones;
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package io.github.picodotdev.blogbitix.javajson;

public class Direccion {

    private String calle;
    private String ciudad;
    private String codigoPostal;
    private String pais;

    public Direccion() {
    }

    public Direccion(String calle, String ciudad, String codigoPostal, String pais) {
        this.calle = calle;
        this.ciudad = ciudad;
        this.codigoPostal = codigoPostal;
        this.pais = pais;
    }

    public String getCalle() {
        return calle;
    }

    public void setCalle(String calle) {
        this.calle = calle;
    }

    public String getCiudad() {
        return ciudad;
    }

    public void setCiudad(String ciudad) {
        this.ciudad = ciudad;
    }

    public String getCodigoPostal() {
        return codigoPostal;
    }

    public void setCodigoPostal(String codigoPostal) {
        this.codigoPostal = codigoPostal;
    }

    public String getPais() {
        return pais;
    }

    public void setPais(String pais) {
        this.pais = pais;
    }
}
1
2
3
4
5
6
JSON-B: {"direcciones":[{"calle":"calle","ciudad":"ciudad","codigoPostal":"codigoPostal","pais":"pais"},{"calle":"calle","ciudad":"ciudad","codigoPostal":"codigoPostal","pais":"pais"}],"fechaNacimiento":"2019-02-01","nombre":"Juan"}
JSON-B (comprador): Juan, 2019-02-01, 2
Gson: {"nombre":"Juan","fechaNacimiento":"2019-02-01","direcciones":[{"calle":"calle","ciudad":"ciudad","codigoPostal":"codigoPostal","pais":"pais"},{"calle":"calle","ciudad":"ciudad","codigoPostal":"codigoPostal","pais":"pais"}]}
Gson (comprador): Juan, 2019-02-01, 2
Jackson: {"nombre":"Juan","fechaNacimiento":"2019-02-01","direcciones":[{"calle":"calle","ciudad":"ciudad","codigoPostal":"codigoPostal","pais":"pais"},{"calle":"calle","ciudad":"ciudad","codigoPostal":"codigoPostal","pais":"pais"}]}
Jackson (comprador): Juan, 2019-02-01, 2

Para añadir tipos de datos que no están entre los básicos de JSON como es una fecha cada librería proporciona interfaces o clases abstractas para hacer la conversión desde el dato a un tipo de JSON y desde JSON al tipo del dato. En este caso para un tipo de dato LocalDate.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
package io.github.picodotdev.blogbitix.javajson;

...

public class JsonbLocalDateAdapter implements JsonbAdapter<LocalDate, JsonString> {

    @Override
    public JsonString adaptToJson(LocalDate obj) throws Exception {
        return Json.createValue(obj.format(DateTimeFormatter.ISO_LOCAL_DATE));
    }

    @Override
    public LocalDate adaptFromJson(JsonString obj) throws Exception {
        return LocalDate.parse(obj.getString(), DateTimeFormatter.ISO_LOCAL_DATE);
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
package io.github.picodotdev.blogbitix.javajson;

...

public class GsonLocalDateTypeAdapter extends TypeAdapter<LocalDate> {

    @Override
    public void write(JsonWriter out, LocalDate value) throws IOException {
        out.value(value.format(DateTimeFormatter.ISO_LOCAL_DATE));
    }

    @Override
    public LocalDate read(JsonReader in) throws IOException {
        return LocalDate.parse(in.nextString(), DateTimeFormatter.ISO_LOCAL_DATE);
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package io.github.picodotdev.blogbitix.javajson;

...

public class JacksonLocalDateSerializer extends JsonSerializer<LocalDate> {

    @Override
    public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeString(value.format(DateTimeFormatter.ISO_LOCAL_DATE));
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package io.github.picodotdev.blogbitix.javajson;

...

public class JacksonLocalDateDeserializer extends JsonDeserializer<LocalDate> {

    @Override
    public LocalDate deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        return LocalDate.parse(p.getValueAsString(), DateTimeFormatter.ISO_LOCAL_DATE);
    }
}

El código fuente completo del ejemplo puedes descargarlo del repositorio de ejemplos de Blog Bitix alojado en GitHub y probarlo en tu equipo ejecutando el comando ./gradlew run.