GraphQL-API:er med Spring Boot · Lektion

Validera argument för mutationer

Lär Er validera inkommande mutationsargument i ett Spring Boot GraphQL-API med Bean Validation, så att endast rena och korrekt formaterade data når datalagret.

Lektion 4 av 413 steg

Validera argument för mutationer är en gratis lektion i GraphQL-API:er med Spring Boot på CoddyKit. Detta är lektion 4 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 ska mutationsindata valideras?

Mutationer ändrar Era data, så argumenten de tar emot måste vara tillförlitliga. Utan validering kan klienter skicka tomma namn, negativa priser eller felaktigt formaterade e-postadresser direkt till databasen.

Indatavalidering avvisar felaktiga data tidigt och returnerar ett tydligt fel innan någon beständig lagring sker.

Validering i GraphQLs livscykel

GraphQL validerar redan strukturen hos Er indata mot schemat (typer och obligatoriska fält). Men det kontrollerar inte affärsregler som ”priset måste vara positivt”.

Det semantiska lagret är Ert ansvar, och Springs Bean Validation passar perfekt här.

Annoteringar för Bean Validation

Spring Boot levereras med Jakarta Bean Validation. Vanliga annoteringar:

@NotNull, @NotBlank för obligatoriska värden
@Size för längdbegränsningar
@Min, @Max, @Positive för tal
@Email för e-postformat

Annotera en indataklass

Mappa GraphQL-indatatypen till en Java-record eller -klass och lägg till begränsningar för dess fält.

public record CreateBookInput(
    @NotBlank String title,
    @Size(min = 2, max = 60) String author,
    @Positive double price
) {}

Utlösa validering i en resolver

Lägg till @Valid i argumentet i mutationsmetoden. Spring kontrollerar sedan varje begränsning innan metodkroppen körs.

@MutationMapping
public Book createBook(@Argument @Valid CreateBookInput input) {
    return bookService.create(input);
}

Vad händer vid fel

Om en begränsning inte uppfylls kastar Spring en ConstraintViolationException innan din tjänstekod körs. Mutationen sparar ingenting, vilket skyddar datalagret från ogiltigt tillstånd.

Anpassade felmeddelanden

Varje annotering accepterar attributet message, så klienterna får användbar återkoppling i stället för ett generiskt fel.

@NotBlank(message = "Title is required")
String title;

Mappa överträdelser till GraphQL-fel

Använd en DataFetcherExceptionResolver för att omvandla valideringsfel till tydliga GraphQL-fel med information på fältnivå, så att klienterna exakt vet vilket indata som var felaktigt.

@Override
public GraphQLError resolveToSingleError(Throwable ex, DataFetchingEnvironment env) {
    return GraphqlErrorBuilder.newError(env)
        .errorType(ErrorType.BAD_REQUEST)
        .message(ex.getMessage())
        .build();
}

Anpassade validerare

För regler som de inbyggda annoteringarna inte kan uttrycka, till exempel att ISBN måste vara unikt, skriver du en anpassad begränsning som implementerar ConstraintValidator och annoterar fälten med den.

public class IsbnValidator implements ConstraintValidator<ValidIsbn, String> {
    public boolean isValid(String value, ConstraintValidatorContext ctx) {
        return value != null && value.matches("\\d{13}");
    }
}

Validera nästlade indata

När ett indata innehåller ett annat objekt markerar du även det nästlade fältet med @Valid. Valideringen fortsätter då ner i det underordnade objektet.

public record OrderInput(
    @NotNull @Valid AddressInput shippingAddress,
    @Positive int quantity
) {}

Bästa praxis

Gör valideringen tillförlitlig:

Validera vid gränsen, innan någon affärslogik körs
Returnera fältspecifika meddelanden som klienterna kan agera på
Återanvänd indataklasser i relaterade mutationer
Håll anpassade validerare tillståndslösa och snabba

Snabb kontroll

Testa din förståelse av mutationsvalidering.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig att validera mutationsindata:

GraphQL kontrollerar strukturen; du tillämpar affärsreglerna
Annotera indataklasser med Bean Validation-begränsningar
Använd @Valid i resolvers för att utlösa kontroller
Mappa överträdelser till tydliga GraphQL-fel
Skriv anpassade validerare och använd kaskadvalidering med nästlade @Valid

Validerade mutationer håller datalagret säkert och rent.

Gratis att börja

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

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Validera argument för mutationer” gratis?

Ja – hela texten till ”Validera argument 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 ”Validera argument för mutationer”?

Lär Er validera inkommande mutationsargument i ett Spring Boot GraphQL-API med Bean Validation, så att endast rena och korrekt formaterade data når datalagret. 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 4 av 4.

Hur lång tid tar lektionen ”Validera argument 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

← Tillbaka till GraphQL-API:er med Spring Boot