GraphQL APIs with Spring Boot · Aula

Implementando Resolvedores de Dados

Escreva funções resolvedoras no Spring Boot para buscar dados dos campos GraphQL definidos em várias fontes.

Implementando Resolvedores de Dados é uma aula grátis de GraphQL APIs with Spring Boot no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de GraphQL APIs with Spring Boot, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de GraphQL APIs with Spring Boot inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

What are Data Resolvers?

Welcome! In GraphQL, clients ask for specific data. But how does your server know where to get that data?

That's where Data Resolvers come in! A resolver is a function or method that knows how to fetch the data for a specific field in your GraphQL schema.

They act as the bridge between your schema and your data sources (like databases, APIs, or even simple in-memory lists).
Each field in your schema needs a resolver, implicitly or explicitly.

Resolvers in Spring for GraphQL

Spring for GraphQL makes implementing resolvers straightforward. It uses annotations to map Java methods directly to fields in your GraphQL schema.

You'll typically write these resolver methods inside Spring @Controller classes. Spring automatically scans these controllers and connects their methods to the GraphQL schema fields based on naming conventions or explicit annotations.

Your First Root Query Resolver

Let's create a simple resolver for a root query. We'll define a basic hello field that returns a greeting string.

First, imagine our schema has:

type Query {
  hello: String
}

Now, let's write the 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!";
  }
}

Resolving Custom Objects

Resolvers aren't just for simple strings. They can return custom Java objects too! Let's define a simple Book class and a resolver to return it.

Assume our schema has:

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

type Query {
  firstBook: Book
}

Here's the Book class and a 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");
  }
}

Mocking Data Sources

For our examples, we won't connect to a real database. Instead, we'll use an in-memory list to simulate a data source. This keeps our code simple and focused on resolvers.

In a real application, your resolvers would interact with:

Databases (SQL, NoSQL)
Other REST or GraphQL APIs
Message queues
File systems

The resolver's job is just to get the data, no matter the source!

Implementing a List Resolver

Often, you'll want to return a list of objects. Our BookController can be updated to provide a list of books from a mock source.

If our schema has:

type Query {
  allBooks: [Book]
}

Here's how we'd implement the 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;
  }
}

Resolving by ID with Arguments

Queries often need arguments, like searching for a book by its ID. Resolvers can easily accept these arguments.

If our schema has:

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

We use the @Argument annotation in 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);
  }
}

Field-Level Resolvers

Sometimes, a field on an object itself needs a separate resolver. For example, if the author of a Book was a complex object needing its own lookup.

Let's say Book has an authorId, and we need to fetch the full Author object. We use @SchemaMapping for these non-root fields.

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 Resolver Application

Let's put everything together into a runnable Spring Boot application! This example includes resolvers for listing books, finding a book by ID, and resolving an author for a book.

Try running this and querying it with a 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");
    };
  }
}

Understanding Resolver Mapping

Which of the following statements about GraphQL resolvers in Spring Boot are TRUE?

Recap: Your Resolver Journey

You've taken a big step in building GraphQL APIs!

We learned that resolvers are the core logic for fetching data.
Spring for GraphQL uses @Controller with @QueryMapping for root queries and @SchemaMapping for nested fields.
Resolvers can return simple types, custom objects, and lists.
You can pass arguments to resolvers using the @Argument annotation.

Next, you'll learn how to execute these queries using tools like GraphiQL!

Perguntas Frequentes

A aula “Implementando Resolvedores de Dados” é grátis?

Sim — o texto completo de “Implementando Resolvedores de Dados” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de GraphQL APIs with Spring Boot, atualize para CoddyKit PRO. O curso de GraphQL APIs with Spring Boot inclui 4 aulas no total.

O que vou aprender em “Implementando Resolvedores de Dados”?

Escreva funções resolvedoras no Spring Boot para buscar dados dos campos GraphQL definidos em várias fontes. Você pratica GraphQL APIs with Spring Boot com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar GraphQL APIs with Spring Boot?

Nenhuma experiência prévia é necessária. GraphQL APIs with Spring Boot no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Implementando Resolvedores de Dados”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de GraphQL APIs with Spring Boot?

Sim. Cada aula de GraphQL APIs with Spring Boot inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para GraphQL APIs with Spring Boot