Oprettelse af data med mutationer
Implementér mutationer i Spring Boot for at tilføje nye poster til dit backend-datalager.
Oprettelse af data med mutationer er en gratis GraphQL-API'er med Spring Boot-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i GraphQL-API'er med Spring Boot, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. GraphQL-API'er med Spring Boot-kurset indeholder 4 lektioner i alt.
Introduktion: Tilføjelse af nye data
GraphQL bruges ikke kun til at hente data. Det gør det også muligt at ændre data! I dag lærer du, hvordan du tilføjer helt nye poster til systemet ved hjælp af mutationer.
Det er en grundlæggende færdighed, når du bygger interaktive applikationer.
Mutationers rolle ved oprettelse
I GraphQL kaldes enhver handling, der ændrer data på serveren, en mutation. Det omfatter:
- Oprettelse af nye elementer (det er dagens fokus!)
- Opdatering af eksisterende elementer
- Sletning af elementer
Tænk på forespørgsler som noget, du bruger til at læse data, og mutationer som noget, du bruger til at skrive eller ændre data.
Design af inputtyper
Når du opretter data, skal du ofte angive flere felter (f.eks. en bogs titel, forfatter og udgivelsesår). I stedet for at angive hvert felt som et separat argument til din mutation bruger du inputtyper.
Inputtyper er særlige objekttyper, der bruges som argumenter. De gør dit skema mere overskueligt og argumenterne nemmere at håndtere, især for komplekse objekter.
Skema: createBook-mutationen
Først definerer vi BookInput og createBook-mutationen i GraphQL Schema Definition Language (SDL).
Det fortæller klienter præcis, hvilke data der kræves for at oprette en bog, og hvad mutationen returnerer.
input BookInput {
title: String!
author: String!
publicationYear: Int
}
type Mutation {
createBook(book: BookInput!): Book!
}
type Book {
id: ID!
title: String!
author: String!
publicationYear: Int
}Bogens datamodel
I vores Spring Boot-applikation repræsenterer vi en bog ved hjælp af en simpel Java-klasse (et Plain Old Java Object eller POJO). Klassen indeholder dataene for hver bog, vi opretter.
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; }
}Simulering af datalagring
I denne lektion holder vi det enkelt og gemmer vores bøger på en liste i hukommelsen. I en rigtig Spring Boot-applikation vil det typisk indebære en database (f.eks. H2 eller PostgreSQL) og et Spring Data JPA-lager.
Indtil videre bruger vi en statisk List til at simulere vores datalager.
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
}
}Implementering af resolvermetoden
Nu skriver vi den Java-metode, der fungerer som resolver for createBook-mutationen.
Metoden modtager BookInput og udfører logikken til at oprette et nyt Book-objekt.
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
}
}Resolverlogik: Tilføjelse af data
Her er den detaljerede logik i vores createBook-resolvermetode. Den håndterer generering af et id, oprettelse af objektet og lagring af det.
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;
}
}Kørbart eksempel: createBook
Her er et forenklet, kørbart eksempel, der viser, hvordan createBook-logikken fungerer i en main-metode. Kør det, og se resultatet!
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);
}
}
}Hurtigt tjek: Mutationens input
Hvorfor foretrækker man generelt at bruge en Input Type til mutationsargumenter frem for individuelle skalare argumenter?
Opsamling: Oprettelse af data
Godt gået! Du har lært, hvordan du implementerer en GraphQL-mutation, der opretter nye dataposter i en Spring Boot-kontekst.
- Vi definerede en inputtype i vores skema for at få mere overskuelige argumenter.
- Vi oprettede et mutationsfelt (
createBook) ved hjælp af dette input. - Vi implementerede en Java-resolvermetode til at håndtere oprettelseslogikken.
- Vi så, hvordan du kan føje nye data til et simuleret lager og returnere det nye element.
Nu undersøger vi, hvordan du kan opdatere og slette eksisterende data ved hjælp af mutationer!
Lær GraphQL-API'er med Spring Boot med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 12
- Lektioner
- 48
Ofte stillede spørgsmål
Er lektionen “Oprettelse af data med mutationer” gratis?
Ja — hele teksten til “Oprettelse af data med mutationer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af GraphQL-API'er med Spring Boot-kurset, skal du opgradere til CoddyKit PRO. GraphQL-API'er med Spring Boot-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Oprettelse af data med mutationer”?
Implementér mutationer i Spring Boot for at tilføje nye poster til dit backend-datalager. Du øver dig i GraphQL-API'er med Spring Boot med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på GraphQL-API'er med Spring Boot?
Der kræves ingen tidligere erfaring. GraphQL-API'er med Spring Boot på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.
Hvor lang tid tager lektionen “Oprettelse af data med mutationer”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne GraphQL-API'er med Spring Boot-lektion?
Ja. Alle GraphQL-API'er med Spring Boot-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Forståelse af GraphQL-mutationer
- Oprettelse af data med mutationer
- Opdatering og sletning af data
- Validering af inputargumenter til mutationer