PricingLoginStart free
GraphQL APIs with Spring Boot · Lekcja

Walidacja argumentów wejściowych mutacji

Nauczą się Państwo walidować przychodzące argumenty mutacji w API GraphQL opartym na Spring Boot, używając Bean Validation, aby do warstwy danych trafiały wyłącznie poprawne dane.

Lekcja 4 z 413 kroki

Walidacja argumentów wejściowych mutacji to bezpłatna lekcja GraphQL APIs with Spring Boot na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej GraphQL APIs with Spring Boot, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs GraphQL APIs with Spring Boot zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Why Validate Mutation Input?

Mutations change your data, so the arguments they receive must be trustworthy. Without validation, clients could send empty names, negative prices, or malformed emails straight into your database.

Input validation rejects bad data early and returns a clear error before any persistence happens.

Validation in the GraphQL Lifecycle

GraphQL already validates the shape of your input against the schema (types, required fields). But it does not check business rules like 'price must be positive'.

That semantic layer is your responsibility, and Spring's Bean Validation fits perfectly here.

Bean Validation Annotations

Spring Boot ships with Jakarta Bean Validation. Common annotations:

  • @NotNull, @NotBlank for required values
  • @Size for length bounds
  • @Min, @Max, @Positive for numbers
  • @Email for email format

Annotating an Input Class

Map your GraphQL input type to a Java record or class and add constraints to its fields.

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

Triggering Validation in a Resolver

Add @Valid to the argument in your mutation method. Spring then checks every constraint before the method body runs.

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

What Happens on Failure

If a constraint fails, Spring throws a ConstraintViolationException before your service code runs. The mutation does not persist anything, protecting your data layer from invalid state.

Custom Error Messages

Each annotation accepts a message attribute so clients see helpful feedback instead of a generic failure.

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

Mapping Violations to GraphQL Errors

Use a DataFetcherExceptionResolver to turn validation exceptions into clean GraphQL errors with field-level detail, so clients know exactly which input was wrong.

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

Custom Validators

For rules the built-in annotations cannot express (like 'ISBN must be unique'), write a custom constraint implementing ConstraintValidator and annotate fields with it.

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

Validating Nested Inputs

When an input contains another object, mark the nested field with @Valid too. Validation then cascades into the child object.

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

Best Practices

Keep validation reliable:

  • Validate at the boundary, before any business logic
  • Return field-specific messages clients can act on
  • Reuse input classes across related mutations
  • Keep custom validators stateless and fast

Quick Check

Test your understanding of mutation validation.

Odpowiedz w interaktywnej lekcji

Recap

You learned to validate mutation input:

  • GraphQL checks shape; you enforce business rules
  • Annotate input classes with Bean Validation constraints
  • Use @Valid in resolvers to trigger checks
  • Map violations to clean GraphQL errors
  • Write custom validators and cascade with nested @Valid

Validated mutations keep your data layer safe and clean.

Bezpłatny start

Ucz się GraphQL APIs with Spring Boot dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
12
Lekcje
48
Zacznij naukę bezpłatnieWyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Walidacja argumentów wejściowych mutacji” jest bezpłatna?

Tak — pełny tekst „Walidacja argumentów wejściowych mutacji” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu GraphQL APIs with Spring Boot, przejdź na CoddyKit PRO. Kurs GraphQL APIs with Spring Boot zawiera 4 lekcji w sumie.

Co nauczysz się w „Walidacja argumentów wejściowych mutacji”?

Nauczą się Państwo walidować przychodzące argumenty mutacji w API GraphQL opartym na Spring Boot, używając Bean Validation, aby do warstwy danych trafiały wyłącznie poprawne dane. Ćwiczysz GraphQL APIs with Spring Boot z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć GraphQL APIs with Spring Boot?

Nie wymagamy żadnego doświadczenia. GraphQL APIs with Spring Boot w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Walidacja argumentów wejściowych mutacji”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji GraphQL APIs with Spring Boot?

Tak. Każda lekcja GraphQL APIs with Spring Boot zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Zrozumienie mutacji GraphQL
  2. Tworzenie danych za pomocą mutacji
  3. Aktualizowanie i usuwanie danych
  4. Walidacja argumentów wejściowych mutacji
← Powrót do GraphQL APIs with Spring Boot