0Pricing
GraphQL APIs with Spring Boot · Leçon

Créer des données avec des mutations

Implémentez des mutations dans Spring Boot pour ajouter de nouveaux enregistrements à votre espace de stockage de données principal.

Créer des données avec des mutations est une leçon GraphQL APIs with Spring Boot gratuite sur CoddyKit. Ceci est la leçon 2 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.

Intro: Adding New Data

GraphQL isn't just for fetching data. It also allows us to change it! Today, we'll learn how to add brand new records to our system using mutations.

This is a core skill for building any interactive application.

Mutation's Role in Creation

In GraphQL, any operation that modifies data on the server is called a Mutation. This includes:

  • Creating new items (our focus today!)
  • Updating existing items
  • Deleting items

Think of queries for reading data and mutations for writing/changing data.

Designing Input Types

When creating data, you often need to provide several fields (e.g., a book's title, author, year). Instead of listing each field as a separate argument for your mutation, we use Input Types.

Input types are special object types used as arguments. They make your schema cleaner and arguments easier to manage, especially for complex objects.

Schema: The createBook Mutation

First, let's define our BookInput and the createBook mutation in our GraphQL Schema Definition Language (SDL).

This tells clients exactly what data is needed to create a book and what the mutation will return.

input BookInput {
  title: String!
  author: String!
  publicationYear: Int
}

type Mutation {
  createBook(book: BookInput!): Book!
}

type Book {
  id: ID!
  title: String!
  author: String!
  publicationYear: Int
}

The Book Data Model

In our Spring Boot application, we'll represent a book using a simple Java class (a Plain Old Java Object, or POJO). This class will hold the data for each book we create.

class Book {
  String id;
  String title;
  String author;
  Integer publicationYear;

  public Book(String id, String title, String author, Integer year) {
    this.id = id;
    this.title = title;
    this.author = author;
    this.publicationYear = year;
  }

  // Getters for all fields (omitted for brevity in snippets)
  public String getId() { return id; }
  public String getTitle() { return title; }
  public String getAuthor() { return author; }
  public Integer getPublicationYear() { return publicationYear; }
}

Simulating Data Storage

For this lesson, we'll keep things simple and store our books in an in-memory list. In a real Spring Boot application, this would typically involve a database (like H2, PostgreSQL, etc.) and a Spring Data JPA repository.

We'll use a static List to simulate our data store for now.

import java.util.ArrayList;
import java.util.List;

public class BookDataStore {
  private static final List<Book> books = new ArrayList<>();

  public static void addBook(Book book) {
    books.add(book);
  }

  public static List<Book> getAllBooks() {
    return new ArrayList<>(books); // Return a copy
  }
}

Implementing the Resolver Method

Now, let's write the Java method that acts as our resolver for the createBook mutation.

This method will receive the BookInput and perform the logic to create a new Book object.

import java.util.UUID; // For generating unique IDs

// Simplified BookInput class for demonstration
class BookInput {
  String title;
  String author;
  Integer publicationYear;

  // Getters (omitted for brevity)
  public String getTitle() { return title; }
  public String getAuthor() { return author; }
  public Integer getPublicationYear() { return publicationYear; }
}

public class BookService {
  public Book createBook(BookInput bookInput) {
    // ... logic to create and save book ...
    return null; // Placeholder
  }
}

Resolver Logic: Adding Data

Here's the detailed logic inside our createBook resolver method. It handles generating an ID, creating the object, and saving it.

import java.util.UUID;

// (Book, BookInput, BookDataStore classes would be available)

public class BookService {
  public Book createBook(BookInput bookInput) {
    // 1. Generate a unique ID for the new book
    String newId = UUID.randomUUID().toString();

    // 2. Create a new Book instance from the input
    Book newBook = new Book(
        newId,
        bookInput.getTitle(),
        bookInput.getAuthor(),
        bookInput.getPublicationYear()
    );

    // 3. Add the new Book to our data store
    BookDataStore.addBook(newBook);

    // 4. Return the newly created Book
    return newBook;
  }
}

Runnable Example: createBook

Here's a simplified runnable example demonstrating how the createBook logic works within a main method. Run it and check the output!

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

// Simplified Book class for runnable snippet
class Book {
  String id;
  String title;
  String author;
  Integer publicationYear;

  public Book(String id, String title, String author, Integer year) {
    this.id = id;
    this.title = title;
    this.author = author;
    this.publicationYear = year;
  }
  public String toString() {
    return "Book{id='" + id.substring(0,4) + "...', title='" + title + "'}";
  }
}

// Simplified BookInput class
class BookInput {
  String title;
  String author;
  Integer publicationYear;

  public BookInput(String title, String author, Integer year) {
    this.title = title;
    this.author = author;
    this.publicationYear = year;
  }
  public String getTitle() { return title; }
  public String getAuthor() { return author; }
  public Integer getPublicationYear() { return publicationYear; }
}

// Simplified DataStore
class SimpleBookDataStore {
  private static final List<Book> books = new ArrayList<>();
  public static void addBook(Book book) { books.add(book); }
  public static List<Book> getAllBooks() { return new ArrayList<>(books); }
}

public class Main {
  public Book createBook(BookInput bookInput) {
    String newId = UUID.randomUUID().toString();
    Book newBook = new Book(
        newId,
        bookInput.getTitle(),
        bookInput.getAuthor(),
        bookInput.getPublicationYear()
    );
    SimpleBookDataStore.addBook(newBook);
    return newBook;
  }

  public static void main(String[] args) {
    Main app = new Main();

    BookInput input1 = new BookInput(
        "The Great Journey", "A. Traveler", 2023
    );
    Book createdBook1 = app.createBook(input1);
    System.out.println("Created: " + createdBook1);

    BookInput input2 = new BookInput(
        "Coding Adventures", "B. Coder", 2024
    );
    Book createdBook2 = app.createBook(input2);
    System.out.println("Created: " + createdBook2);

    System.out.println("\nAll books in store:");
    for (Book b : SimpleBookDataStore.getAllBooks()) {
      System.out.println("- " + b);
    }
  }
}

Quick Check: Mutation Input

Why is using an Input Type generally preferred for mutation arguments compared to individual scalar arguments?

Recap: Creating Data

Great job! You've learned how to implement a GraphQL mutation to create new data records in a Spring Boot context.

  • We defined an Input Type in our schema for cleaner arguments.
  • We created a mutation field (createBook) using this input.
  • We implemented a Java resolver method to handle the creation logic.
  • We saw how to add new data to a simulated store and return the new item.

Next, we'll explore how to update and delete existing data using mutations!

Questions Fréquemment Posées

La leçon « Créer des données avec des mutations » est-elle gratuite ?

Oui — le texte complet de « Créer des données avec 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 « Créer des données avec des mutations » ?

Implémentez des mutations dans Spring Boot pour ajouter de nouveaux enregistrements à votre espace de stockage de données principal. 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 2 sur 4.

Combien de temps prend la leçon « Créer des données avec 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