Spring Boot 4 – komplett guide · Lektion

Data fetchers och argumentbindning

Implementera @QueryMapping- och @MutationMapping-handlers med bindning av argument och indata.

Lektion 2 av 413 steg

Data fetchers och argumentbindning är en gratis lektion i Spring Boot 4 – komplett guide på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Spring Boot 4 – komplett guide, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Spring Boot 4 – komplett guide innehåller totalt 4 lektioner.

Vad en data fetcher är

I Spring for GraphQL löses varje fält i Ert schema av en data fetcher (GraphQL-Java-termen för en resolver). När en klient efterfrågar ett fält anropar motorn den fetcher som är bunden till det.

I stället för att registrera råa DataFetcher-beans låter Spring Er skriva annoterade controllermetoder. Ramverket mappar varje metod till ett schemafält och hanterar argumentbindning, returvärden och asynkron inramning åt Er.

@QueryMapping löser ett fält under rottypen Query.
@MutationMapping löser ett fält under rottypen Mutation.
@SchemaMapping löser vilket fält som helst (inklusive fält i kapslade objekt).

Schemat styr allt

Spring for GraphQL är schema-first. Ni deklarerar Era typer och operationer i en SDL-fil under src/main/resources/graphql/ (till exempel schema.graphqls), och Era controllermetoder binds till dessa fältnamn.

Betrakta detta schema. Fälten book och books finns under Query, så vart och ett behöver en handler med @QueryMapping.

type Query {
    books: [Book!]!
    book(id: ID!): Book
}

type Mutation {
    addBook(input: AddBookInput!): Book!
}

type Book {
    id: ID!
    title: String!
    pages: Int!
}

input AddBookInput {
    title: String!
    pages: Int!
}

Er första @QueryMapping

En klass med @Controller innehåller Era handlers. Som standard härleder Spring schemafältets namn från metodnamnet, så books() binds till frågan books.

Returvärdet matchas mot schemats returtyp. Här uppfyller List<Book> [Book!]!.

@Controller
public class BookController {

    private final BookService bookService;

    public BookController(BookService bookService) {
        this.bookService = bookService;
    }

    @QueryMapping
    public List<Book> books() {
        return bookService.findAll();
    }
}

Binda ett enskilt argument med @Argument

När ett frågefält tar emot argument binder Ni vart och ett med @Argument. Spring matchar GraphQL-argumentets namn mot parameternamnet och konverterar värdet till Java-typen.

För book(id: ID!) kommer skalären ID som String som standard. Spring kan också konvertera den till Long om parametern har den typen.

@QueryMapping
public Book book(@Argument Long id) {
    return bookService.findById(id)
            .orElseThrow(() -> new BookNotFoundException(id));
}

När argument- och parameternamn skiljer sig åt

Matchning av parameternamn beror på att felsökningssymboler finns i den kompilerade klassen. Om de har tagits bort, eller om Ni helt enkelt vill använda ett annat Java-namn, anger Ni argumentnamnet explicit.

@Argument("id") binder schemaargumentet id till den parameter Ni deklarerar.
Kompilering med flaggan -parameters (Spring Boot starter parent aktiverar den) behåller namnen, så den explicita formen är ofta valfri.

@QueryMapping
public Book book(@Argument("id") Long bookId) {
    return bookService.findById(bookId)
            .orElseThrow(() -> new BookNotFoundException(bookId));
}

Binda input-objekt till en POJO

För mutationer som tar emot ett input-objekt binder Ni inte varje fält separat. I stället binder @Argument hela GraphQL-inputtypen till en Java-klass. Spring fyller i objektet fält för fält med hjälp av matchande egenskapsnamn.

Målklassen behöver bara ha fält (eller en konstruktor) som matchar inputens nycklar. Ett record fungerar utmärkt.

public record AddBookInput(String title, int pages) {}

@MutationMapping
public Book addBook(@Argument AddBookInput input) {
    Book created = bookService.create(input.title(), input.pages());
    return created;
}

@MutationMapping i praktiken

@MutationMapping fungerar precis som @QueryMapping, men löser fält under rottypen Mutation. Använd det för operationer som ändrar tillstånd: skapa, uppdatera, ta bort.

Ni kan fritt blanda enkla skalära argument och input-objekt. Nedan tar en uppdatering emot både ett ID och en input-payload.

@MutationMapping
public Book updateBook(@Argument Long id, @Argument UpdateBookInput input) {
    Book existing = bookService.findById(id)
            .orElseThrow(() -> new BookNotFoundException(id));
    existing.setTitle(input.title());
    existing.setPages(input.pages());
    return bookService.save(existing);
}

Binda hela argumentmappen med @Arguments

Ibland vill Ni binda hela uppsättningen argument till ett enda objekt i stället för att anropa @Argument upprepade gånger. Annoteringen @Arguments (i plural) binder alla fältargument till en målklass på en gång.

Detta är praktiskt när en fråga har många filterparametrar som enkelt kan mappas till ett kriterieobjekt.

public record BookFilter(String titleContains, Integer minPages, Integer maxPages) {}

@QueryMapping
public List<Book> searchBooks(@Arguments BookFilter filter) {
    return bookService.search(filter);
}

Validera bundna argument

Spring for GraphQL integrerar med Bean Validation. Annotera controllermetodens argument eller input-recordets komponenter med begränsningar och lägg till @Valid, så kontrolleras överträdelser innan metodens innehåll körs.

En överträdd begränsning resulterar i ett GraphQL-fel i stället för att affärslogiken körs, vilket håller felaktiga data borta från tjänstelagret.

public record AddBookInput(
        @NotBlank String title,
        @Positive int pages) {}

@MutationMapping
public Book addBook(@Argument @Valid AddBookInput input) {
    return bookService.create(input.title(), input.pages());
}

Åtkomst till den råa argumentmappen

För dynamiska fall kan Ni hoppa över typad bindning och injicera DataFetchingEnvironment (eller en @Argument Map<String, Object>). Miljön exponerar de råa argumenten, urvalsmängden och kontexten.

Använd detta sparsamt — typad bindning med @Argument är tydligare och säkrare. Använd miljön endast när Ni verkligen behöver detaljer på motornivå.

@QueryMapping
public Book book(DataFetchingEnvironment env) {
    Long id = Long.valueOf(env.getArgument("id").toString());
    return bookService.findById(id)
            .orElseThrow(() -> new BookNotFoundException(id));
}

En fristående demonstration av argumentkonvertering

Argumentbindning handlar i grunden om att konvertera inkommande värden till Java-typer. Kodsnutten nedan efterliknar detta utan något ramverk: den tolkar ett strängargument av typen ID till en long och slår upp det — exakt vad @Argument Long id gör internt.

Detta körs i en vanlig online judge för att göra konceptet konkret.

import java.util.Map;

public class Main {
    record Book(long id, String title) {}

    public static void main(String[] args) {
        Map<Long, Book> store = Map.of(
            1L, new Book(1, "Spring in Action"),
            2L, new Book(2, "Effective Java")
        );

        String rawIdArgument = "2"; // as it would arrive from GraphQL
        long id = Long.parseLong(rawIdArgument);

        Book found = store.get(id);
        System.out.println(found != null ? found.title() : "not found");
    }
}

Snabbkontroll

Ni har en mutation addBook(input: AddBookInput!): Book! där AddBookInput har fälten title och pages. Ni vill binda hela input-objektet till ett enda Java-record i en handler. Vilken är den korrekta signaturen?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni kan nu koppla GraphQL-fält till Java-hanterare i Spring for GraphQL:

@QueryMapping och @MutationMapping kopplar controller-metoder till rotfälten Query/Mutation och härleder fältnamnet från metodnamnet.
@Argument kopplar ett enskilt GraphQL-argument eller ett helt input-objekt till en Java-typ. Använd formen med explicit namn när parameternamn inte är tillgängliga.
@Arguments kopplar hela uppsättningen fältargument till ett och samma målobjekt.
@Valid tillsammans med Bean Validation-begränsningar avvisar felaktig indata innan tjänsten körs.
DataFetchingEnvironment ger tillgång till råargument för dynamiska fall, men typad bindning bör vara standard.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 21
Lektioner: 84

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Data fetchers och argumentbindning” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Spring Boot 4 – komplett guide, inklusive ”Data fetchers och argumentbindning”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Spring Boot 4 – komplett guide innehåller totalt 4 lektioner.

Vad lär jag mig i ”Data fetchers och argumentbindning”?

Implementera @QueryMapping- och @MutationMapping-handlers med bindning av argument och indata. Ni övar på Spring Boot 4 – komplett guide med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Spring Boot 4 – komplett guide?

Du behöver inga förkunskaper. Utbildningen i Spring Boot 4 – komplett guide på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Data fetchers och argumentbindning”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Spring Boot 4 – komplett guide-lektionen?

Ja. Varje Spring Boot 4 – komplett guide-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Spring Boot 4 – komplett guide