JSON a POJO: clases o records Java desde un JSON

Pega tu JSON y obtén código Java listo para usar: una clase por cada objeto, con campos privados, un constructor sin argumentos, getters y setters, o records de Java si lo prefieres. Los objetos anidados se escriben dentro de su clase padre, así que todo el resultado cabe en un único archivo .java. Añade anotaciones de Jackson o Gson cuando necesites conservar las claves originales del JSON. La conversión ocurre en tu navegador y el JSON no se sube a ningún sitio.

JSON to POJO online Java: cómo convertir paso a paso

1. Pega el JSON en el cuadro JSON (muestra «Pega el JSON aquí...»). Un texto pegado se convierte al instante. Si escribes, el código se actualiza unos 300 milisegundos después de que pares.
2. Lee las clases bajo Código Java. Una línea debajo, como «Se generaron 2 clases.», indica cuántas se han escrito.
3. Pulsa Copiar, justo debajo del código. El botón muestra «Copiado» un momento. Guarda el código en un archivo con el nombre de la clase raíz, por ejemplo Root.java.
4. Para cambiar el resultado, abre Ajustes: indica el Nombre de la clase raíz (por defecto Root), elige en Anotaciones entre Ninguna, Jackson o Gson, o marca Usar records en lugar de clases. El código se actualiza en cuanto cambias un ajuste.
5. Pulsa Borrar para vaciar el cuadro y empezar de nuevo.

De JSON a clase Java: un ejemplo

Esto es lo que pegas: { "user_id": 7, "name": "Ana", "price": 4.5, "tags": ["a", "b"], "address": { "city": "Kyoto" } }

Con Anotaciones en «Ninguna», el resultado empieza con import java.util.List; y public class Root. Los campos son Integer userId, String name, Double price, List<String> tags y Address address. Después vienen el constructor sin argumentos y los getters y setters, como getUserId y setUserId.

El objeto anidado address se convirtió en Address, una public static class dentro de Root, y por eso basta con un archivo. La clave user_id pasó a ser el campo userId. La línea de estado te avisa: «Se cambió 1 nombre de campo para adaptarlo a Java.»

JSON a record Java con anotaciones Jackson

Pon el Nombre de la clase raíz en Order, elige Jackson en Anotaciones y marca Usar records en lugar de clases. El mismo JSON se convierte en public record Order(...).

Cada componente del record lleva @JsonProperty("key") con la clave original del JSON, así que user_id sigue asignándose a userId. Si eliges Gson, los mismos componentes llevan @SerializedName("key"), con su importación de Gson. Los records requieren Java 16 o posterior.

Cómo se convierten los tipos de JSON a tipos de Java

Todos los tipos son tipos envoltorio, así que cualquier campo puede faltar o ser nulo.

• Número entero como 7: Integer. Si no cabe (12345678901): Long. Si es aún mayor (99999999999999999999): BigInteger, con su importación.
• Número con punto decimal o exponente, como 4.5, 1.0 o 2e3: Double.
• Texto: String. true o false: Boolean (el getter es getActive, no isActive). null: Object.
• Array de un solo tipo, como ["a", "b"]: List<String>, con java.util.List importado. Array vacío o de tipos mezclados: List<Object>. Array dentro de un array: List<List<Integer>>.
• Objeto: una clase o un record anidado con el nombre de la clave.

Los números se leen exactamente como están escritos, así que un ID largo nunca se redondea. Las importaciones solo aparecen cuando el código las usa. Si una clave aparece dos veces en el mismo objeto, gana la última.

Cómo se eligen los nombres de clases y campos

• user_id y user-name pasan a ser los campos userId y userName (camelCase).
• Una palabra reservada de Java como class pasa a ser _class.
• Un nombre que empieza por un dígito, como 2nd, pasa a ser _2nd.
• Una clave items con un array de objetos da la clase Item y el campo List<Item>: la clave se pone en singular.
• Una clave String con un objeto da StringData. Los nombres que taparían String, List u Object reciben Data al final.
• Dos objetos con el mismo nombre: la segunda clase recibe un número, porque los nombres de clase deben ser únicos en el archivo.

El nombre de la clase raíz se limpia hasta ser un nombre válido de Java, y si el cuadro está vacío se usa Root. Cuando el propio JSON empieza por un array de objetos, Root describe un elemento y la página te indica que leas el JSON como List<Root>.

Cuando el JSON no se acepta

El lector es estricto, como lo es JSON: los comentarios, las comillas simples y las comas finales son errores. El mensaje «No se pudo leer este JSON» da un motivo claro y la posición, como «Línea 3, columna 5», por ejemplo «El analizador se detuvo en «}». Revisa si falta una coma, dos puntos, un corchete o unas comillas justo antes.»

• Si tu texto es un objeto de JavaScript con claves sin comillas o con comillas simples, pásalo primero por «Objeto JavaScript a JSON» para obtener JSON estricto.
• Para ordenar el JSON antes de convertirlo, usa «Formateador de JSON».
• Para comprobar el JSON contra un esquema, usa «Validador de JSON Schema».
• Para interfaces de TypeScript a partir de JavaScript, mira «Convertidor de JS a TS».

Un JSON válido que no contiene ningún objeto, como 42 o un array de números, muestra «Este JSON no contiene ningún objeto del que generar una clase.» Se rechaza el texto de más de 2.000.000 de caracteres y también un anidamiento de más de 200 niveles.

Herramientas relacionadas

Autoprefijador CSS

Pega CSS y obtén prefijos de motor al instante. Gratis.

Desofuscador de JS

Desofusca y ordena código JavaScript ofuscado

Convertidor de JS a TS

Convierte JavaScript a TypeScript, PropTypes a interfaces

Objeto JavaScript a JSON

Convierte un objeto JS en JSON estricto y escapado

Convertidor de JSX a JS

Compila JSX de React a JavaScript en tu navegador