Java JSON con Jackson | W3Docs Learn Java

Jackson es la biblioteca JSON estándar de facto para Java. El JDK no incluye ninguna API JSON propia, por lo que casi todas las aplicaciones Spring, Quarkus o Micronaut recurren a Jackson para convertir objetos Java en texto JSON y viceversa. Su punto de entrada es una única clase de trabajo — ObjectMapper — que se encarga de las dos tareas que siempre se necesitan: serialización (objeto Java → JSON) y deserialización (JSON → objeto Java).

Si eres nuevo en JSON en Java, comienza con la introducción a JSON; para una biblioteca alternativa más ligera, consulta el capítulo de Gson. Esta página cubre cómo añadir Jackson, los tres niveles de su API, el enlace de datos, el modelo de árbol y las anotaciones que controlan el mapeo.

Agregar Jackson a tu proyecto

Jackson no forma parte del JDK, por lo que debes declararlo como dependencia. El artefacto jackson-databind incluye de forma transitiva los otros dos módulos principales (jackson-core y jackson-annotations).

<!-- Maven -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.17.1</version>
</dependency>

// Gradle
implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.1'

Las tres formas de trabajar con JSON

Jackson expone los mismos datos de tres maneras distintas. Elige el nivel que se ajuste a la tarea:

Enfoque	Tipo principal	Úsalo cuando
Enlace de datos	`ObjectMapper.readValue` / `writeValue`	Tienes un POJO o record que refleja el JSON — el caso más común
Modelo de árbol	`JsonNode` vía `readTree`	La forma es dinámica o solo necesitas unos pocos campos
Streaming	`JsonParser` / `JsonGenerator`	Documentos muy grandes donde no puedes mantener todo el árbol en memoria

El enlace de datos es lo que se usa el 90% del tiempo; los otros dos son escotillas de escape.

Enlace de datos: objetos a JSON y viceversa

ObjectMapper.writeValueAsString serializa cualquier objeto Java leyendo sus getters (o los componentes del record); readValue hace lo contrario, haciendo coincidir los nombres de campos JSON con tus campos. Un record es el destino más limpio — Jackson 2.12+ se enlaza a su constructor canónico automáticamente, por lo que no necesitas escribir getters ni un constructor sin argumentos.

import com.fasterxml.jackson.databind.ObjectMapper;

record User(String name, int age, boolean active) {}

ObjectMapper mapper = new ObjectMapper();

// serialize: Java -> JSON
User ada = new User("Ada", 36, true);
String json = mapper.writeValueAsString(ada);
// {"name":"Ada","age":36,"active":true}

// deserialize: JSON -> Java
User back = mapper.readValue(json, User.class);
System.out.println(back.name()); // Ada

Para colecciones y genéricos, pasa a Jackson un TypeReference para que el tipo de elemento sobreviva al borrado de tipos:

import com.fasterxml.jackson.core.type.TypeReference;

List<User> users = mapper.readValue(jsonArray, new TypeReference<List<User>>() {});

El modelo de árbol: cuando la forma es desconocida

Cuando no tienes (o no quieres) una clase correspondiente, analiza el JSON en un árbol genérico JsonNode y navega por él con claves. Esto imita lo que hace un analizador manual de Map/List, pero con accesores con reconocimiento de tipos como asInt() y asText().

import com.fasterxml.jackson.databind.JsonNode;

JsonNode root = mapper.readTree(json);
String name = root.get("name").asText();
int age     = root.get("age").asInt();
JsonNode first = root.get("languages").get(0); // array access by index

Controlar el mapeo con anotaciones

Los nombres de campos JSON raramente coinciden perfectamente con las convenciones de Java. Un puñado de anotaciones cierra la brecha sin cambiar los nombres de tus campos:

Anotación	Efecto
`@JsonProperty("user_name")`	Mapea un campo a una clave JSON diferente
`@JsonIgnore`	Omite un campo en ambas direcciones
`@JsonInclude(NON_NULL)`	Elimina los campos `null` de la salida
`@JsonCreator` / `@JsonFormat`	Construcción personalizada / formato de fecha

record Account(
    @JsonProperty("user_name") String userName,
    @JsonIgnore String passwordHash) {}

Un ejemplo completo: serializar, analizar y enlazar manualmente

Jackson no está en el classpath de este ejecutor, por lo que el programa a continuación construye los mismos conceptos — un escritor JSON, un analizador de descenso recursivo en un árbol Map/List, y el enlace en un record — usando solo java.util. Es exactamente lo que ObjectMapper hace internamente: recorrer un gráfico de objetos para emitir texto, y tokenizar texto para reconstruir un árbol.

java— editable, runs on the server

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;

public class JacksonDemo {
  // A tiny JSON model: objects are Map<String,Object>, arrays are List<Object>.
  // Real code uses Jackson's ObjectMapper; here we model the same data binding by hand.

public static void main(String[] args) {
    // 1. SERIALIZE: build an object graph, then render it as JSON text.
    Map<String, Object> user = new LinkedHashMap<>();
    user.put("name", "Ada");
    user.put("age", 36);
    user.put("active", true);
    List<Object> langs = new ArrayList<>();
    langs.add("Java");
    langs.add("Ada");
    user.put("languages", langs);

String json = writeJson(user);
    System.out.println("serialized   : " + json);

// 2. PARSE: read JSON text back into the same Map/List tree (tree model).
    String input = "{\"name\":\"Grace\",\"age\":42,\"active\":false,\"languages\":[\"COBOL\",\"Java\"]}";
    Object tree = new Parser(input).parse();
    System.out.println("parsed type  : " + tree.getClass().getSimpleName());

// 3. NAVIGATE the tree, the way ObjectMapper.readTree() + JsonNode.get() do.
    @SuppressWarnings("unchecked")
    Map<String, Object> parsed = (Map<String, Object>) tree;
    System.out.println("name field   : " + parsed.get("name"));
    System.out.println("age field    : " + parsed.get("age") + " (" + parsed.get("age").getClass().getSimpleName() + ")");

// 4. BIND into a typed record, the way ObjectMapper.readValue(json, User.class) does.
    @SuppressWarnings("unchecked")
    List<Object> plist = (List<Object>) parsed.get("languages");
    List<String> typed = new ArrayList<>();
    for (Object o : plist) typed.add((String) o);
    User bound = new User((String) parsed.get("name"), (int) parsed.get("age"), typed);
    System.out.println("bound record : " + bound);

// 5. ROUND-TRIP: re-serialize the parsed tree and confirm it survives.
    System.out.println("round-trip   : " + writeJson(parsed));
  }

record User(String name, int age, List<String> languages) {}

// ---- minimal JSON writer ----
  static String writeJson(Object value) {
    StringBuilder sb = new StringBuilder();
    write(value, sb);
    return sb.toString();
  }

@SuppressWarnings("unchecked")
  static void write(Object value, StringBuilder sb) {
    if (value == null) { sb.append("null"); return; }
    if (value instanceof String s) { sb.append('"').append(s).append('"'); return; }
    if (value instanceof Boolean || value instanceof Number) { sb.append(value); return; }
    if (value instanceof Map<?, ?> m) {
      sb.append('{');
      boolean first = true;
      for (Map.Entry<?, ?> e : m.entrySet()) {
        if (!first) sb.append(',');
        first = false;
        sb.append('"').append(e.getKey()).append("\":");
        write(e.getValue(), sb);
      }
      sb.append('}');
      return;
    }
    if (value instanceof List<?> list) {
      sb.append('[');
      for (int i = 0; i < list.size(); i++) {
        if (i > 0) sb.append(',');
        write(list.get(i), sb);
      }
      sb.append(']');
      return;
    }
    throw new IllegalArgumentException("unsupported: " + value.getClass());
  }

// ---- minimal recursive-descent JSON parser ----
  static class Parser {
    private final String s;
    private int i = 0;
    Parser(String s) { this.s = s; }

Object parse() { skip(); return value(); }

private Object value() {
      skip();
      char c = s.charAt(i);
      return switch (c) {
        case '{' -> object();
        case '[' -> array();
        case '"' -> string();
        case 't', 'f' -> bool();
        case 'n' -> nul();
        default -> number();
      };
    }

private Map<String, Object> object() {
      Map<String, Object> m = new LinkedHashMap<>();
      i++; // {
      skip();
      if (s.charAt(i) == '}') { i++; return m; }
      while (true) {
        skip();
        String key = string();
        skip();
        i++; // :
        m.put(key, value());
        skip();
        char c = s.charAt(i++);
        if (c == '}') break;
      }
      return m;
    }

private List<Object> array() {
      List<Object> list = new ArrayList<>();
      i++; // [
      skip();
      if (s.charAt(i) == ']') { i++; return list; }
      while (true) {
        list.add(value());
        skip();
        char c = s.charAt(i++);
        if (c == ']') break;
      }
      return list;
    }

private String string() {
      StringBuilder sb = new StringBuilder();
      i++; // opening quote
      while (s.charAt(i) != '"') sb.append(s.charAt(i++));
      i++; // closing quote
      return sb.toString();
    }

private Object number() {
      int start = i;
      while (i < s.length() && "-+.eE0123456789".indexOf(s.charAt(i)) >= 0) i++;
      String num = s.substring(start, i);
      if (num.contains(".") || num.contains("e") || num.contains("E"))
        return Double.parseDouble(num);
      return Integer.parseInt(num);
    }

private Boolean bool() {
      if (s.charAt(i) == 't') { i += 4; return Boolean.TRUE; }
      i += 5; return Boolean.FALSE;
    }

private Object nul() { i += 4; return null; }

private void skip() { while (i < s.length() && Character.isWhitespace(s.charAt(i))) i++; }
  }
}

Lo que hay que aprender de la ejecución:

La serialización recorre un gráfico de objetos y emite texto. La línea serialized muestra un Map/List anidado renderizado como {"name":"Ada",...,"languages":["Java","Ada"]} — un array dentro de un objeto. ObjectMapper.writeValueAsString hace el mismo recorrido recursivo sobre los getters de tu POJO o los componentes de un record.
El análisis reconstruye primero un árbol genérico. El tipo en tiempo de ejecución del valor analizado es LinkedHashMap, no User — exactamente el modelo de árbol de Jackson, donde readTree te da un JsonNode que navegas por clave antes de que intervenga ninguna clase.
Los números JSON se convierten en números Java, con una decisión de tipo. El campo age volvió como un Integer (42) porque el texto no tenía punto decimal; el analizador eligió Integer sobre Double. Jackson toma la decisión idéntica, razón por la cual un campo int se enlaza limpiamente mientras que 3.14 llegaría como un Double.
El acceso a los campos es por nombre y el orden se preserva. Usar LinkedHashMap mantuvo las claves en orden de inserción, por lo que name se lee antes que age. Jackson preserva el orden de las claves del objeto de la misma manera, razón por la cual el JSON procesado en un viaje de ida y vuelta se ve igual que el original.
El viaje de ida y vuelta es sin pérdida cuando el modelo coincide. La última línea re-serializó el árbol analizado al mismo JSON del que vino, y el User record tipado enlazó name, age y languages correctamente — el punto central del enlace de datos: texto dentro, objeto fuera, texto de vuelta, sin deriva.

Práctica

Con Jackson, recibes una respuesta JSON cuya estructura no controlas y solo necesitas leer dos campos de un documento grande y profundamente anidado. ¿Qué enfoque se adapta mejor?

Analizarlo en un árbol 'JsonNode' con 'ObjectMapper.readTree' y extraer los dos campos con 'get(...)'Crear una clase Java completa que refleje cada campo del documento y usar 'readValue' para el enlace de datosConcatenar las cadenas JSON sin procesar y extraer los valores con 'String.substring'Usar un 'DatagramSocket' para transmitir el JSON y leer los campos del flujo