Brug af input-typer til mutationer
Strømlin mutationsargumenter ved at definere genanvendelige input-typer, så dine API-kald bliver renere og mere strukturerede.
Brug af input-typer til mutationer er en gratis GraphQL-API'er med Spring Boot-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i GraphQL-API'er med Spring Boot, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. GraphQL-API'er med Spring Boot-kurset indeholder 4 lektioner i alt.
Lange mutationsargumenter?
Når du bygger GraphQL-mutationer, skal du ofte sende flere stykker data for at oprette eller opdatere en entitet. Tænk for eksempel på at oprette en ny bruger eller et produkt.
Hvis hvert felt sendes som et separat argument, kan mutationssignaturerne blive meget lange og svære at administrere, hvilket giver mindre læsbar og vedligeholdelsesvenlig kode.
Mød GraphQL-inputtyper
Inputtyper er særlige objekttyper i GraphQL, der specifikt bruges som argumenter til mutationer eller nogle gange forespørgsler. De gør det muligt at samle relaterede felter i ét struktureret objekt.
Det gør dine mutationsdefinitioner renere og mere organiserede, på samme måde som en DTO (Data Transfer Object) fungerer i traditionelle REST-API'er.
Syntaks for inputtyper (SDL)
Det er enkelt at definere en inputtype i dit GraphQL Schema Definition Language (SDL). Du bruger nøgleordet input i stedet for type.
Inputtyper kan kun indeholde skalartyper, enumerationer eller andre inputtyper som felter. De kan ikke indeholde outputobjekttyper, grænseflader eller unionstyper.
input CreateProductInput {
name: String!
description: String
price: Float!
category: String
}Problemet: Mange argumenter
Overvej en mutation, der opretter et nyt produkt. Uden en inputtype kunne du definere den sådan:
Bemærk, hvordan argumentlisten kan blive lang og gentagende, især hvis du har mange felter. Det kan være besværligt at skrive og læse.
type Mutation {
createProduct(
name: String!,
description: String,
price: Float!,
category: String
): Product
}Løsningen: Rene mutationer
Ved at bruge vores CreateProductInput bliver mutationssignaturen meget renere og nemmere at læse. Alle relaterede inputfelter er nu indkapslet i ét argument.
Det forbedrer tydeligheden og reducerer rod i dit skema.
type Mutation {
createProduct(input: CreateProductInput!): Product
}
input CreateProductInput {
name: String!
description: String
price: Float!
category: String
}Spring Boot-DTO til input
I din Spring Boot-applikation repræsenterer du dine GraphQL-inputtyper som simple Java-klasser. De fungerer som Data Transfer Objects (DTO'er), som Spring's GraphQL-integration automatisk kan knytte til de tilsvarende typer.
Sørg for, at feltnavnene i din Java-klasse matcher din SDL-inputtype, så tilknytningen fungerer problemfrit.
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
}Brug af input i en resolver
Lad os nu se, hvordan din GraphQL-resolvemetode i Spring Boot bruger denne CreateProductInput-DTO. I stedet for flere @Argument-annoteringer har du kun én til dit inputobjekt.
Det gør resolvemetodens signatur meget renere og nemmere at administrere, især når der er mange inputfelter.
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());
}
}Hvorfor bruge inputtyper?
Inputtyper giver flere væsentlige fordele i din GraphQL-API's design:
- Læselighed: Mutationssignaturerne bliver meget kortere og tydeligere.
- Genbrug: Den samme inputtype kan ofte bruges til både oprettelses- og opdateringsmutationer, hvilket reducerer duplikering i skemaet.
- Validering: Det er nemmere at anvende valideringslogik på ét samlet inputobjekt.
- Udvidelsesmuligheder: Tilføjelse af nye valgfrie felter til en inputtype ødelægger ikke eksisterende klienter, da de blot kan ignorere de nye felter.
Komplekse data med indlejrede inputtyper
Inputtyper kan også indeholde andre inputtyper, så du kan modellere komplekse, hierarkiske data til dine mutationer. Det er meget nyttigt til indsendelse af strukturerede data.
Når du for eksempel opretter en ordre, skal du måske inkludere kundeoplysninger og en liste over varer, hvor hver vare har sine egne egenskaber, alt sammen i ét 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!
}Tjek af inputtyper
Du har lært om GraphQL-inputtyper og deres fordele. Lad os teste din forståelse!
Opsummering: Du har styr på inputtyper!
Godt gået! I denne lektion har du fået styr på GraphQL-inputtyper. Du har lært, hvordan de forenkler mutationsargumenter og gør din API renere og nemmere at vedligeholde.
- Vi så, hvordan man definerer inputtyper i SDL ved hjælp af nøgleordet
input. - Vi implementerede dem i Spring Boot-resolvers ved hjælp af DTO'er.
- Og vi undersøgte deres vigtigste fordele, f.eks. forbedret læselighed, genbrug og nemmere validering.
De er afgørende for at bygge robuste og brugervenlige GraphQL-API'er! Bliv ved med at øve dig!
Lær GraphQL-API'er med Spring Boot med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 12
- Lektioner
- 48
Ofte stillede spørgsmål
Er lektionen “Brug af input-typer til mutationer” gratis?
Ja — hele teksten til “Brug af input-typer til mutationer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af GraphQL-API'er med Spring Boot-kurset, skal du opgradere til CoddyKit PRO. GraphQL-API'er med Spring Boot-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Brug af input-typer til mutationer”?
Strømlin mutationsargumenter ved at definere genanvendelige input-typer, så dine API-kald bliver renere og mere strukturerede. Du øver dig i GraphQL-API'er med Spring Boot med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på GraphQL-API'er med Spring Boot?
Der kræves ingen tidligere erfaring. GraphQL-API'er med Spring Boot på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Brug af input-typer til mutationer”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne GraphQL-API'er med Spring Boot-lektion?
Ja. Alle GraphQL-API'er med Spring Boot-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Modellering af indlejrede objekter og relationer
- Implementering af interfaces og union-typer
- Brug af input-typer til mutationer
- Enums og brugerdefinerede scalar-typer