Interfaces und Union-Typen implementieren
Nutzen Sie Interfaces und Union-Typen, um flexible und polymorphe Schemadesigns zu erstellen.
Interfaces und Union-Typen implementieren ist eine kostenlose GraphQL APIs with Spring Boot-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des GraphQL APIs with Spring Boot-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der GraphQL APIs with Spring Boot-Kurs umfasst insgesamt 4 Lektionen.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
Flexible Schemas with Polymorphism
GraphQL allows you to design highly flexible APIs. Sometimes, you need a field that can return different types of objects, or you want to define a shared set of fields that multiple types must implement. This is where polymorphism comes in.
We'll explore two key concepts for achieving this: Interfaces and Union Types.
Understanding GraphQL Interfaces
Imagine you have different types of media, like a Book and a Movie. Both might have a title and a releaseYear. Instead of duplicating these fields, you can define an Interface.
An interface is a contract that specifies a set of fields that any type implementing it must include. It's like a blueprint for common functionality.
Defining an Interface in SDL
In GraphQL's Schema Definition Language (SDL), an interface is defined using the interface keyword. Here, we define a Media interface that both Book and Movie will share.
interface Media {
id: ID!
title: String!
releaseYear: Int
}Types Implementing an Interface
Now, let's make our Book and Movie types implement the Media interface. They must include all fields defined by Media, and can add their own unique fields. Notice the implements keyword.
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 for Interfaces
When you query a field that returns an interface type, Spring GraphQL automatically resolves the concrete type based on the data. You usually create Java data classes that implement a common Java interface, and Spring GraphQL handles the rest. Try running this example:
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;
}
}Exploring GraphQL Union Types
While interfaces ensure types share common fields, Union Types allow a field to return one of several distinct types, without requiring them to share any common fields. Think of it as an 'either-or' situation. For example, a search result might be a Product OR a User.
Schema Definition for Unions
In SDL, union types are defined using the union keyword, followed by the types it can represent, separated by a vertical bar |. Here's a SearchResult union that can be either a Book or a Movie.
union SearchResult = Book | MovieResolvers for Union Types
When a field returns a union type, Spring GraphQL needs to know which concrete type it is. For Java, you simply return an instance of one of the types defined in the union. Spring GraphQL automatically adds the __typename field for clients to distinguish. Try running this example:
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;
}
}Choosing Between Interfaces and Unions
Both interfaces and unions offer polymorphism, but they serve different purposes:
- Interfaces: Use when multiple types share a common set of fields and behavior. They enforce a contract.
- Union Types: Use when a field can return one of several distinct types that do not necessarily share any common fields. It's about 'either A or B or C'.
Interfaces vs. Unions Quiz
You are designing a GraphQL API. You need a field that can return either a Photo object or a Video object. These two types have completely different fields and do not share any common properties. Which GraphQL schema feature is best suited for this scenario?
Recap: Flexible Schemas
You've learned how GraphQL Interfaces and Union Types enable flexible and polymorphic schema designs. Interfaces define a contract for common fields, while Union Types allow a field to return one of several distinct types. These tools are crucial for building robust and adaptable GraphQL APIs.
Next, you'll explore Input Types to streamline mutation arguments.
Häufig gestellte Fragen
Ist die Lektion „Interfaces und Union-Typen implementieren“ kostenlos?
Ja — der vollständige Text von „Interfaces und Union-Typen implementieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des GraphQL APIs with Spring Boot-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der GraphQL APIs with Spring Boot-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Interfaces und Union-Typen implementieren“?
Nutzen Sie Interfaces und Union-Typen, um flexible und polymorphe Schemadesigns zu erstellen. Du übst GraphQL APIs with Spring Boot mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um GraphQL APIs with Spring Boot zu starten?
Keine Vorkenntnisse erforderlich. GraphQL APIs with Spring Boot auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Interfaces und Union-Typen implementieren“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser GraphQL APIs with Spring Boot-Lektion Code schreiben und ausführen?
Ja. Jede GraphQL APIs with Spring Boot-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Verschachtelte Objekte und Beziehungen modellieren
- Interfaces und Union-Typen implementieren
- Input-Typen für Mutationen nutzen
- Enums und benutzerdefinierte skalare Typen