0Pricing
GraphQL APIs with Spring Boot · Leçon

Valider les arguments d’entrée des mutations

Apprenez à valider les arguments entrants d’une mutation dans une API GraphQL Spring Boot avec Bean Validation, afin que seules des données propres et correctement formées atteignent votre couche de données.

Valider les arguments d’entrée des mutations est une leçon GraphQL APIs with Spring Boot gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage GraphQL APIs with Spring Boot, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours GraphQL APIs with Spring Boot comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

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.

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.

Questions Fréquemment Posées

La leçon « Valider les arguments d’entrée des mutations » est-elle gratuite ?

Oui — le texte complet de « Valider les arguments d’entrée des mutations » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours GraphQL APIs with Spring Boot, passe à CoddyKit PRO. Le cours GraphQL APIs with Spring Boot comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Valider les arguments d’entrée des mutations » ?

Apprenez à valider les arguments entrants d’une mutation dans une API GraphQL Spring Boot avec Bean Validation, afin que seules des données propres et correctement formées atteignent votre couche de… Tu pratiques GraphQL APIs with Spring Boot avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer GraphQL APIs with Spring Boot ?

Aucune expérience préalable n'est requise. GraphQL APIs with Spring Boot sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Valider les arguments d’entrée des mutations » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon GraphQL APIs with Spring Boot ?

Oui. Chaque leçon GraphQL APIs with Spring Boot inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Comprendre les mutations GraphQL
  2. Créer des données avec des mutations
  3. Mettre à jour et supprimer des données
  4. Valider les arguments d’entrée des mutations
← Retour à GraphQL APIs with Spring Boot