NoSQL-databases verschillen van relationele databases doordat ze complexere structuren toelaten zonder traditionele relaties zoals één-op-veel of één-op-één te vereisen. In plaats daarvan maken NoSQL-databases gebruik van flexibele typen, zoals arrays of subdocumenten, om gerelateerde data efficiënt op te slaan binnen één document. Deze flexibiliteit stelt ontwikkelaars in staat modellen te ontwerpen die passen bij de query- en prestatiebehoeften van hun toepassing.
Jakarta NoSQL is een Java-framework dat interacties met NoSQL-databases, waaronder MongoDB, vereenvoudigt. Het biedt annotaties die bepalen hoe data wordt gemapt en opgeslagen, waardoor ontwikkelaars kunnen bepalen of ingesloten objecten gegroepeerd of vlak opgeslagen worden.
Bij het werken met MongoDB en Jakarta NoSQL is een van de belangrijkste overwegingen hoe je je documenten structureert. De keuze tussen een vlakke structuur en een gegroepeerde structuur heeft invloed op hoe de data wordt opgeslagen, bevraagd en opgehaald. In dit artikel verkennen we deze twee benaderingen aan de hand van een praktisch voorbeeld.
Jakarta NoSQL en Product Entity
Om de vlakke en gegroepeerde structuren te begrijpen, laten we eerst de Product entiteit introduceren en zien hoe Jakarta NoSQL-annotaties werken:
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();
}
}
Laten we nu verkennen hoe het veld fabrikant anders kan worden opgeslagen op basis van Jakarta NoSQL-annotaties.
Begrip van Gegroepeerde en Vlakke Structuren
Gegroepeerde Structuur
Een gegroepeerde structuur organiseert gerelateerde informatie in afzonderlijke objecten binnen het document. Deze aanpak verbetert de leesbaarheid en maakt een schonere domeinmodelleringspraktijk mogelijk. Jakarta NoSQL bereikt dit door gebruik te maken van @Embeddable(Embeddable.EmbeddableType.GROUPING).
Voorbeeld:
{
"_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 wordt de fabrikant gegroepeerd in een apart sub-object in plaats van de eigenschappen op het hoogste niveau te hebben.
(Embeddable.EmbeddableType.GROUPING)
public record Manufacturer( String name, String address, String contactNumber) {}
Platte Structuur
Een platte structuur houdt gerelateerde informatie binnen hetzelfde document, waarbij lijsten of geneste velden direct worden ingebed. Jakarta NoSQL maakt dit mogelijk door gebruik te maken van @Embeddable(Embeddable.EmbeddableType.FLAT). Deze aanpak is gunstig wanneer u snel toegang wilt hebben tot alle details zonder ingewikkelde queries te hoeven uitvoeren.
Voorbeeld:
{
"_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"]
}
Deze aanpak slaat fabrikantdetails direct op in het document in plaats van ze te groeperen in aparte velden.
(Embeddable.EmbeddableType.FLAT)
public record Manufacturer( String name, String address, String contactNumber) {}
Voorbeeldgebruik in Jakarta NoSQL
De volgende codefragment laat zien hoe Jakarta NoSQL deze structuren integreert:
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);
}
}
}
De Juiste Aanpak Kiezen
- Gebruik een platte structuur wanneer u een eenvoudigere documentindeling nodig heeft met alle eigenschappen op hetzelfde niveau.
- Gebruik een gegroepeerde structuur wanneer u gerelateerde gegevens in logische sub-objecten wilt organiseren om de leesbaarheid en onderhoudbaarheid te verbeteren.
Conclusie
Jakarta NoSQL biedt flexibiliteit in het structureren van MongoDB-documenten met @Embeddable(Embeddable.EmbeddableType). De keuze tussen plat of gegroepeerde structuren hangt af van uw gegevenstoegangspatronen en modellering voorkeuren. Het begrijpen van deze benaderingen maakt een efficiënte database-ontwerp mogelijk, waardoor queries effectiever worden en uw domeinmodel schoon en goed gestructureerd blijft.
Voor de complete code, bezoek de GitHub-repository.
Video
Source:
https://dzone.com/articles/handling-embedded-data-in-nosql-with-java