GraphQL-API's met Spring Boot · Les

Data resolvers implementeren

Schrijf resolverfuncties in Spring Boot om gegevens voor uw gedefinieerde GraphQL-velden uit verschillende bronnen op te halen.

Les 2 van 411 stappen

Data resolvers implementeren is een gratis GraphQL-API's met Spring Boot-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject GraphQL-API's met Spring Boot. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus GraphQL-API's met Spring Boot bevat in totaal 4 lessen.

Wat zijn gegevensresolvers?

Welkom! In GraphQL vragen clients specifieke gegevens op. Maar hoe weet je server waar hij die gegevens vandaan moet halen?

Daar komen gegevensresolvers om de hoek kijken! Een resolver is een functie of methode die weet hoe hij de gegevens voor een specifiek veld in je GraphQL-schema moet ophalen.

Ze vormen de brug tussen je schema en je gegevensbronnen, zoals databases, API's of zelfs eenvoudige lijsten in het geheugen.
Elk veld in je schema heeft impliciet of expliciet een resolver nodig.

Resolvers in Spring voor GraphQL

Spring for GraphQL maakt het implementeren van resolvers eenvoudig. Het gebruikt annotaties om Java-methoden rechtstreeks aan velden in je GraphQL-schema te koppelen.

Je schrijft deze resolvermethoden doorgaans in Spring-@Controller-klassen. Spring scant deze controllers automatisch en koppelt hun methoden aan de velden van het GraphQL-schema op basis van naamgevingsconventies of expliciete annotaties.

Je eerste resolver voor een hoofdquery

Laten we een eenvoudige resolver voor een hoofdquery maken. We definiëren een basisveld hello dat een begroetingsreeks teruggeeft.

Stel eerst dat ons schema het volgende bevat:

type Query {
  hello: String
}

Nu schrijven we de Java-resolver:

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!";
  }
}

Aangepaste objecten resolven

Resolvers zijn niet alleen bedoeld voor eenvoudige tekenreeksen. Ze kunnen ook aangepaste Java-objecten retourneren! We definiëren een eenvoudige klasse Book en een resolver die dit object retourneert.

Stel dat ons schema het volgende bevat:

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

type Query {
  firstBook: Book
}

Hier zijn de klasse Book en een 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");
  }
}

Gegevensbronnen nabootsen

Voor onze voorbeelden maken we geen verbinding met een echte database. In plaats daarvan gebruiken we een lijst in het geheugen om een gegevensbron na te bootsen. Zo blijft onze code eenvoudig en blijft de focus op resolvers liggen.

In een echte toepassing zouden je resolvers communiceren met:

Databases (SQL, NoSQL)
Andere REST- of GraphQL-API's
Berichtenwachtrijen
Bestandssystemen

De taak van de resolver is simpelweg de gegevens ophalen, ongeacht de bron!

Een resolver voor een lijst implementeren

Vaak wil je een lijst met objecten retourneren. We kunnen BookController bijwerken zodat deze een lijst met boeken uit een nagebootste bron levert.

Als ons schema het volgende bevat:

type Query {
  allBooks: [Book]
}

Zo implementeren we de resolver:

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;
  }
}

Op ID zoeken met argumenten

Voor query's zijn vaak argumenten nodig, bijvoorbeeld om een boek op ID te zoeken. Resolvers kunnen deze argumenten eenvoudig accepteren.

Als ons schema het volgende bevat:

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

In Spring for GraphQL gebruiken we de annotatie @Argument:

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);
  }
}

Resolvers op veldniveau

Soms heeft een veld van een object zelf een aparte resolver nodig. Bijvoorbeeld wanneer de author van een Book een complex object is waarvoor een eigen zoekactie nodig is.

Stel dat Book een authorId heeft en dat we het volledige object Author moeten ophalen. Voor deze niet-hoofdvelden gebruiken we @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");
  }
}

Complete resolvertoepassing

We voegen alles samen in een uitvoerbare Spring Boot-toepassing! Dit voorbeeld bevat resolvers voor het weergeven van boeken, het zoeken van een boek op ID en het ophalen van een auteur voor een boek.

Probeer dit uit te voeren en er query's op uit te voeren met een GraphQL-client!

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");
    };
  }
}

Toewijzing van resolvers begrijpen

Welke van de volgende uitspraken over GraphQL-resolvers in Spring Boot zijn WAAR?

Beantwoord dit in de interactieve les

Samenvatting: jouw reis met resolvers

Je hebt een grote stap gezet bij het bouwen van GraphQL-API's!

We hebben geleerd dat resolvers de kernlogica vormen voor het ophalen van gegevens.
Spring for GraphQL gebruikt @Controller met @QueryMapping voor hoofdquery's en @SchemaMapping voor geneste velden.
Resolvers kunnen eenvoudige typen, aangepaste objecten en lijsten retourneren.
Je kunt argumenten aan resolvers doorgeven met de annotatie @Argument.

Hierna leer je hoe je deze query's uitvoert met hulpmiddelen zoals GraphiQL!

Gratis beginnen

Leer GraphQL-API's met Spring Boot met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Data resolvers implementeren” gratis?

Ja — de volledige tekst van “Data resolvers implementeren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus GraphQL-API's met Spring Boot wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus GraphQL-API's met Spring Boot bevat in totaal 4 lessen.

Wat leer ik in “Data resolvers implementeren”?

Schrijf resolverfuncties in Spring Boot om gegevens voor uw gedefinieerde GraphQL-velden uit verschillende bronnen op te halen. Je oefent met GraphQL-API's met Spring Boot door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met GraphQL-API's met Spring Boot te beginnen?

Ervaring vooraf is niet nodig. GraphQL-API's met Spring Boot op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Data resolvers implementeren”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over GraphQL-API's met Spring Boot?

Ja. Elke les over GraphQL-API's met Spring Boot bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar GraphQL-API's met Spring Boot