¿Por qué `Long` y `Double` y no `long` y `double`?

Porque un campo JSON puede ser nulo y un primitivo no. Decodificar `{"score": null}` en un `double` lanza una excepción o da 0.0 en silencio, según la biblioteca y sus ajustes. Los tipos envueltos hacen representable la ausencia, y son además los que exigen los genéricos si el valor acaba en una `List`.

¿De dónde sale el `@JsonProperty`?

De que la clave no sobrevive al viaje. `content-type` no puede ser nombre de componente: pasa a `contentType`, y Jackson busca entonces `contentType` en el JSON sin encontrar nada. La anotación fija la clave original. Faltaba: el record dejaba de leer en silencio el documento del que venía. Era un defecto real, corregido.

Uso Gson, no Jackson. ¿Qué cambia?

La anotación. Gson quiere `@SerializedName("content-type")` en el mismo sitio, y JSON-B quiere `@JsonbProperty`. Los nombres de componente y los tipos son idénticos en ambos casos: sustituir la anotación y su import es toda la adaptación.

JSON a Java — records que Jackson sí decodifica

Convierte una muestra JSON en records de Java. Tipos envueltos y anotación Jackson donde un nombre tuvo que cambiar: el payload se decodifica tal cual.

Instantáneo Privado Cero cookies

Nombre raíz

Entrada JSON

Salida Java

Qué hace esta herramienta

Una muestra JSON pasa a ser records de Java, uno por objeto.

{ "id": 1, "firstName": "Ada", "address": { "city": "Paris" } }

public record Root(
    Long id,
    String firstName,
    Address address
) {}

public record Address(
    String city
) {}

Los records son la forma más corta de expresar «datos y nada más» en el Java moderno: constructor, accesores, equals, hashCode y toString vienen con ellos. Hacen falta Java 16 o posterior.

La clave sobrevive al renombrado

Un nombre de componente sigue las reglas de Java: sin guion, sin dígito inicial, sin palabra reservada. content-type pasa a contentType, class a class_, 2fa a f2fa. Cada vez que el nombre debe cambiar, la clave original lo acompaña:

import com.fasterxml.jackson.annotation.JsonProperty;

public record Root(
    @JsonProperty("content-type") String contentType,
    @JsonProperty("class") Long class_,
    Boolean ok
) {}

Sin esa anotación, Jackson busca contentType y no encuentra nada: el record ya no lee el documento del que salió. Faltaba hasta que se escribió esta página; el defecto está corregido, y la anotación aparece solo donde el nombre cambió de verdad, con su import.

Tipos envueltos, y por qué

Cada número es un Long o un Double, cada booleano un Boolean. JSON tiene null, los primitivos de Java no, y un double que recibe un null se queda en 0.0, un valor que ya no se distingue de un cero de verdad. Los tipos envueltos mantienen el null representable, que es lo que el formato permite.

Por la misma razón, null y los valores desconocidos pasan a Object, y un array de ellos a List<Object>.

Lo que una muestra no puede decir

Nada es opcional y nada lleva @Nullable: cada componente está ahí porque el documento lo traía. Los records son inmutables en superficie: un campo que más tarde decidas que puede faltar es un cambio de forma, no una bandera.

Un escalar en la raíz —42, "texto"— se rechaza: Java no tiene alias de tipo, así que no hay nada que nombrar. Un array JSON de objetos te da el record de su elemento, que es la forma que de verdad enlazas a una List<Root>.

Privado por diseño

Todo se ejecuta localmente en tu navegador con JavaScript. Tus datos nunca se suben a un servidor, lo que hace que la herramienta sea segura para contenido sensible y funcione sin conexión.

Preguntas frecuentes

¿Por qué `Long` y `Double` y no `long` y `double`?: Porque un campo JSON puede ser nulo y un primitivo no. Decodificar `{"score": null}` en un `double` lanza una excepción o da 0.0 en silencio, según la biblioteca y sus ajustes. Los tipos envueltos hacen representable la ausencia, y son además los que exigen los genéricos si el valor acaba en una `List`.
¿De dónde sale el `@JsonProperty`?: De que la clave no sobrevive al viaje. `content-type` no puede ser nombre de componente: pasa a `contentType`, y Jackson busca entonces `contentType` en el JSON sin encontrar nada. La anotación fija la clave original. Faltaba: el record dejaba de leer en silencio el documento del que venía. Era un defecto real, corregido.
Uso Gson, no Jackson. ¿Qué cambia?: La anotación. Gson quiere `@SerializedName("content-type")` en el mismo sitio, y JSON-B quiere `@JsonbProperty`. Los nombres de componente y los tipos son idénticos en ambos casos: sustituir la anotación y su import es toda la adaptación.