Convertir JSON en un schéma Spring Boot MongoDB !

Entrez JSON et convertissez-le en schéma Spring Boot MongoDB ! Compatible avec Spring Data MongoDB, @Document, @Id.
JSON
Résultat
 

Convertir JSON en un schéma Spring Boot MongoDB !

Convertit des documents JSON en classe @Document Spring Data MongoDB : la collection nommée dans @Document, un champ @Id, un champ private par clé avec @Field quand la clé stockée diffère, plus des annotations Lombok et jakarta.validation, le tout dans un seul fichier Java.

À utiliser quand des données qui arrivent dans MongoDB en JSON brut (mesures IoT, événements, résultats de scraping) doivent être lues et écrites depuis un service Spring Boot via un MongoRepository.

Mode d'emploi

  1. Collez des documents présents ou à venir dans la collection. En coller plusieurs sous forme de tableau, comme la sortie de find().limit(5) dans mongosh, permet de distinguer les champs occasionnels des champs constants.
  2. Tapez un Nom du modèle (vide signifie MyModel) ; il sert à la fois de nom de classe et de collection dans @Document(collection = "...").
  3. Corrigez la ligne package, enregistrez le fichier et créez un repository qui étend MongoRepository<DeviceLog, String>.

Exemple

Entrée (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" }
]
Sortie (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 n'apparaît que dans le deuxième document : il n'a donc pas d'annotation. device_id et recorded_at sont lus via @Field("device_id") et @Field("recorded_at"), si bien que les documents existants se mappent sur les champs camelCase sans migration.

Fonctionnalités prises en charge

  • Nomme explicitement la collection avec @Document(collection = "DeviceLog").
  • @Id private String id contient le _id de MongoDB ; une clé id ou _id dans votre JSON y est intégrée plutôt que répétée, et un id numérique le fait passer en Long.
  • Chaque champ est typé d'après ses valeurs en Long, Double, Boolean, LocalDate (YYYY-MM-DD), LocalDateTime (dates-heures) ou String ; les objets embarqués deviennent Map<String, Object> et les tableaux List<...>.
  • @Field("...") est ajouté chaque fois que le nom Java n'est pas la clé stockée, y compris pour les mots-clés Java renommés avec un _ final.
  • Les champs présents dans chaque document reçoivent @NotEmpty() pour les chaînes non vides et @NotNull() sinon ; les champs occasionnels ou null n'en reçoivent aucune.

Cas d'utilisation

API de consultation sur des collections de capteurs ou de logs

Quand des mesures que les appareils écrivent directement dans MongoDB doivent alimenter un tableau de bord, collez quelques documents pour obtenir la classe et déclarez aussitôt des requêtes dérivées comme findByDeviceIdOrderByRecordedAtDesc.

Partager une collection avec un service Node.js

Si Spring doit lire une collection qu'un autre service écrit déjà en snake_case, les annotations @Field permettent au côté Java d'utiliser des noms camelCase tout en lisant et écrivant les mêmes clés.

Remarques et limites

  • @NotEmpty et @NotNull ne sont pas vérifiés à l'enregistrement par défaut ; déclarez un bean ValidatingMongoEventListener pour valider juste avant save().
  • LocalDateTime est stocké dans MongoDB sous forme de Date basée sur UTC et peut apparaître décalé selon le fuseau horaire du serveur. Pour des logs où l'instant exact compte, Instant est plus sûr.
  • Un id Long n'est pas généré par MongoDB ; vous devez l'attribuer avant l'enregistrement. Seuls les ids String, ObjectId et BigInteger sont remplis automatiquement.
  • Les documents embarqués sortent en Map<String, Object>. Remplacez-les par de petites classes quand vous voulez un accès typé et de la validation.

FAQ

Pourquoi le champ s'appelle-t-il id alors que MongoDB stocke _id ?

Spring Data associe automatiquement à _id un champ nommé id (ou annoté @Id) et convertit une String en ObjectId quand elle en a la forme. Déclarer _id vous-même est inutile.

Je veux que la collection s'appelle device_logs.

Modifiez simplement la chaîne : @Document(collection = "device_logs"). Le générateur insère le nom du modèle tel que saisi : entrer device_logs comme nom de modèle transformerait aussi la classe en DeviceLogs.

Quelle différence avec une entité JPA ?

On utilise @Document, @Field et l'@Id de Spring Data au lieu de @Entity, @Column et @GeneratedValue, et les valeurs imbriquées restent embarquées au lieu de nécessiter une colonne JSON. Pour des tables relationnelles, utilisez la page JSON → Spring Boot JPA.