Converta JSON para esquema Spring Boot MongoDB!

Introduza JSON e converta-o para esquema Spring Boot MongoDB! Compatível com Spring Data MongoDB, @Document, @Id.
JSON
Resultado
 

Converta JSON para esquema Spring Boot MongoDB!

Converte documentos JSON numa classe @Document do Spring Data MongoDB: a collection nomeada no @Document, um campo @Id, um campo private por chave com @Field onde a chave armazenada difere, mais anotações do Lombok e do jakarta.validation, tudo num único arquivo Java.

Use quando dados que chegam ao MongoDB como JSON puro (leituras de IoT, eventos, resultados de scraping) precisam ser lidos e gravados por um serviço Spring Boot através de um MongoRepository.

Como usar

  1. Cole documentos que estão ou vão estar na collection. Colar vários como array, por exemplo a saída de find().limit(5) no mongosh, separa os campos ocasionais dos constantes.
  2. Digite um Nome do modelo (vazio significa MyModel); ele é usado tanto no nome da classe quanto na collection em @Document(collection = "...").
  3. Ajuste a linha package, salve o arquivo e crie um repository que estenda MongoRepository<DeviceLog, String>.

Exemplo

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" }
]
Saída (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 só aparece no segundo documento, então não tem anotação. device_id e recorded_at são lidos via @Field("device_id") e @Field("recorded_at"), então os documentos existentes são mapeados para os campos em camelCase sem migração.

Recursos suportados

  • Nomeia a collection explicitamente com @Document(collection = "DeviceLog").
  • @Id private String id guarda o _id do MongoDB; uma chave id ou _id no seu JSON é incorporada nele em vez de repetida, e um id numérico o transforma em Long.
  • Cada campo é tipado a partir dos seus valores como Long, Double, Boolean, LocalDate (YYYY-MM-DD), LocalDateTime (data e hora) ou String; objetos embutidos viram Map<String, Object> e arrays, List<...>.
  • @Field("...") é adicionado sempre que o nome Java não é a chave armazenada, incluindo keywords do Java renomeadas com _ no final.
  • Campos presentes em todos os documentos recebem @NotEmpty() para strings não vazias e @NotNull() nos outros casos; campos ocasionais ou null não recebem nenhuma.

Casos de uso

APIs de consulta sobre collections de sensores ou logs

Quando leituras que os dispositivos gravam direto no MongoDB precisam ser servidas a um dashboard, cole alguns documentos para obter a classe e declare na hora derived queries como findByDeviceIdOrderByRecordedAtDesc.

Compartilhar uma collection com um serviço Node.js

Se o Spring precisa ler uma collection que outro serviço já grava em snake_case, as anotações @Field deixam o lado Java usar nomes em camelCase enquanto lê e grava as mesmas chaves.

Observações e limitações

  • @NotEmpty e @NotNull não são checados ao salvar por padrão; registre um bean ValidatingMongoEventListener para validar logo antes do save().
  • LocalDateTime é guardado no MongoDB como um Date baseado em UTC e pode aparecer deslocado dependendo do fuso horário do servidor. Para logs em que o instante exato importa, Instant é mais seguro.
  • Um id Long não é gerado pelo MongoDB; você precisa atribuí-lo antes de salvar. Só ids String, ObjectId e BigInteger são preenchidos automaticamente.
  • Documentos embutidos saem como Map<String, Object>. Troque por classes pequenas quando quiser acesso tipado e validação.

Perguntas frequentes

Por que o campo se chama id se o MongoDB guarda _id?

O Spring Data mapeia automaticamente um campo chamado id (ou anotado com @Id) para _id e converte uma String em ObjectId quando ela tem esse formato. Não é preciso declarar _id você mesmo.

Quero que a collection se chame device_logs.

É só editar a string: @Document(collection = "device_logs"). O gerador insere o nome do modelo como foi digitado, então informar device_logs como nome do modelo também transformaria a classe em DeviceLogs.

Qual a diferença para uma entity JPA?

Ele usa @Document, @Field e o @Id do Spring Data no lugar de @Entity, @Column e @GeneratedValue, e valores aninhados ficam embutidos em vez de precisarem de uma coluna JSON. Para tabelas relacionais, use a página JSON → Spring Boot JPA.