Geneste objecten en relaties modelleren
Ontwerp schema's die hiërarchische gegevens weergeven en relaties tussen verschillende typen definiëren.
Geneste objecten en relaties modelleren is een gratis GraphQL-API's met Spring Boot-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject GraphQL-API's met Spring Boot. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus GraphQL-API's met Spring Boot bevat in totaal 4 lessen.
Waarom geneste gegevens belangrijk zijn
Gegevens uit de echte wereld zijn zelden vlak. Ze bevatten verbindingen en hiërarchieën, zoals een auteur met meerdere boeken of een product met veel reviews. GraphQL is bijzonder geschikt om deze complexe relaties op een natuurlijke manier te modelleren.
In deze les leer je hoe je je schema ontwerpt om gegevens met geneste objecten en verschillende relaties weer te geven, zodat je API intuïtiever en krachtiger wordt.
Geneste typen begrijpen
Een genest object betekent dat één type een ander type als veld bevat. Een Author kan bijvoorbeeld een lijst bevatten van Book-objecten die de auteur heeft geschreven.
Hierdoor kunnen clients gerelateerde gegevens (zoals alle boeken van een auteur) ophalen met één GraphQL-aanvraag, waardoor te veel of te weinig gegevens ophalen wordt beperkt.
Geneste typen definiëren in SDL
In GraphQL's Schema Definition Language (SDL) definieer je geneste typen rechtstreeks. Hier bevat een Author-type een lijst met Book-objecten.
Let op de syntaxis [Book!]!: dit betekent een lijst die niet null is en die alleen boeken bevat die niet null zijn.
type Book {
id: ID!
title: String!
publicationYear: Int
}
type Author {
id: ID!
name: String!
books: [Book!]! # List of books by this author
}
type Query {
author(id: ID!): Author
}Java-modellen voor geneste gegevens
In Spring Boot moeten je Java-gegevensmodellen (POJO's of records) je GraphQL-schema weerspiegelen. Zo wordt het toewijzen van gegevens tussen je backend en de GraphQL-API eenvoudig.
Meestal heb je afzonderlijke klassen voor elk GraphQL-type, met velden die overeenkomen met het schema.
// src/main/java/com/example/model/Author.java
class Author {
private String id;
private String name;
private List<Book> books;
// Constructor, getters, setters...
}
// src/main/java/com/example/model/Book.java
class Book {
private String id;
private String title;
private Integer publicationYear;
// Constructor, getters, setters...
}Geneste velden oplossen
Wanneer een client een Author en diens books opvraagt, lost Spring Boot GraphQL eerst het Author-object op. Vervolgens zoekt het naar een manier om het veld books van die Author op te lossen.
Als je Java-object een overeenkomende getter heeft (bijvoorbeeld getBooks()), kan Spring Boot GraphQL de geneste lijst vaak automatisch ophalen.
Geneste gegevens opvragen
Clients kunnen alle geneste gegevens ophalen met één duidelijke query. Dit is een groot voordeel van GraphQL ten opzichte van traditionele REST-API's, waarbij je op de client mogelijk meerdere aanvragen of complexe joinlogica nodig hebt.
Let erop hoe books en de bijbehorende velden rechtstreeks binnen het veld author worden opgevraagd.
query GetAuthorWithBooks {
author(id: "author-1") {
id
name
books {
id
title
publicationYear
}
}
}Het oplossen van geneste gegevens simuleren
Deze vereenvoudigde Java-code laat zien hoe een datafetcher een Author-object kan voorbereiden dat de bijbehorende Book-objecten al bevat. Deze structuur kan GraphQL vervolgens rechtstreeks beschikbaar maken.
Voer de code uit om te zien hoe de geneste gegevens worden weergegeven.
import java.util.Arrays;
import java.util.List;
// Simplified Book class
class Book {
String id;
String title;
Integer publicationYear;
public Book(String id, String title, Integer publicationYear) {
this.id = id;
this.title = title;
this.publicationYear = publicationYear;
}
// Getters for GraphQL to access fields
public String getId() { return id; }
public String getTitle() { return title; }
public Integer getPublicationYear() { return publicationYear; }
}
// Simplified Author class
class Author {
String id;
String name;
List<Book> books;
public Author(String id, String name, List<Book> books) {
this.id = id;
this.name = name;
this.books = books;
}
// Getters for GraphQL to access fields
public String getId() { return id; }
public String getName() { return name; }
public List<Book> getBooks() { return books; }
}
public class Main {
public static void main(String[] args) {
// Create some books
Book book1 = new Book("b1", "The Martian", 2011);
Book book2 = new Book("b2", "Project Hail Mary", 2021);
List<Book> authorsBooks = Arrays.asList(book1, book2);
// Create an author with their books
Author author = new Author("a1", "Andy Weir", authorsBooks);
// Demonstrate accessing the nested data
System.out.println("Author: " + author.getName());
System.out.println("Books written:");
for (Book book : author.getBooks()) {
System.out.println(" - " + book.getTitle() + " (" + book.getPublicationYear() + ")");
}
}
}Relaties begrijpen: één-op-veel
Het voorbeeld van de relatie tussen Author en Book dat we hebben gebruikt, is een klassieke relatie van één-op-veel: één auteur kan veel boeken schrijven.
Een GraphQL-schema ondersteunt dit van nature door een veld te definiëren als een lijst van een ander type (bijvoorbeeld books: [Book!]!), waardoor je eenvoudig alle gerelateerde items kunt ophalen.
Verwijzen naar gerelateerde objecten
Soms zijn gegevens niet rechtstreeks ingebed in één object of daarin beschikbaar. Een Book kan bijvoorbeeld intern alleen een authorId opslaan en niet het volledige Author-object.
Je kunt dit toch in GraphQL modelleren door Author als veld van Book op te nemen. Spring Boot GraphQL lost het veld Author vervolgens op door het volledige Author-object op te halen op basis van de authorId.
type Book {
id: ID!
title: String!
author: Author! # Reference to the Author type
}
type Author {
id: ID!
name: String!
}Controleer je begrip
Denk na over een GraphQL-schema voor een e-commercetoepassing. Een Product kan veel Reviews hebben en elke Review is geschreven door een specifieke User.
Samenvatting: relaties modelleren
In deze les heb je geleerd hoe je geneste objecten en relaties in je GraphQL-schema modelleert. We hebben het volgende behandeld:
- Velden definiëren die lijsten van andere typen zijn (bijvoorbeeld
books: [Book!]!) om één-op-veelrelaties weer te geven. - Deze hiërarchische structuren weerspiegelen in je Spring Boot-gegevensmodellen.
- Begrijpen hoe GraphQL deze geneste velden automatisch oplost, vaak via Java-getters.
- Complexe, hiërarchische gegevens efficiënt opvragen met één GraphQL-aanvraag.
Het beheersen van geneste objecten en relaties is essentieel voor het bouwen van krachtige en intuïtieve GraphQL-API's die de gegevensstructuur van je toepassing echt weerspiegelen.
Leer GraphQL-API's met Spring Boot met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Geneste objecten en relaties modelleren” gratis?
Ja — de volledige tekst van “Geneste objecten en relaties modelleren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus GraphQL-API's met Spring Boot wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus GraphQL-API's met Spring Boot bevat in totaal 4 lessen.
Wat leer ik in “Geneste objecten en relaties modelleren”?
Ontwerp schema's die hiërarchische gegevens weergeven en relaties tussen verschillende typen definiëren. Je oefent met GraphQL-API's met Spring Boot door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met GraphQL-API's met Spring Boot te beginnen?
Ervaring vooraf is niet nodig. GraphQL-API's met Spring Boot op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Geneste objecten en relaties modelleren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over GraphQL-API's met Spring Boot?
Ja. Elke les over GraphQL-API's met Spring Boot bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Geneste objecten en relaties modelleren
- Interfaces en uniontypen implementeren
- Inputtypen benutten voor mutations
- Enums en aangepaste scalartypen