Konvertieren Sie JSON in Spring Boot MongoDB-Schema!

Geben Sie JSON ein und konvertieren Sie es in ein Spring Boot MongoDB-Schema! Unterstützt Spring Data MongoDB, @Document, @Id.
JSON
Ergebnis
 

Konvertieren Sie JSON in Spring Boot MongoDB-Schema!

Wandelt JSON-Dokumente in eine @Document-Klasse für Spring Data MongoDB um: die in @Document benannte Collection, ein @Id-Feld, ein private-Feld pro Key mit @Field, wo der gespeicherte Key abweicht, dazu Annotationen von Lombok und jakarta.validation, alles in einer Java-Datei.

Verwende es, wenn Daten, die als einfaches JSON in MongoDB landen (IoT-Messwerte, Events, Scraping-Ergebnisse), aus einem Spring-Boot-Service über ein MongoRepository gelesen und geschrieben werden sollen.

So funktioniert es

  1. Füge Dokumente ein, die in der Collection liegen oder liegen werden. Fügst du mehrere als Array ein, etwa die Ausgabe von find().limit(5) in mongosh, werden gelegentliche Felder von ständig vorhandenen unterschieden.
  2. Gib einen Modellname ein (leer bedeutet MyModel); er wird sowohl für den Klassennamen als auch für die Collection in @Document(collection = "...") verwendet.
  3. Korrigiere die package-Zeile, speichere die Datei und lege ein Repository an, das MongoRepository<DeviceLog, String> erweitert.

Beispiel

Eingabe (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" }
]
Ausgabe (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 kommt nur im zweiten Dokument vor und hat daher keine Annotation. device_id und recorded_at werden über @Field("device_id") und @Field("recorded_at") gelesen, sodass bestehende Dokumente ohne Migration auf die camelCase-Felder passen.

Unterstützte Funktionen

  • Benennt die Collection explizit mit @Document(collection = "DeviceLog").
  • @Id private String id hält das _id von MongoDB; ein Key id oder _id in deinem JSON wird darin aufgenommen statt wiederholt, und eine numerische id macht es zu Long.
  • Jedes Feld wird anhand seiner Werte als Long, Double, Boolean, LocalDate (YYYY-MM-DD), LocalDateTime (Datum mit Uhrzeit) oder String typisiert; eingebettete Objekte werden zu Map<String, Object> und Arrays zu List<...>.
  • @Field("...") wird immer dann ergänzt, wenn der Java-Name nicht dem gespeicherten Key entspricht, auch bei Java-Schlüsselwörtern, die mit angehängtem _ umbenannt wurden.
  • Felder, die in jedem Dokument vorkommen, bekommen bei nicht leeren Strings @NotEmpty(), sonst @NotNull(); gelegentliche oder null-Felder bekommen keine.

Anwendungsfälle

Abfrage-APIs über Sensor- oder Log-Collections

Sollen Messwerte, die Geräte direkt in MongoDB schreiben, an ein Dashboard ausgeliefert werden, füge ein paar Dokumente ein, um die Klasse zu bekommen, und deklariere sofort abgeleitete Abfragen wie findByDeviceIdOrderByRecordedAtDesc.

Eine Collection mit einem Node.js-Service teilen

Muss Spring eine Collection lesen, die ein anderer Service bereits in snake_case schreibt, erlauben die @Field-Annotationen der Java-Seite camelCase-Namen, während dieselben Keys gelesen und geschrieben werden.

Hinweise und Einschränkungen

  • @NotEmpty und @NotNull werden beim Speichern standardmäßig nicht geprüft; registriere eine ValidatingMongoEventListener-Bean, um direkt vor save() zu validieren.
  • LocalDateTime wird in MongoDB als UTC-basiertes Date gespeichert und kann je nach Zeitzone des Servers verschoben erscheinen. Für Logs, bei denen der genaue Zeitpunkt zählt, ist Instant sicherer.
  • Eine Long-ID wird nicht von MongoDB erzeugt; du musst sie vor dem Speichern zuweisen. Automatisch befüllt werden nur IDs vom Typ String, ObjectId und BigInteger.
  • Eingebettete Dokumente kommen als Map<String, Object> heraus. Ersetze sie durch kleine Klassen, wenn du typisierten Zugriff und Validierung willst.

Häufige Fragen

Warum heißt das Feld id, wenn MongoDB _id speichert?

Spring Data bildet ein Feld namens id (oder mit @Id annotiert) automatisch auf _id ab und wandelt einen String in eine ObjectId um, wenn er wie eine aussieht. _id selbst zu deklarieren ist unnötig.

Ich möchte, dass die Collection device_logs heißt.

Bearbeite einfach den String: @Document(collection = "device_logs"). Der Generator setzt den Modellnamen so ein, wie er eingegeben wurde; gibst du device_logs als Modellnamen ein, würde aber auch die Klasse zu DeviceLogs.

Was unterscheidet das von einer JPA-Entity?

Es verwendet @Document, @Field und das @Id von Spring Data statt @Entity, @Column und @GeneratedValue, und verschachtelte Werte bleiben eingebettet, statt eine JSON-Spalte zu brauchen. Für relationale Tabellen nimm die Seite JSON → Spring Boot JPA.