¡Convierte JSON a esquema de Spring Boot MongoDB!

¡Introduce JSON y conviértelo en esquema de Spring Boot MongoDB! Compatible con Spring Data MongoDB, @Document, @Id.
JSON
Resultado
 

¡Convierte JSON a esquema de Spring Boot MongoDB!

Convierte documentos JSON en una clase @Document de Spring Data MongoDB: la colección indicada en @Document, un campo @Id, un campo private por clave con @Field donde la clave almacenada difiere, más anotaciones de Lombok y jakarta.validation, todo en un solo archivo Java.

Úsalo cuando datos que llegan a MongoDB como JSON plano (lecturas de IoT, eventos, resultados de scraping) tienen que leerse y escribirse desde un servicio Spring Boot a través de un MongoRepository.

Cómo usar

  1. Pega documentos que están o estarán en la colección. Si pegas varios como array, por ejemplo la salida de find().limit(5) en mongosh, los campos ocasionales se distinguen de los constantes.
  2. Escribe un Nombre del modelo (vacío equivale a MyModel); se usa tanto para el nombre de la clase como para la colección en @Document(collection = "...").
  3. Corrige la línea package, guarda el archivo y crea un repositorio que extienda MongoRepository<DeviceLog, String>.

Ejemplo

Entrada (JSON)
[
  { "device_id": "th-sensor-07", "temperature": 21.4, "battery": 87, "online": true, "recorded_at": "2024-02-11T06:00:00Z" },
  { "device_id": "th-sensor-09", "temperature": 19.8, "battery": 12, "online": false, "recorded_at": "2024-02-11T06:00:00Z", "firmware": "1.4.2" }
]
Salida (Spring Data MongoDB)
package com.hello.world.devicelog;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;

import java.time.LocalDateTime;

import lombok.Getter;
import lombok.Setter;
import lombok.experimental.FieldNameConstants;

@Document(collection = "DeviceLog")
@FieldNameConstants
@Getter
@Setter
public class DeviceLog {
    @Id
    private String id;

    @NotEmpty()
    @Field("device_id")
    private String deviceId;

    @NotNull()
    private Double temperature;

    @NotNull()
    private Long battery;

    @NotNull()
    private Boolean online;

    @NotNull()
    @Field("recorded_at")
    private LocalDateTime recordedAt;

    private String firmware;
}

firmware solo aparece en el segundo documento, así que no tiene anotación. device_id y recorded_at se leen mediante @Field("device_id") y @Field("recorded_at"), de modo que los documentos existentes se mapean a los campos camelCase sin migración.

Funciones compatibles

  • Nombra la colección de forma explícita con @Document(collection = "DeviceLog").
  • @Id private String id contiene el _id de MongoDB; una clave id o _id en tu JSON se integra en él en lugar de repetirse, y un id numérico lo convierte en Long.
  • Cada campo se tipa a partir de sus valores como Long, Double, Boolean, LocalDate (YYYY-MM-DD), LocalDateTime (fechas con hora) o String; los objetos embebidos pasan a Map<String, Object> y los arrays a List<...>.
  • Se añade @Field("...") siempre que el nombre en Java no es la clave almacenada, incluidas las palabras reservadas de Java renombradas con un _ al final.
  • Los campos presentes en todos los documentos reciben @NotEmpty() si son cadenas no vacías y @NotNull() en los demás casos; los campos ocasionales o null no reciben ninguna.

Casos de uso

APIs de consulta sobre colecciones de sensores o logs

Cuando las lecturas que los dispositivos escriben directamente en MongoDB deben servirse a un dashboard, pega unos cuantos documentos para obtener la clase y declara enseguida derived queries como findByDeviceIdOrderByRecordedAtDesc.

Compartir una colección con un servicio Node.js

Si Spring necesita leer una colección que otro servicio ya escribe en snake_case, las anotaciones @Field permiten al lado Java usar nombres camelCase mientras lee y escribe las mismas claves.

Notas y limitaciones

  • @NotEmpty y @NotNull no se comprueban al guardar por defecto; registra un bean ValidatingMongoEventListener para validar justo antes de save().
  • LocalDateTime se guarda en MongoDB como un Date basado en UTC y puede aparecer desplazado según la zona horaria del servidor. Para logs en los que importa el instante exacto, Instant es más seguro.
  • MongoDB no genera un id Long; debes asignarlo antes de guardar. Solo los ids String, ObjectId y BigInteger se rellenan automáticamente.
  • Los documentos embebidos salen como Map<String, Object>. Sustitúyelos por clases pequeñas cuando quieras acceso tipado y validación.

Preguntas frecuentes

¿Por qué el campo se llama id si MongoDB guarda _id?

Spring Data mapea automáticamente a _id un campo llamado id (o anotado con @Id) y convierte un String en ObjectId cuando lo parece. No hace falta declarar _id tú mismo.

Quiero que la colección se llame device_logs.

Basta con editar la cadena: @Document(collection = "device_logs"). El generador inserta el nombre del modelo tal como lo escribes, así que introducir device_logs como nombre del modelo también convertiría la clase en DeviceLogs.

¿En qué se diferencia de una entidad JPA?

Usa @Document, @Field y el @Id de Spring Data en lugar de @Entity, @Column y @GeneratedValue, y los valores anidados se quedan embebidos en lugar de necesitar una columna JSON. Para tablas relacionales, usa la página JSON → Spring Boot JPA.