Java

Getting Started

La librería Jackson es una de las herramientas más populares y potentes para procesar JSON en Java. Permite trabajar con datos JSON de manera sencilla, rápida y eficiente. A continuación, te explico todo lo necesario para entender y usar Jackson en tus proyectos:

1. ¿Qué es Jackson?

Jackson es una biblioteca de Java para:

Convertir objetos Java a JSON (serialización).
Convertir JSON a objetos Java (deserialización).
Manejar y manipular nodos JSON directamente.

Es parte del ecosistema FasterXML y consta de varios módulos que amplían su funcionalidad.

2. Componentes principales de Jackson

Jackson está compuesto por varios módulos:

a. `jackson-databind`

Es el núcleo de Jackson y ofrece soporte para serialización y deserialización de POJOs (Plain Old Java Objects).

b. `jackson-core`

Proporciona las funcionalidades básicas para procesar JSON.
Incluye un parser (JsonParser) para leer JSON y un generador (JsonGenerator) para escribir JSON.

c. `jackson-annotations`

Contiene anotaciones para personalizar la serialización/deserialización.

Otros módulos avanzados

jackson-datatype-*: Para manejar tipos específicos como LocalDate, BigDecimal, etc.
jackson-module-kotlin: Compatibilidad con Kotlin.
jackson-dataformat-*: Manejo de formatos alternativos como YAML, XML, CSV, etc.

4. Operaciones básicas

a. Crear un objeto `ObjectMapper`

El ObjectMapper es el núcleo de Jackson. Es el encargado de convertir entre JSON y objetos Java.

import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper objectMapper = new ObjectMapper();

b. Serialización: Convertir un objeto Java a JSON

import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();

        // Crear un objeto Java
        Persona persona = new Persona("Juan", 25);

        // Convertir el objeto a JSON
        String json = objectMapper.writeValueAsString(persona);
        System.out.println(json);
    }
}

class Persona {
    private String nombre;
    private int edad;

    // Constructor, getters y setters
    public Persona(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    public String getNombre() {
        return nombre;
    }

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

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }
}

Salida:

{"nombre":"Juan","edad":25}

c. Deserialización: Convertir JSON a un objeto Java

String json = "{\"nombre\":\"Juan\",\"edad\":25}";

// Convertir JSON a un objeto Java
Persona persona = objectMapper.readValue(json, Persona.class);
System.out.println(persona.getNombre()); // Juan

5. Anotaciones de Jackson

Jackson proporciona varias anotaciones para personalizar el comportamiento:

a. `@JsonProperty`

Define el nombre del campo en JSON.

public class Persona {
    @JsonProperty("nombre_completo")
    private String nombre;

    private int edad;
}

b. `@JsonIgnore`

Excluye un campo durante la serialización.

public class Persona {
    private String nombre;

    @JsonIgnore
    private int edad;
}

c. `@JsonInclude`

Excluye valores nulos o predeterminados.

@JsonInclude(JsonInclude.Include.NON_NULL)
public class Persona {
    private String nombre;
    private Integer edad;
}

d. `@JsonFormat`

Define el formato de fechas.

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy")
private Date fechaNacimiento;

6. Manejo de nodos JSON dinámicos

Si trabajas con JSON dinámico, puedes usar la clase JsonNode:

import com.fasterxml.jackson.databind.JsonNode;

String json = "{\"nombre\":\"Juan\",\"edad\":25}";
JsonNode node = objectMapper.readTree(json);

System.out.println(node.get("nombre").asText()); // Juan
System.out.println(node.get("edad").asInt());   // 25

7. Configuración avanzada

a. Ignorar campos desconocidos

Cuando el JSON tiene más campos de los que la clase Java define:

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

b. Serialización bonita (Pretty Print)

Para generar JSON formateado:

String json = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(objeto);
System.out.println(json);

c. Customizadores

Puedes registrar módulos o personalizar serializadores/deserializadores.

SimpleModule module = new SimpleModule();
module.addSerializer(CustomType.class, new CustomSerializer());
objectMapper.registerModule(module);

8. Compatibilidad con otros formatos

Jackson tiene extensiones para manejar otros formatos:

XML: Usa jackson-dataformat-xml.
YAML: Usa jackson-dataformat-yaml.
CSV: Usa jackson-dataformat-csv.

Ejemplo con YAML:

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-yaml</artifactId>
    <version>2.15.2</version>
</dependency>

ObjectMapper yamlMapper = new ObjectMapper(new YAMLFactory());
String yaml = yamlMapper.writeValueAsString(persona);