Lecture 292: Grouping Requests with Batch Loading

Hey, future GraphQL masters! Today we’re diving into optimizing GraphQL queries and breaking down the Batch Loading concept. How often have you heard that "GraphQL magically fixes everything"? Sadly, there’s no magic, but there are powerful tools and approaches that can take your GraphQL API performance to the next level. One of those tools is Batch Loading. Ready? Let’s go!

What is Batch Loading?

When the frontend makes a GraphQL request, it can ask for a ton of related data. Example: you request a list of users, and for each user you need their list of posts or info about their followers. With a naive implementation this can turn into dozens, or even hundreds of database calls.

Batch Loading is a technique for grouping all those independent requests into one, reducing the number of round-trips to the database or other external systems. It’s literally a way to "load everything in bulk" instead of one-by-one.

Why Batch Loading matters

Without Batch Loading your GraphQL API can suffer from the issue known as the N+1 Problem. For example, imagine you request 10 users and for each you need their 10 posts. In the worst case that results in:

• 1 request to get the 10 users.
• 10 requests to get their posts (1 request per user).

Total: 1 + 10 = 11 requests, whereas we could do just 2 big requests.

Boosting performance

Batch Loading helps combine those 10 separate requests into one "batched" database query — result: fewer requests and a noticeable performance boost.

Tools for Batch Loading

In the GraphQL ecosystem there are several popular libraries for implementing Batch Loading. The most well-known is DataLoader. It provides a convenient API for batching and caching requests.

Spring GraphQL also supports DataLoader out of the box, so we don’t have to reinvent the wheel!

Scenarios where Batch Loading is useful

Let’s look at some common cases where Batch Loading is especially helpful:

1. Data from common sources

If you have multiple requests that use the same external API or database, Batch Loading is the perfect fit. For example:

query {
  users {
    id
    posts {
      id
      title
    }
  }
}

Here, users and their posts can be fetched from the same source by grouping requests.

2. Data dependencies

When fields inside the GraphQL schema are related or depend on each other, using Batch Loading helps avoid redundant queries.

Practice: Implementing Batch Loading in Spring GraphQL

Step 1: Add DataLoader

To get started, first add the graphql-java-dataloader dependency to your pom.xml:

<dependency>
    <groupId>com.graphql-java</groupId>
    <artifactId>graphql-java-dataloader</artifactId>
    <version>1.4.0</version>
</dependency>

Step 2: Create the BatchLoader

Let’s create a UserBatchLoader class that batches requests for users' posts:

import org.dataloader.BatchLoader;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

public class UserBatchLoader implements BatchLoader<Long, List<Post>> {

    private final PostService postService; // Assume we have a PostService

    public UserBatchLoader(PostService postService) {
        this.postService = postService;
    }

    @Override
    public CompletableFuture<List<List<Post>>> load(List<Long> userIds) {
        // Group requests based on userId
        return CompletableFuture.supplyAsync(() ->
            userIds.stream()
                   .map(postService::getPostsByUserId) // Get posts for each userId
                   .collect(Collectors.toList())
        );
    }
}

Step 3: Register the DataLoader

Now we register our BatchLoader via DataLoader:

import org.dataloader.DataLoaderRegistry;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class DataLoaderConfig {

    private final PostService postService;

    public DataLoaderConfig(PostService postService) {
        this.postService = postService;
    }

    @Bean
    public DataLoaderRegistry dataLoaderRegistry() {
        DataLoaderRegistry registry = new DataLoaderRegistry();
        // Register the loader
        registry.register("postBatchLoader", DataLoader.newMappedDataLoader(new UserBatchLoader(postService)));
        return registry;
    }
}

Step 4: Hook the DataLoader into the Data Fetcher

Now we need to plug our DataLoader into the appropriate Data Fetcher:

import org.dataloader.DataLoader;
import org.springframework.stereotype.Component;

@Component
public class UserGraphQLDataFetcher {

    public CompletableFuture<List<Post>> getPosts(DataLoader<Long, List<Post>> postDataLoader, User user) {
        return postDataLoader.load(user.getId()); // Use DataLoader to load
    }
}

Step 5: Testing

To see Batch Loading in action, run this GraphQL query:

query {
  users {
    id
    name
    posts {
      id
      title
    }
  }
}

You’ll notice that instead of N separate queries, the database receives 1 grouped request for all users.

How to avoid common mistakes?

Beginners often run into issues from misconfigured BatchLoaders. Here are a few tips:

1. Don’t forget to cache. DataLoader handles caching out of the box, so don’t roll your own caches unnecessarily.
2. Asynchronicity is your friend. Even if DataLoader can run synchronously, prefer using CompletableFuture.
3. Don’t use Batch Loading for everything. If a request is simple and doesn’t benefit from batching, only add a DataLoader where it makes sense.

Benefits of Batch Loading

• Fewer requests: minimizes calls to the database or external APIs.
• Better performance: reduces latency.
• Easier data dependency management: DataLoader takes care of batching for you.
• Improved scalability: reduces server load in high-traffic systems.

That’s it for today! Now you know how to use Batch Loading to optimize your GraphQL APIs. Most importantly, you can explain to your teammates why their app is slow without DataLoader (and smoothly offer to help). Good luck optimizing your APIs, coders!