Använda inputtyper för mutationer
Förenkla mutationsargument genom att definiera återanvändbara inputtyper för renare och mer strukturerade API-anrop.
Använda inputtyper för mutationer är en gratis lektion i GraphQL-API:er med Spring Boot på CoddyKit. Detta är lektion 3 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.
Långa mutationsargument?
När ni bygger GraphQL-mutationer behöver ni ofta skicka flera datauppgifter för att skapa eller uppdatera en entitet. Tänk exempelvis på att skapa en ny användare eller produkt.
Om varje fält skickas som ett separat argument kan mutationssignaturerna bli långa och svåra att hantera, vilket leder till kod som är mindre läsbar och underhållbar.
Lär känna GraphQL-inputtyper
Inputtyper är särskilda objekttyper i GraphQL som används specifikt som argument för mutationer, och ibland för frågor. De låter er gruppera relaterade fält i ett enda strukturerat objekt.
Det gör mutationsdefinitionerna renare och mer organiserade, ungefär som ett DTO (Data Transfer Object) i traditionella REST-API:er.
Syntax för inputtyper (SDL)
Att definiera en inputtyp i GraphQL:s Schema Definition Language (SDL) är enkelt. Ni använder nyckelordet input i stället för type.
Inputtyper kan endast innehålla skalära typer, enumtyper eller andra inputtyper som fält. De kan inte innehålla utgående objekttyper, gränssnitt eller uniontyper.
input CreateProductInput {
name: String!
description: String
price: Float!
category: String
}Problemet: många argument
Överväg en mutation för att skapa en ny produkt. Utan en inputtyp kanske ni definierar den så här:
Observera hur argumentlistan kan bli lång och repetitiv, särskilt om ni har många fält. Det kan vara omständligt att både skriva och läsa.
type Mutation {
createProduct(
name: String!,
description: String,
price: Float!,
category: String
): Product
}Lösningen: rena mutationer
Genom att använda CreateProductInput blir mutationssignaturen mycket renare och enklare att läsa. Alla relaterade inputfält kapslas nu in i ett enda argument.
Det förbättrar tydligheten och minskar röran i schemat.
type Mutation {
createProduct(input: CreateProductInput!): Product
}
input CreateProductInput {
name: String!
description: String
price: Float!
category: String
}Spring Boot-DTO för input
I er Spring Boot-applikation representerar ni GraphQL-inputtyper som enkla Java-klasser. Dessa fungerar som Data Transfer Objects (DTO:er) som Springs GraphQL-integration automatiskt kan mappa åt er.
Se till att fältnamnen i Java-klassen överensstämmer med er SDL-inputtyp, så att mappningen fungerar utan problem.
package com.coddykit.graphql;
public class CreateProductInput {
private String name;
private String description;
private float price;
private String category;
// Getters and Setters (omitted for brevity)
public String getName() { return name; }
public void setName(String name) { this.name = name; }
// ... other getters/setters
}Använda input i en resolver
Nu ska vi se hur er GraphQL-resolvermetod i Spring Boot använder denna CreateProductInput-DTO. I stället för flera @Argument-annoteringar behöver ni bara en för ert inputobjekt.
Det gör resolvermetodens signatur mycket renare och enklare att hantera, särskilt när det finns många inputfält.
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.MutationMapping;
import org.springframework.stereotype.Controller;
// Dummy Product class for example return type
class Product {
String id; String name; public Product(String id, String name) { this.id = id; this.name = name; }
public String getId() { return id; } public String getName() { return name; }
}
// Input DTO from previous scene
class CreateProductInput {
private String name; private String description; private float price; private String category;
public String getName() { return name; } public void setName(String name) { this.name = name; }
public String getDescription() { return description; } public void setDescription(String description) { this.description = description; }
public float getPrice() { return price; } public void setPrice(float price) { this.price = price; }
public String getCategory() { return category; } public void setCategory(String category) { this.category = category; }
}
@SpringBootApplication
@Controller
public class Main {
public static void main(String[] args) {
// This would start a Spring Boot web server
// SpringApplication.run(Main.class, args);
System.out.println("Application context started (conceptually).");
}
private static long productIdCounter = 1;
@MutationMapping
public Product createProduct(@Argument CreateProductInput input) {
System.out.println("Creating product: " + input.getName());
// In a real application, you'd save this to a database
String newId = "prod-" + productIdCounter++;
return new Product(newId, input.getName());
}
}Varför använda inputtyper?
Inputtyper ger flera betydande fördelar vid utformning av GraphQL-API:er:
- Läsbarhet: Mutationssignaturerna blir mycket kortare och tydligare.
- Återanvändbarhet: Samma inputtyp kan ofta användas för både skapande- och uppdateringsmutationer, vilket minskar duplicering i schemat.
- Validering: Det blir enklare att tillämpa valideringslogik på ett enda samlat inputobjekt.
- Utbyggbarhet: Om ni lägger till nya valfria fält i en inputtyp påverkas befintliga klienter inte, eftersom de helt enkelt kan ignorera de nya fälten.
Komplexa data med nästlade inputtyper
Inputtyper kan även innehålla andra inputtyper, vilket gör att ni kan modellera komplexa, hierarkiska data för era mutationer. Det är mycket användbart när strukturerade data ska skickas in.
När ni till exempel skapar en order kan ni behöva inkludera kunduppgifter och en lista med artiklar, där varje artikel har egna egenskaper, allt i ett enda inputobjekt.
input AddressInput {
street: String!
city: String!
zipCode: String
}
input CustomerInput {
name: String!
email: String!
shippingAddress: AddressInput
}
input CreateOrderInput {
customer: CustomerInput!
items: [OrderItemInput!]!
}
input OrderItemInput {
productId: ID!
quantity: Int!
}Kontroll av inputtyper
Ni har lärt er om GraphQL-inputtyper och deras fördelar. Låt oss testa era kunskaper!
Sammanfattning: ni behärskar inputtyper!
Bra jobbat! I den här lektionen har ni lärt er att behärska GraphQL-inputtyper. Ni har lärt er hur de förenklar mutationsargument och gör ert API renare och enklare att underhålla.
- Vi såg hur inputtyper definieras i SDL med hjälp av nyckelordet
input. - Vi implementerade dem i Spring Boot-resolvers genom att använda DTO:er.
- Vi utforskade även deras viktigaste fördelar, till exempel förbättrad läsbarhet, återanvändbarhet och enklare validering.
De är grundläggande för att bygga robusta och användarvänliga GraphQL-API:er! Fortsätt öva!
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 ”Använda inputtyper för mutationer” gratis?
Ja – hela texten till ”Använda inputtyper för mutationer” 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 ”Använda inputtyper för mutationer”?
Förenkla mutationsargument genom att definiera återanvändbara inputtyper för renare och mer strukturerade API-anrop. 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 3 av 4.
Hur lång tid tar lektionen ”Använda inputtyper för mutationer”?
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