Modellera nästlade objekt och relationer
Utforma scheman som representerar hierarkiska data och definiera relationer mellan olika typer.
Modellera nästlade objekt och relationer är en gratis lektion i GraphQL-API:er med Spring Boot på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för GraphQL-API:er med Spring Boot, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i GraphQL-API:er med Spring Boot innehåller totalt 4 lektioner.
Varför nästlade data är viktigt
Data från verkligheten är sällan platt. Den innehåller kopplingar och hierarkier, till exempel att en författare har flera böcker eller att en produkt har många recensioner. GraphQL är utmärkt för att på ett naturligt sätt modellera dessa komplexa relationer.
I den här lektionen utforskar vi hur du utformar ditt schema för att representera data med nästlade objekt och olika relationer, vilket gör ditt API mer intuitivt och kraftfullt.
Förstå nästlade typer
Ett nästlat objekt innebär att en typ innehåller en annan typ som ett fält. Till exempel kan en Author ha en lista med Book-objekt som författaren har skrivit.
Detta gör det möjligt för klienter att hämta relaterade data (till exempel alla böcker av en författare) i en enda GraphQL-förfrågan, vilket minskar över- och underhämtning.
Definiera nästlade typer i SDL
I GraphQL:s Schema Definition Language (SDL) definierar du nästlade typer direkt. Här innehåller typen Author en lista med Book-objekt.
Observera syntaxen [Book!]!, som betyder en icke-null-lista med icke-null-böcker.
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-modeller för nästlade data
I Spring Boot bör dina Java-datamodeller (POJO:er eller records) motsvara ditt GraphQL-schema. Det gör det enkelt att mappa data mellan backend och GraphQL-API:t.
Vanligtvis har du separata klasser för varje GraphQL-typ, med fält som motsvarar schemat.
// 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...
}Så löses nästlade fält
När en klient begär en Author och dess books löser Spring Boot GraphQL först objektet Author. Därefter letar det efter ett sätt att lösa fältet books för den Author-instansen.
Om ditt Java-objekt har en motsvarande getter (till exempel getBooks()) kan Spring Boot GraphQL ofta hämta den nästlade listan automatiskt.
Ställ frågor mot nästlade data
Klienter kan hämta alla nästlade data med en enda tydlig query. Detta är en stor fördel med GraphQL jämfört med traditionella REST-API:er, där du kan behöva flera förfrågningar eller komplex join-logik på klienten.
Observera hur books och dess fält efterfrågas direkt inuti fältet author.
query GetAuthorWithBooks {
author(id: "author-1") {
id
name
books {
id
title
publicationYear
}
}
}Simulera upplösning av nästlade data
Den här förenklade Java-koden visar hur en data fetcher kan förbereda ett Author-objekt som redan innehåller sina tillhörande Book-objekt. Denna struktur är sedan redo att exponeras av GraphQL.
Kör koden för att se hur de nästlade data representeras.
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() + ")");
}
}
}Förstå relationer: en-till-många
Exemplet med Author och Book som vi har använt är en klassisk "en-till-många"-relation: en författare kan skriva många böcker.
GraphQL-schema stöder detta naturligt genom att definiera ett fält som en lista av en annan typ (till exempel books: [Book!]!), vilket gör det enkelt att hämta alla relaterade objekt.
Referera till relaterade objekt
Ibland är data inte direkt inbäddade i eller tillgängliga från ett enda objekt. En Book kanske till exempel bara lagrar ett authorId internt, inte hela Author-objektet.
Du kan ändå modellera detta i GraphQL genom att göra Author till ett fält på Book. Spring Boot GraphQL löser då fältet Author genom att hämta hela Author-objektet baserat på authorId.
type Book {
id: ID!
title: String!
author: Author! # Reference to the Author type
}
type Author {
id: ID!
name: String!
}Testa dina kunskaper
Föreställ dig ett GraphQL-schema för en e-handelsapplikation. En Product kan ha många Review-objekt, och varje Review är skriven av en specifik User.
Sammanfattning: modellera relationer
I den här lektionen har du lärt dig att modellera nästlade objekt och relationer i ditt GraphQL-schema. Vi har gått igenom:
- Att definiera fält som är listor av andra typer (till exempel
books: [Book!]!) för att representera en-till-många-relationer. - Att återspegla dessa hierarkiska strukturer i dina Spring Boot-datamodeller.
- Att förstå hur GraphQL automatiskt löser dessa nästlade fält, ofta via Java-getters.
- Att effektivt ställa frågor mot komplexa, hierarkiska data med en enda GraphQL-förfrågan.
Att behärska nästlade objekt och relationer är avgörande för att bygga kraftfulla och intuitiva GraphQL-API:er som verkligen återspeglar applikationens datastruktur.
Lär dig GraphQL-API:er med Spring Boot med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Modellera nästlade objekt och relationer” gratis?
Ja – hela texten till ”Modellera nästlade objekt och relationer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i GraphQL-API:er med Spring Boot, kan Ni uppgradera till CoddyKit PRO. Kursen i GraphQL-API:er med Spring Boot innehåller totalt 4 lektioner.
Vad lär jag mig i ”Modellera nästlade objekt och relationer”?
Utforma scheman som representerar hierarkiska data och definiera relationer mellan olika typer. Ni övar på GraphQL-API:er med Spring Boot med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig GraphQL-API:er med Spring Boot?
Du behöver inga förkunskaper. Utbildningen i GraphQL-API:er med Spring Boot på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Modellera nästlade objekt och relationer”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här GraphQL-API:er med Spring Boot-lektionen?
Ja. Varje GraphQL-API:er med Spring Boot-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Modellera nästlade objekt och relationer
- Implementera gränssnitt och unionstyper
- Använda inputtyper för mutationer
- Enumtyper och anpassade skalärtyper