NoSQL-Datenbanken unterscheiden sich von relationalen Datenbanken, indem sie komplexere Strukturen ermöglichen, ohne traditionelle Beziehungen wie Eins-zu-Viele oder Eins-zu-Eins zu verlangen. Stattdessen nutzen NoSQL-Datenbanken flexible Typen wie Arrays oder Unterdokumente, um verwandte Daten effizient innerhalb eines einzelnen Dokuments zu speichern. Diese Flexibilität ermöglicht es Entwicklern, Modelle zu entwerfen, die den Abfrage- und Leistungsanforderungen ihrer Anwendung entsprechen.
Jakarta NoSQL ist ein Java-Framework, das die Interaktionen mit NoSQL-Datenbanken, einschließlich MongoDB, vereinfacht. Es bietet Annotations, die bestimmen, wie Daten abgebildet und gespeichert werden, sodass Entwickler kontrollieren können, ob eingebettete Objekte gruppiert oder flach gespeichert werden.
Bei der Arbeit mit MongoDB und Jakarta NoSQL ist eine der wichtigsten Überlegungen, wie man seine Dokumente strukturiert. Die Wahl zwischen einer flachen Struktur und einer gruppierten Struktur beeinflusst, wie die Daten gespeichert, abgefragt und abgerufen werden. In diesem Artikel untersuchen wir diese beiden Ansätze anhand eines praktischen Beispiels.
Jakarta NoSQL und Produktentität
Um die flachen und gruppierten Strukturen zu verstehen, lassen Sie uns zunächst die Produkt-Entität einführen und sehen, wie die Annotations von Jakarta NoSQL funktionieren:
public class Product {
(ObjectIdConverter.class)
private String id;
private String name;
private Manufacturer manufacturer;
private List<String> tags;
private Set<Category> categories;
Product(String name, Manufacturer manufacturer, List<String> tags, Set<Category> categories) {
this.name = name;
this.manufacturer = manufacturer;
this.tags = tags;
this.categories = categories;
}
public static ProductBuilder builder() {
return new ProductBuilder();
}
}
Jetzt wollen wir erkunden, wie das Feld hersteller je nach Annotations von Jakarta NoSQL unterschiedlich gespeichert werden kann.
Verständnis von gruppierten und flachen Strukturen
Gruppierte Struktur
Eine gruppierte Struktur organisiert verwandte Informationen in separaten Objekten innerhalb des Dokuments. Dieser Ansatz verbessert die Lesbarkeit und ermöglicht eine sauberere Domänenmodellierungspraxis. Jakarta NoSQL erreicht dies durch die Verwendung von @Embeddable(Embeddable.EmbeddableType.GROUPING).
Beispiel:
{
"_id": { "$oid": "67b264520abd020ec0eb9a4c" },
"categories": [
{ "name": "Computers", "description": "All computers" },
{ "name": "Electronics", "description": "All electronics" }
],
"manufacturer": {
"address": "One Infinite Loop Cupertino, CA 95014",
"name": "Apple",
"contactNumber": "+1-408-996-1010"
},
"name": "MacBook Pro",
"tags": ["smartphone", "tablet", "laptop"]
}
Hier wird der Hersteller gruppiert in ein separates Unterobjekt anstatt seine Eigenschaften auf der obersten Ebene zu haben.
(Embeddable.EmbeddableType.GROUPING)
public record Manufacturer( String name, String address, String contactNumber) {}
Flache Struktur
Eine flache Struktur behält verwandte Informationen im selben Dokument bei, indem Listen oder verschachtelte Felder direkt eingebettet werden. Jakarta NoSQL ermöglicht dies durch die Verwendung von @Embeddable(Embeddable.EmbeddableType.FLAT). Dieser Ansatz ist nützlich, wenn Sie schnellen Zugriff auf alle Details wünschen, ohne komplexe Abfragen durchführen zu müssen.
Beispiel:
{
"_id": { "$oid": "67b22d20c921154b0223b27b" },
"address": "One Infinite Loop Cupertino, CA 95014",
"categories": [
{ "name": "Electronics", "description": "All electronics" },
{ "name": "Computers", "description": "All computers" }
],
"contactNumber": "+1-408-996-1010",
"name": "Apple",
"tags": ["smartphone", "tablet", "laptop"]
}
Dieser Ansatz speichert Herstellerdetails direkt im Dokument anstatt sie in separate Felder zu gruppieren.
(Embeddable.EmbeddableType.FLAT)
public record Manufacturer( String name, String address, String contactNumber) {}
Beispielhafte Verwendung in Jakarta NoSQL
Der folgende Code-Schnipsel zeigt, wie Jakarta NoSQL diese Strukturen integriert:
public class App {
public static void main(String[] args) {
var faker = new Faker();
try (SeContainer container = SeContainerInitializer.newInstance().initialize()) {
var template = container.select(DocumentTemplate.class).get();
var electronicsCategory = new Category("Electronics", "All electronics");
var computerCategory = new Category("Computers", "All computers");
var tags = List.of("smartphone", "tablet", "laptop");
var manufacturer = new Manufacturer("Apple", "One Infinite Loop Cupertino, CA 95014", "+1-408-996-1010");
Product macBookPro = Product.builder().categories(Set.of(electronicsCategory, computerCategory))
.manufacturer(manufacturer)
.name("MacBook Pro")
.tags(tags)
.build();
Product product = template.insert(macBookPro);
System.out.println("Product saved: " + product);
}
}
}
Auswahl des richtigen Ansatzes
- Verwenden Sie eine flache Struktur, wenn Sie ein einfacheres Dokumentenlayout mit allen Eigenschaften auf der gleichen Ebene benötigen.
- Verwenden Sie eine gruppierte Struktur, um verwandte Daten in logische Unterobjekte zu organisieren, um die Lesbarkeit und Wartbarkeit zu verbessern.
Zusammenfassung
Jakarta NoSQL bietet Flexibilität bei der Strukturierung von MongoDB-Dokumenten mit @Embeddable(Embeddable.EmbeddableType). Die Wahl zwischen flachen oder gruppierten Strukturen hängt von Ihren Datenzugriffsmustern und Modellierungsvorlieben ab. Das Verständnis dieser Ansätze ermöglicht eine effiziente Datenbankgestaltung, wodurch Abfragen effektiver werden, während Ihr Domänenmodell sauber und gut strukturiert bleibt.
Für den vollständigen Code besuchen Sie das GitHub-Repository.
Video
Source:
https://dzone.com/articles/handling-embedded-data-in-nosql-with-java