GraphQL APIs with Spring Boot · 课时

使用变更创建数据

在 Spring Boot 中实现变更，将新记录添加到后端数据存储中。

使用变更创建数据 是 CoddyKit 上的免费 GraphQL APIs with Spring Boot 课时。这是第 2 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 GraphQL APIs with Spring Boot 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 GraphQL APIs with Spring Boot 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

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!

常见问题解答

「使用变更创建数据」课时是免费的吗？

是的 — 「使用变更创建数据」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 GraphQL APIs with Spring Boot 课程的其余内容，请升级到 CoddyKit PRO。 GraphQL APIs with Spring Boot 课程共包含 4 节课。

「使用变更创建数据」这节课中我会学到什么？

在 Spring Boot 中实现变更，将新记录添加到后端数据存储中。你通过在浏览器中直接运行的动手代码来练习 GraphQL APIs with Spring Boot，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 GraphQL APIs with Spring Boot 需要有经验吗？

无需任何先前经验。CoddyKit 上的 GraphQL APIs with Spring Boot 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 4 节。

「使用变更创建数据」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 GraphQL APIs with Spring Boot 课中编写并运行代码吗？

能。每节 GraphQL APIs with Spring Boot 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 GraphQL APIs with Spring Boot