GraphQL-API:er med Spring Boot · Lektion

Implementera dataresolvers

Skriv resolverfunktioner i Spring Boot för att hämta data till era definierade GraphQL-fält från olika källor.

Lektion 2 av 411 steg

Implementera dataresolvers är en gratis lektion i GraphQL-API:er med Spring Boot på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för GraphQL-API:er med Spring Boot, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i GraphQL-API:er med Spring Boot innehåller totalt 4 lektioner.

Vad är dataresolvers?

Välkomna! I GraphQL ber klienter om specifika data. Men hur vet servern var den ska hämta dessa data?

Det är här dataresolvers kommer in! En resolver är en funktion eller metod som vet hur data ska hämtas för ett specifikt fält i ert GraphQL-schema.

De fungerar som en länk mellan schemat och era datakällor, till exempel databaser, API:er eller enkla listor i minnet.
Varje fält i schemat behöver en resolver, implicit eller explicit.

Resolvers i Spring for GraphQL

Spring for GraphQL gör det enkelt att implementera resolvers. Det använder annoteringar för att direkt koppla Java-metoder till fält i GraphQL-schemat.

Vanligtvis skriver ni dessa resolvermetoder i Spring-klasser som är märkta med @Controller. Spring genomsöker automatiskt dessa controllers och kopplar deras metoder till GraphQL-schemats fält utifrån namnkonventioner eller explicita annoteringar.

Er första resolver för en rotfråga

Nu skapar vi en enkel resolver för en rotfråga. Vi definierar ett grundläggande fält, hello, som returnerar en hälsningssträng.

Föreställ er först att schemat innehåller:

type Query {
  hello: String
}

Nu skriver vi Java-resolvern:

import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.stereotype.Controller;

@Controller
public class GreetingController {

  @QueryMapping
  public String hello() {
    return "Hello from CoddyKit!";
  }
}

Resolvera anpassade objekt

Resolvers är inte bara till för enkla strängar. De kan även returnera anpassade Java-objekt! Låt oss definiera en enkel Book-klass och en resolver som returnerar den.

Anta att vårt schema innehåller:

type Book {
  id: ID
  title: String
  author: String
}

type Query {
  firstBook: Book
}

Här är Book-klassen och en resolver:

import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.stereotype.Controller;

// A simple data class for our Book
record Book(String id, String title, String author) {}

@Controller
public class BookController {

  @QueryMapping
  public Book firstBook() {
    return new Book("book-1", "The Great Journey", "Alice Wonderland");
  }
}

Simulering av datakällor

I våra exempel ansluter vi inte till någon riktig databas. I stället använder vi en lista i minnet för att simulera en datakälla. Det håller koden enkel och fokuserad på resolvers.

I en riktig applikation skulle era resolvers interagera med:

Databaser (SQL, NoSQL)
Andra REST- eller GraphQL-API:er
Meddelandeköer
Filsystem

Resolverns uppgift är helt enkelt att hämta data, oavsett källa!

Implementera en listresolver

Ofta vill ni returnera en lista med objekt. Vår BookController kan uppdateras så att den tillhandahåller en lista med böcker från en simulerad datakälla.

Om vårt schema innehåller:

type Query {
  allBooks: [Book]
}

Så här skulle vi implementera resolvern:

import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.stereotype.Controller;
import java.util.List;
import java.util.ArrayList;

record Book(String id, String title, String author) {}

@Controller
public class BookListController {

  private final List<Book> books = new ArrayList<>(List.of(
    new Book("b-1", "The Moonstone", "Wilkie Collins"),
    new Book("b-2", "Pride and Prejudice", "Jane Austen"),
    new Book("b-3", "1984", "George Orwell")
  ));

  @QueryMapping
  public List<Book> allBooks() {
    return books;
  }
}

Hämta via ID med argument

Frågor behöver ofta argument, till exempel när ni vill söka efter en bok med dess ID. Resolvers kan enkelt ta emot dessa argument.

Om vårt schema innehåller:

type Query {
  bookById(id: ID!): Book
}

Vi använder annoteringen @Argument i Spring for GraphQL:

import org.springframework.graphql.data.method.annotation.Argument;
import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.stereotype.Controller;
import java.util.List;
import java.util.ArrayList;

record Book(String id, String title, String author) {}

@Controller
public class BookByIdController {

  private final List<Book> books = new ArrayList<>(List.of(
    new Book("b-1", "The Moonstone", "Wilkie Collins"),
    new Book("b-2", "Pride and Prejudice", "Jane Austen")
  ));

  @QueryMapping
  public Book bookById(@Argument String id) {
    return books.stream()
      .filter(book -> book.id().equals(id))
      .findFirst()
      .orElse(null);
  }
}

Fältnivåresolvers

Ibland behöver ett fält i ett objekt ha en separat resolver. Det kan till exempel vara så att author i en Book är ett komplext objekt som behöver hämtas separat.

Anta att Book har ett authorId och att vi behöver hämta hela Author-objektet. För dessa fält som inte ligger på rotnivån använder vi @SchemaMapping.

import org.springframework.graphql.data.method.annotation.SchemaMapping;
import org.springframework.stereotype.Controller;

record Book(String id, String title, String authorId) {}
record Author(String id, String name) {}

@Controller
public class AuthorResolver {

  // This resolver is for the 'author' field on a 'Book' object
  @SchemaMapping
  public Author author(Book book) {
    // In a real app, you'd fetch from a data source using book.authorId()
    if ("auth-1".equals(book.authorId())) {
      return new Author(book.authorId(), "Wilkie Collins");
    }
    return new Author(book.authorId(), "Unknown Author");
  }
}

Komplett resolverapplikation

Låt oss sätta ihop allt till en körbar Spring Boot-applikation! Det här exemplet innehåller resolvers för att lista böcker, hitta en bok med ID och hämta en författare för en bok.

Prova att köra detta och skicka frågor till det med en GraphQL-klient!

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.graphql.data.method.annotation.Argument;
import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.graphql.data.method.annotation.SchemaMapping;
import org.springframework.stereotype.Controller;
import java.util.List;
import java.util.ArrayList;

// Data classes
record Book(String id, String title, String authorId) {}
record Author(String id, String name) {}

@SpringBootApplication
public class GraphQLResolversApp {
  public static void main(String[] args) {
    SpringApplication.run(GraphQLResolversApp.class, args);
  }
}

@Controller
class BookDataController {

  private final List<Book> books = new ArrayList<>(List.of(
    new Book("b-1", "The Moonstone", "auth-1"),
    new Book("b-2", "Pride and Prejudice", "auth-2"),
    new Book("b-3", "1984", "auth-3")
  ));

  @QueryMapping
  public List<Book> allBooks() {
    return books;
  }

  @QueryMapping
  public Book bookById(@Argument String id) {
    return books.stream()
      .filter(book -> book.id().equals(id))
      .findFirst()
      .orElse(null);
  }

  // Field-level resolver for 'author' on 'Book'
  @SchemaMapping
  public Author author(Book book) {
    // Mocking author data lookup
    return switch (book.authorId()) {
      case "auth-1" -> new Author("auth-1", "Wilkie Collins");
      case "auth-2" -> new Author("auth-2", "Jane Austen");
      case "auth-3" -> new Author("auth-3", "George Orwell");
      default -> new Author(book.authorId(), "Unknown Author");
    };
  }
}

Förstå resolver-mappning

Vilka av följande påståenden om GraphQL-resolvers i Spring Boot är sanna?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Er resa med resolvers

Ni har tagit ett stort steg i arbetet med att bygga GraphQL-API:er!

Vi har lärt oss att resolvers innehåller den centrala logiken för att hämta data.
Spring for GraphQL använder @Controller tillsammans med @QueryMapping för frågor på rotnivå och @SchemaMapping för nästlade fält.
Resolvers kan returnera enkla typer, anpassade objekt och listor.
Ni kan skicka argument till resolvers med annoteringen @Argument.

Härnäst får ni lära er att köra dessa frågor med verktyg som GraphiQL!

Gratis att börja

Lär dig GraphQL-API:er med Spring Boot 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: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Implementera dataresolvers” gratis?

Ja – hela texten till ”Implementera dataresolvers” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i GraphQL-API:er med Spring Boot, kan Ni uppgradera till CoddyKit PRO. Kursen i GraphQL-API:er med Spring Boot innehåller totalt 4 lektioner.

Vad lär jag mig i ”Implementera dataresolvers”?

Skriv resolverfunktioner i Spring Boot för att hämta data till era definierade GraphQL-fält från olika källor. Ni övar på GraphQL-API:er med Spring Boot 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 GraphQL-API:er med Spring Boot?

Du behöver inga förkunskaper. Utbildningen i GraphQL-API:er med Spring Boot 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 ”Implementera dataresolvers”?

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 GraphQL-API:er med Spring Boot-lektionen?

Ja. Varje GraphQL-API:er med Spring Boot-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 GraphQL-API:er med Spring Boot