0Pricing
GraphQL APIs with Spring Boot · Lekcja

Tworzenie danych za pomocą mutacji

Zaimplementuj mutacje w Spring Boot, aby dodawać nowe rekordy do magazynu danych backendu.

Tworzenie danych za pomocą mutacji to bezpłatna lekcja GraphQL APIs with Spring Boot na CoddyKit. To lekcja 2 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.

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!

Często zadawane pytania

Czy lekcja „Tworzenie danych za pomocą mutacji” jest bezpłatna?

Tak — pełny tekst „Tworzenie danych za pomocą 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 „Tworzenie danych za pomocą mutacji”?

Zaimplementuj mutacje w Spring Boot, aby dodawać nowe rekordy do magazynu danych backendu. Ć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 2 z 4.

Ile czasu zajmuje lekcja „Tworzenie danych za pomocą 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