Implementera gränssnitt och unionstyper
Använd gränssnitt och unionstyper för att skapa flexibla och polymorfa schemadesigner.
Implementera gränssnitt och unionstyper är en gratis lektion i GraphQL-API:er med Spring Boot på CoddyKit. Detta är lektion 2 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.
Flexibla scheman med polymorfism
GraphQL låter dig utforma mycket flexibla API:er. Ibland behöver du ett fält som kan returnera olika typer av objekt, eller så vill du definiera en gemensam uppsättning fält som flera typer måste implementera. Det är här polymorfism kommer in.
Vi utforskar två viktiga koncept för att åstadkomma detta: Interfaces och Union Types.
Förstå GraphQL-gränssnitt
Föreställ er att ni har olika medietyper, till exempel en Book och en Movie. Båda kan ha en title och ett releaseYear. I stället för att duplicera dessa fält kan ni definiera ett gränssnitt.
Ett gränssnitt är ett kontrakt som anger en uppsättning fält som alla typer som implementerar det måste innehålla. Det fungerar som en ritning för gemensam funktionalitet.
Definiera ett gränssnitt i SDL
I GraphQL:s Schema Definition Language (SDL) definieras ett gränssnitt med nyckelordet interface. Här definierar vi gränssnittet Media, som både Book och Movie ska dela.
interface Media {
id: ID!
title: String!
releaseYear: Int
}Typer som implementerar ett gränssnitt
Nu låter vi våra typer Book och Movie implementera gränssnittet Media. De måste innehålla alla fält som definieras av Media och kan dessutom lägga till egna unika fält. Observera nyckelordet implements.
type Book implements Media {
id: ID!
title: String!
releaseYear: Int
author: String
pages: Int
}
type Movie implements Media {
id: ID!
title: String!
releaseYear: Int
director: String
durationMinutes: Int
}Resolvers för gränssnitt
När ni frågar efter ett fält som returnerar en gränssnittstyp identifierar Spring GraphQL automatiskt den konkreta typen utifrån data. Vanligtvis skapar ni Java-dataklasser som implementerar ett gemensamt Java-gränssnitt, och Spring GraphQL hanterar resten. Prova att köra det här exemplet:
package com.coddykit.graphql;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.stereotype.Controller;
import java.util.List;
import java.util.ArrayList;
@SpringBootApplication
public class GraphqlApp {
public static void main(String[] args) {
SpringApplication.run(GraphqlApp.class, args);
}
}
interface Media {
String getId();
String getTitle();
Integer getReleaseYear();
}
record Book(String id, String title, Integer releaseYear, String author, Integer pages) implements Media {}
record Movie(String id, String title, Integer releaseYear, String director, Integer durationMinutes) implements Media {}
@Controller
class MediaController {
@QueryMapping
public List<Media> allMedia() {
List<Media> mediaList = new ArrayList<>();
mediaList.add(new Book("b1", "The Hitchhiker's Guide", 1979, "Douglas Adams", 193));
mediaList.add(new Movie("m1", "Inception", 2010, "Christopher Nolan", 148));
return mediaList;
}
}Utforska GraphQL-uniontyper
Medan gränssnitt säkerställer att typer delar gemensamma fält, låter uniontyper ett fält returnera en av flera distinkta typer utan krav på att de ska dela några gemensamma fält. Se det som en situation där det är "antingen eller". Ett sökresultat kan till exempel vara en Product ELLER en User.
Schemadefinition för uniontyper
I SDL definieras uniontyper med nyckelordet union, följt av de typer som den kan representera, separerade med ett lodrätt streck |. Här är en SearchResult-union som antingen kan vara en Book eller en Movie.
union SearchResult = Book | MovieResolvers för uniontyper
När ett fält returnerar en uniontyp måste Spring GraphQL veta vilken konkret typ det är. I Java returnerar ni helt enkelt en instans av någon av typerna som definieras i unionen. Spring GraphQL lägger automatiskt till fältet __typename, så att klienter kan skilja typerna åt. Prova att köra det här exemplet:
package com.coddykit.graphql;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.graphql.data.method.annotation.Argument;
import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.stereotype.Controller;
@SpringBootApplication
public class GraphqlApp {
public static void main(String[] args) {
SpringApplication.run(GraphqlApp.class, args);
}
}
record Book(String id, String title, Integer releaseYear, String author, Integer pages) {}
record Movie(String id, String title, Integer releaseYear, String director, Integer durationMinutes) {}
@Controller
class SearchController {
@QueryMapping
public Object search(@Argument String query) {
if (query.equalsIgnoreCase("inception")) {
return new Movie("m1", "Inception", 2010, "Christopher Nolan", 148);
} else if (query.equalsIgnoreCase("hitchhiker")) {
return new Book("b1", "The Hitchhiker's Guide", 1979, "Douglas Adams", 193);
}
return null;
}
}Välja mellan gränssnitt och uniontyper
Både gränssnitt och uniontyper erbjuder polymorfism, men de är avsedda för olika ändamål:
- Gränssnitt: Används när flera typer delar en gemensam uppsättning fält och beteenden. De framtvingar ett kontrakt.
- Uniontyper: Används när ett fält kan returnera en av flera distinkta typer som inte nödvändigtvis delar några gemensamma fält. Det handlar om "antingen A, B eller C".
Frågesport: gränssnitt kontra uniontyper
Ni utformar ett GraphQL-API. Ni behöver ett fält som kan returnera antingen ett Photo-objekt eller ett Video-objekt. Dessa två typer har helt olika fält och delar inga gemensamma egenskaper. Vilken GraphQL-schemafunktion passar bäst för detta scenario?
Sammanfattning: flexibla scheman
Ni har lärt er hur GraphQL:s gränssnitt och uniontyper möjliggör flexibla och polymorfa schemadesigner. Gränssnitt definierar ett kontrakt för gemensamma fält, medan uniontyper låter ett fält returnera en av flera distinkta typer. Dessa verktyg är avgörande för att bygga robusta och anpassningsbara GraphQL-API:er.
Härnäst ska ni utforska inputtyper för att förenkla mutationsargument.
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 ”Implementera gränssnitt och unionstyper” gratis?
Ja – hela texten till ”Implementera gränssnitt och unionstyper” 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 ”Implementera gränssnitt och unionstyper”?
Använd gränssnitt och unionstyper för att skapa flexibla och polymorfa schemadesigner. 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 2 av 4.
Hur lång tid tar lektionen ”Implementera gränssnitt och unionstyper”?
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