0Pricing
GraphQL APIs with Spring Boot · 강의

일괄 처리 및 캐싱 구현

Spring Boot 리졸버에 DataLoaders를 통합해 데이터 검색을 최적화하고 데이터베이스 왕복을 줄입니다.

일괄 처리 및 캐싱 구현은(는) CoddyKit의 무료 GraphQL APIs with Spring Boot 강의입니다. 이것은 4개 중 3번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 GraphQL APIs with Spring Boot 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. GraphQL APIs with Spring Boot 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

DataLoaders: Time to Implement!

Welcome back! In previous lessons, we learned about the N+1 problem and how DataLoaders provide an elegant solution through batching and caching.

Today, we'll get hands-on and integrate DataLoaders into a Spring Boot GraphQL application. We'll see how to define a BatchLoader, register it, and use it in our GraphQL resolvers.

Simulating a Data Service

First, let's set up a simple mock service that simulates fetching users from a database. This service will be called by our DataLoaders.

Notice the System.out.println, which will help us observe when the actual 'database' call happens, demonstrating batching later.

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

// A simple User data class
class User {
  String id;
  String name;
  User(String id, String name) { 
    this.id = id; this.name = name; 
  }
  public String getId() { return id; }
  public String getName() { return name; }
}

// Mock service to fetch users (simulates DB call)
class MockUserService {
  private final Map<String, User> users = Map.of(
    "1", new User("1", "Alice"),
    "2", new User("2", "Bob"),
    "3", new User("3", "Charlie"),
    "4", new User("4", "David")
  );

  public List<User> findAllByIds(List<String> ids) {
    System.out.println("DB Call: Fetching users for IDs: " + ids);
    return ids.stream()
              .map(users::get)
              .filter(user -> user != null)
              .collect(Collectors.toList());
  }
}

public class Main {
  public static void main(String[] args) {
    MockUserService service = new MockUserService();
    List<User> foundUsers = service.findAllByIds(List.of("1", "3"));
    System.out.println("Found: " + foundUsers.size() + " users.");
  }
}

The BatchLoader Interface

The core of DataLoader's batching mechanism is the BatchLoader interface. It defines a single method: load(List<K> keys).

  • It takes a list of keys (e.g., user IDs).
  • It returns a CompletionStage (a future-like object) of a list of values (e.g., users).
  • Crucially, this method is called once for all keys requested in a short window, allowing you to fetch them in a single optimized operation (like a single database query).

Implementing Your BatchLoader

Now, let's create our UserBatchLoader. It will implement the BatchLoader<String, User> interface, meaning it takes a String (user ID) as a key and returns a User object.

It uses our MockUserService to perform the actual batch fetch.

import org.dataloader.BatchLoader;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;

// (Assume User and MockUserService are defined elsewhere)
// For runnable example, they would be in the same file.

public class UserBatchLoader implements BatchLoader<String, User> {
  private final MockUserService userService;

  public UserBatchLoader(MockUserService userService) {
    this.userService = userService;
  }

  @Override
  public CompletionStage<List<User>> load(List<String> userIds) {
    // This method is called once with all requested IDs.
    // We delegate to our mock service to fetch them in one go.
    return CompletableFuture.supplyAsync(
      () -> userService.findAllByIds(userIds)
    );
  }
}

public class Main {
  public static void main(String[] args) {
    MockUserService userService = new MockUserService();
    UserBatchLoader batchLoader = new UserBatchLoader(userService);
    System.out.println("UserBatchLoader created!");
  }
}

The DataLoaderRegistry

In a Spring Boot GraphQL application, DataLoader instances are managed within a DataLoaderRegistry. This registry acts as a container for all DataLoaders available during a GraphQL request execution.

  • Each DataLoader is registered with a unique name (e.g., "userDataLoader").
  • Resolvers retrieve the necessary DataLoader from this registry using its name.
  • Spring for GraphQL typically handles the lifecycle and scope of this registry per request.

Setting up DataLoaders

Here's how you create a DataLoader instance from your BatchLoader and register it in a DataLoaderRegistry. This setup is crucial for making DataLoaders accessible to your resolvers.

import org.dataloader.DataLoader;
import org.dataloader.DataLoaderRegistry;

// (Assume User, MockUserService, UserBatchLoader are defined)

public class Main {
  public static void main(String[] args) {
    MockUserService userService = new MockUserService();
    UserBatchLoader userBatchLoader = new UserBatchLoader(userService);

    // Create a DataLoader instance
    DataLoader<String, User> userDataLoader =
      DataLoader.newDataLoader(userBatchLoader);

    // Register it in a DataLoaderRegistry
    DataLoaderRegistry registry = new DataLoaderRegistry();
    registry.register("userDataLoader", userDataLoader);

    System.out.println("DataLoader registered as 'userDataLoader'!");
    // In a real app, this registry would be part of the GraphQLContext.
    // Resolvers would then retrieve DataLoaders from it.
  }
}

Using DataLoader in Resolvers

Once your DataLoader is registered, you can use it within your GraphQL resolvers. Instead of directly calling your service, you'll call dataLoader.load(id).

  • The load() method returns a CompletionStage, not the direct object.
  • The DataLoader collects all load() calls within the current execution frame before dispatching them to the BatchLoader.
  • Spring for GraphQL automatically dispatches the DataLoaders at the end of a data fetching cycle.

Resolver Integration in Action

This example simulates a GraphQL query where multiple user IDs are requested. Watch the "DB Call" message in the output to see how DataLoaders batch these requests into a single operation, even if they appear separate in the resolver logic.

import org.dataloader.DataLoader;
import org.dataloader.DataLoaderRegistry;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.stream.Collectors;

// User, MockUserService, UserBatchLoader definitions (from previous scenes)
class User {
  String id; String name;
  User(String id, String name) { this.id = id; this.name = name; }
  public String getId() { return id; }
  public String getName() { return name; }
}

class MockUserService {
  private final Map<String, User> users = Map.of(
    "1", new User("1", "Alice"), "2", new User("2", "Bob"),
    "3", new User("3", "Charlie"), "4", new User("4", "David")
  );
  public List<User> findAllByIds(List<String> ids) {
    System.out.println("DB Call: Fetching users for IDs: " + ids);
    return ids.stream().map(users::get)
              .filter(user -> user != null).collect(Collectors.toList());
  }
}

class UserBatchLoader implements BatchLoader<String, User> {
  private final MockUserService userService;
  public UserBatchLoader(MockUserService userService) { this.userService = userService; }
  @Override
  public CompletionStage<List<User>> load(List<String> userIds) {
    return CompletableFuture.supplyAsync(() -> userService.findAllByIds(userIds));
  }
}

// Simulate a GraphQL Query Resolver method
public class UserResolver {
  private final DataLoaderRegistry dataLoaderRegistry;

  public UserResolver(DataLoaderRegistry registry) {
    this.dataLoaderRegistry = registry;
  }

  public CompletionStage<User> getUserById(String id) {
    DataLoader<String, User> userDataLoader =
      dataLoaderRegistry.getDataLoader("userDataLoader");
    return userDataLoader.load(id);
  }

  public static void main(String[] args) {
    MockUserService userService = new MockUserService();
    UserBatchLoader userBatchLoader = new UserBatchLoader(userService);
    DataLoader<String, User> userDataLoader =
      DataLoader.newDataLoader(userBatchLoader);

    DataLoaderRegistry registry = new DataLoaderRegistry();
    registry.register("userDataLoader", userDataLoader);

    UserResolver resolver = new UserResolver(registry);

    System.out.println("Requesting User 1 and User 2 concurrently...");

    // Simulate two concurrent GraphQL field fetches
    CompletableFuture<User> user1Future =
      (CompletableFuture<User>) resolver.getUserById("1");
    CompletableFuture<User> user2Future =
      (CompletableFuture<User>) resolver.getUserById("2");

    CompletableFuture.allOf(user1Future, user2Future)
      .thenRun(() -> {
        try {
          System.out.println("Fetched User 1: " + user1Future.join().getName());
          System.out.println("Fetched User 2: " + user2Future.join().getName());
        } catch (Exception e) {
          e.printStackTrace();
        }
        // For this manual demo, we dispatch the DataLoader.
        // In Spring GraphQL, this is handled automatically.
        userDataLoader.dispatch();
      }).join();
  }
}

DataLoader's Built-in Caching

Beyond batching, DataLoaders also provide request-scoped caching out-of-the-box. This means:

  • If dataLoader.load("1") is called multiple times within the same GraphQL request, the BatchLoader's fetch function for ID "1" will only be invoked once.
  • Subsequent calls for the same ID within that request will return the already fetched (cached) result.
  • This prevents redundant database calls for the same data within a single GraphQL operation, further boosting performance.

Check Your Understanding

You've learned how to implement DataLoaders for batching and caching. Let's test your knowledge!

Recap: Batching & Caching

Great job! You've successfully learned how to implement DataLoaders in Spring Boot GraphQL.

  • We created a MockUserService to simulate data fetching.
  • We built a UserBatchLoader to handle batching multiple ID requests.
  • We saw how to initialize and register DataLoader instances in a DataLoaderRegistry.
  • Finally, we integrated DataLoaders into a resolver, observing how requests are batched and how caching prevents redundant calls.

By using DataLoaders, you significantly optimize your GraphQL API's performance, especially when dealing with complex data graphs and nested objects.

자주 묻는 질문

“일괄 처리 및 캐싱 구현” 강의는 무료인가요?

네 — “일괄 처리 및 캐싱 구현” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 GraphQL APIs with Spring Boot 강의 전체를 잠금 해제할 수 있습니다. GraphQL APIs with Spring Boot 강의에는 총 4개의 강의가 포함되어 있습니다.

“일괄 처리 및 캐싱 구현”에서 뭘 배우나요?

Spring Boot 리졸버에 DataLoaders를 통합해 데이터 검색을 최적화하고 데이터베이스 왕복을 줄입니다. 브라우저에서 직접 실행하는 실습 코드로 GraphQL APIs with Spring Boot을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

GraphQL APIs with Spring Boot을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 GraphQL APIs with Spring Boot은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 3번째 강의입니다.

“일괄 처리 및 캐싱 구현” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 GraphQL APIs with Spring Boot 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 GraphQL APIs with Spring Boot 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

  1. N+1 문제 설명
  2. GraphQL DataLoaders 소개
  3. 일괄 처리 및 캐싱 구현
  4. Spring 컨텍스트 및 비동기 처리를 사용하는 DataLoaders
← GraphQL APIs with Spring Boot(으)로 돌아가기