graphql-java
diff --git a/build.gradle b/build.gradle
@@ -105,7 +105,7 @@ tasks.withType(GroovyCompile) {
 }
 dependencies {
     implementation 'org.antlr:antlr4-runtime:' + antlrVersion
-    api 'com.graphql-java:java-dataloader:4.0.0'
+    api 'com.graphql-java:java-dataloader:5.0.0'
     api 'org.reactivestreams:reactive-streams:' + reactiveStreamsVersion
     api "org.jspecify:jspecify:1.0.0"
     antlr 'org.antlr:antlr4:' + antlrVersion

diff --git a/src/test/groovy/graphql/execution/instrumentation/DataLoaderCacheCanBeAsyncTest.groovy b/src/test/groovy/graphql/execution/instrumentation/DataLoaderCacheCanBeAsyncTest.groovy
@@ -87,7 +87,7 @@ class DataLoaderCacheCanBeAsyncTest extends Specification {
         def valueCache = new CustomValueCache()
         valueCache.store.put("a", [id: "cachedA", name: "cachedAName"])
 
-        DataLoaderOptions options = DataLoaderOptions.newOptions().setValueCache(valueCache).setCachingEnabled(true)
+        DataLoaderOptions options = DataLoaderOptions.newOptions().setValueCache(valueCache).setCachingEnabled(true).build()
         DataLoader userDataLoader = DataLoaderFactory.newDataLoader(userBatchLoader, options)
 
         registry = DataLoaderRegistry.newRegistry()

diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/BatchCompareDataFetchers.java b/src/test/groovy/graphql/execution/instrumentation/dataloader/BatchCompareDataFetchers.java
@@ -100,9 +100,9 @@ private static List<List<Department>> getDepartmentsForShops(List<Shop> shops) {
 
     public DataLoader<String, List<Department>> departmentsForShopDataLoader = DataLoaderFactory.newDataLoader(departmentsForShopsBatchLoader);
 
-    public DataFetcher<CompletableFuture<List<Department>>> departmentsForShopDataLoaderDataFetcher = environment -> {
+    public DataFetcher<?> departmentsForShopDataLoaderDataFetcher = environment -> {
         Shop shop = environment.getSource();
-        return departmentsForShopDataLoader.load(shop.getId());
+        return environment.getDataLoader("departments").load(shop.getId());
     };
 
     // Products
@@ -136,9 +136,9 @@ private static List<List<Product>> getProductsForDepartments(List<Department> de
 
     public DataLoader<String, List<Product>> productsForDepartmentDataLoader = DataLoaderFactory.newDataLoader(productsForDepartmentsBatchLoader);
 
-    public DataFetcher<CompletableFuture<List<Product>>> productsForDepartmentDataLoaderDataFetcher = environment -> {
+    public DataFetcher<?> productsForDepartmentDataLoaderDataFetcher = environment -> {
         Department department = environment.getSource();
-        return productsForDepartmentDataLoader.load(department.getId());
+        return environment.getDataLoader("products").load(department.getId());
     };
 
     private <T> CompletableFuture<T> maybeAsyncWithSleep(Supplier<CompletableFuture<T>> supplier) {

diff --git a/.../groovy/graphql/execution/instrumentation/dataloader/DataLoaderCompanyProductBackend.java b/.../groovy/graphql/execution/instrumentation/dataloader/DataLoaderCompanyProductBackend.java
@@ -2,6 +2,7 @@
 
 
 import com.google.common.collect.ImmutableList;
+import org.dataloader.BatchLoader;
 import org.dataloader.DataLoader;
 import org.dataloader.DataLoaderFactory;
 
@@ -26,12 +27,13 @@ public DataLoaderCompanyProductBackend(int companyCount, int projectCount) {
             mkCompany(projectCount);
         }
 
-        projectsLoader = DataLoaderFactory.newDataLoader(keys -> getProjectsForCompanies(keys).thenApply(projects -> keys
+        BatchLoader<UUID, List<Project>> uuidListBatchLoader = keys -> getProjectsForCompanies(keys).thenApply(projects -> keys
                 .stream()
                 .map(companyId -> projects.stream()
                         .filter(project -> project.getCompanyId().equals(companyId))
                         .collect(Collectors.toList()))
-                .collect(Collectors.toList())));
+                .collect(Collectors.toList()));
+        projectsLoader = DataLoaderFactory.newDataLoader(uuidListBatchLoader);
 
     }
 

diff --git a/.../graphql/execution/instrumentation/dataloader/DataLoaderCompanyProductMutationTest.groovy b/.../graphql/execution/instrumentation/dataloader/DataLoaderCompanyProductMutationTest.groovy
@@ -48,7 +48,7 @@ class DataLoaderCompanyProductMutationTest extends Specification {
                 newTypeWiring("Company").dataFetcher("projects", {
                     environment ->
                         DataLoaderCompanyProductBackend.Company source = environment.getSource()
-                        return backend.getProjectsLoader().load(source.getId())
+                        return environment.getDataLoader("projects-dl").load(source.getId())
                 }))
                 .type(
                 newTypeWiring("Query").dataFetcher("companies", {

diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderHangingTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderHangingTest.groovy
@@ -192,7 +192,7 @@ class DataLoaderHangingTest extends Specification {
                     })
                 }, executor)
             }
-        }, DataLoaderOptions.newOptions().setMaxBatchSize(5))
+        }, DataLoaderOptions.newOptions().setMaxBatchSize(5).build())
 
         def dataLoaderSongs = DataLoaderFactory.newDataLoader(new BatchLoader<DataFetchingEnvironment, List<Object>>() {
             @Override
@@ -209,7 +209,7 @@ class DataLoaderHangingTest extends Specification {
                     })
                 }, executor)
             }
-        }, DataLoaderOptions.newOptions().setMaxBatchSize(5))
+        }, DataLoaderOptions.newOptions().setMaxBatchSize(5).build())
 
         def dataLoaderRegistry = new DataLoaderRegistry()
         dataLoaderRegistry.register("artist.albums", dataLoaderAlbums)

diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderNodeTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderNodeTest.groovy
@@ -11,6 +11,7 @@ import graphql.schema.GraphQLObjectType
 import graphql.schema.GraphQLSchema
 import graphql.schema.StaticDataFetcher
 import org.dataloader.DataLoader
+import org.dataloader.DataLoaderFactory
 import org.dataloader.DataLoaderRegistry
 import spock.lang.Specification
 
@@ -69,39 +70,42 @@ class DataLoaderNodeTest extends Specification {
     }
 
     class NodeDataFetcher implements DataFetcher {
-        DataLoader loader
+        String name
 
-        NodeDataFetcher(DataLoader loader) {
-            this.loader = loader
+        NodeDataFetcher(String name) {
+            this.name = name
         }
 
         @Override
         Object get(DataFetchingEnvironment environment) throws Exception {
-            return loader.load(environment.getSource())
+            return environment.getDataLoader(name).load(environment.getSource())
         }
     }
 
     def "levels of loading"() {
 
         List<List<Node>> nodeLoads = []
 
-        DataLoader<Node, List<Node>> loader = new DataLoader<>({ keys ->
+
+        def batchLoadFunction = { keys ->
             nodeLoads.add(keys)
             List<List<Node>> childNodes = new ArrayList<>()
             for (Node key : keys) {
                 childNodes.add(key.childNodes)
             }
             System.out.println("BatchLoader called for " + keys + " -> got " + childNodes)
             return CompletableFuture.completedFuture(childNodes)
-        })
-
-        DataFetcher<?> nodeDataFetcher = new NodeDataFetcher(loader)
+        }
+        DataLoader<Node, List<Node>> loader = DataLoaderFactory.newDataLoader(batchLoadFunction)
 
         def nodeTypeName = "Node"
         def childNodesFieldName = "childNodes"
         def queryTypeName = "Query"
         def rootFieldName = "root"
 
+        DataFetcher<?> nodeDataFetcher = new NodeDataFetcher(childNodesFieldName)
+        DataLoaderRegistry registry = new DataLoaderRegistry().register(childNodesFieldName, loader)
+
         GraphQLObjectType nodeType = GraphQLObjectType
                 .newObject()
                 .name(nodeTypeName)
@@ -132,8 +136,6 @@ class DataLoaderNodeTest extends Specification {
                         .build())
                 .build()
 
-        DataLoaderRegistry registry = new DataLoaderRegistry().register(childNodesFieldName, loader)
-
         ExecutionResult result = GraphQL.newGraphQL(schema)
 //                .instrumentation(new DataLoaderDispatcherInstrumentation())
                 .build()

diff --git a/...est/groovy/graphql/execution/instrumentation/dataloader/DataLoaderTypeMismatchTest.groovy b/...est/groovy/graphql/execution/instrumentation/dataloader/DataLoaderTypeMismatchTest.groovy
@@ -9,6 +9,7 @@ import graphql.schema.idl.SchemaGenerator
 import graphql.schema.idl.SchemaParser
 import org.dataloader.BatchLoader
 import org.dataloader.DataLoader
+import org.dataloader.DataLoaderFactory
 import org.dataloader.DataLoaderRegistry
 import spock.lang.Specification
 
@@ -36,7 +37,7 @@ class DataLoaderTypeMismatchTest extends Specification {
 
         def typeDefinitionRegistry = new SchemaParser().parse(sdl)
 
-        def dataLoader = new DataLoader<Object, Object>(new BatchLoader<Object, Object>() {
+        def dataLoader = DataLoaderFactory.newDataLoader(new BatchLoader<Object, Object>() {
             @Override
             CompletionStage<List<Object>> load(List<Object> keys) {
                 return CompletableFuture.completedFuture([
@@ -50,7 +51,7 @@ class DataLoaderTypeMismatchTest extends Specification {
         def todosDef = new DataFetcher<CompletableFuture<Object>>() {
             @Override
             CompletableFuture<Object> get(DataFetchingEnvironment environment) {
-                return dataLoader.load(environment)
+                return environment.getDataLoader("getTodos").load(environment)
             }
         }
 

diff --git a/...roovy/graphql/execution/instrumentation/dataloader/Issue1178DataLoaderDispatchTest.groovy b/...roovy/graphql/execution/instrumentation/dataloader/Issue1178DataLoaderDispatchTest.groovy
@@ -8,6 +8,7 @@ import graphql.schema.StaticDataFetcher
 import graphql.schema.idl.RuntimeWiring
 import org.dataloader.BatchLoader
 import org.dataloader.DataLoader
+import org.dataloader.DataLoaderFactory
 import org.dataloader.DataLoaderRegistry
 import spock.lang.Specification
 
@@ -40,15 +41,15 @@ class Issue1178DataLoaderDispatchTest extends Specification {
 
         def executor = Executors.newFixedThreadPool(5)
 
-        def dataLoader = new DataLoader<Object, Object>(new BatchLoader<Object, Object>() {
+        def dataLoader = DataLoaderFactory.newDataLoader(new BatchLoader<Object, Object>() {
             @Override
             CompletionStage<List<Object>> load(List<Object> keys) {
                 return CompletableFuture.supplyAsync({
                     return keys.collect({ [id: 'r' + it] })
                 }, executor)
             }
         })
-        def dataLoader2 = new DataLoader<Object, Object>(new BatchLoader<Object, Object>() {
+        def dataLoader2 = DataLoaderFactory.newDataLoader(new BatchLoader<Object, Object>() {
             @Override
             CompletionStage<List<Object>> load(List<Object> keys) {
                 return CompletableFuture.supplyAsync({
@@ -61,8 +62,8 @@ class Issue1178DataLoaderDispatchTest extends Specification {
         dataLoaderRegistry.register("todo.related", dataLoader)
         dataLoaderRegistry.register("todo.related2", dataLoader2)
 
-        def relatedDf = new MyDataFetcher(dataLoader)
-        def relatedDf2 = new MyDataFetcher(dataLoader2)
+        def relatedDf = new MyDataFetcher("todo.related")
+        def relatedDf2 = new MyDataFetcher("todo.related2")
 
         def wiring = RuntimeWiring.newRuntimeWiring()
                 .type(newTypeWiring("Query")
@@ -119,16 +120,16 @@ class Issue1178DataLoaderDispatchTest extends Specification {
 
     static class MyDataFetcher implements DataFetcher<CompletableFuture<Object>> {
 
-        private final DataLoader dataLoader
+        private final String name
 
-        MyDataFetcher(DataLoader dataLoader) {
-            this.dataLoader = dataLoader
+        MyDataFetcher(String name) {
+            this.name = name
         }
 
         @Override
         CompletableFuture<Object> get(DataFetchingEnvironment environment) {
             def todo = environment.source as Map
-            return dataLoader.load(todo['id'])
+            return environment.getDataLoader(name).load(todo['id'])
         }
     }
 }
diff --git a/...phql/execution/instrumentation/dataloader/PeopleCompaniesAndProductsDataLoaderTest.groovy b/...phql/execution/instrumentation/dataloader/PeopleCompaniesAndProductsDataLoaderTest.groovy
@@ -12,6 +12,7 @@ import graphql.schema.DataFetchingEnvironment
 import graphql.schema.idl.RuntimeWiring
 import org.dataloader.BatchLoader
 import org.dataloader.DataLoader
+import org.dataloader.DataLoaderFactory
 import org.dataloader.DataLoaderRegistry
 import spock.lang.Specification
 
@@ -168,8 +169,8 @@ class PeopleCompaniesAndProductsDataLoaderTest extends Specification {
 
 
     private DataLoaderRegistry buildRegistry() {
-        DataLoader<Integer, Person> personDataLoader = new DataLoader<>(personBatchLoader)
-        DataLoader<Integer, Company> companyDataLoader = new DataLoader<>(companyBatchLoader)
+        DataLoader<Integer, Person> personDataLoader = DataLoaderFactory.newDataLoader(personBatchLoader)
+        DataLoader<Integer, Company> companyDataLoader = DataLoaderFactory.newDataLoader(companyBatchLoader)
 
         DataLoaderRegistry registry = new DataLoaderRegistry()
         registry.register("person", personDataLoader)

diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/StarWarsDataLoaderWiring.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/StarWarsDataLoaderWiring.groovy
@@ -10,6 +10,7 @@ import graphql.schema.idl.MapEnumValuesProvider
 import graphql.schema.idl.RuntimeWiring
 import org.dataloader.BatchLoader
 import org.dataloader.DataLoader
+import org.dataloader.DataLoaderFactory
 import org.dataloader.DataLoaderRegistry
 
 import java.util.concurrent.CompletableFuture
@@ -60,7 +61,7 @@ class StarWarsDataLoaderWiring {
 
     def newDataLoaderRegistry() {
         // a data loader for characters that points to the character batch loader
-        def characterDataLoader = new DataLoader<String, Object>(characterBatchLoader)
+        def characterDataLoader = DataLoaderFactory.newDataLoader(characterBatchLoader)
         new DataLoaderRegistry().register("character", characterDataLoader)
     }
 

diff --git a/src/test/groovy/graphql/schema/DataFetchingEnvironmentImplTest.groovy b/src/test/groovy/graphql/schema/DataFetchingEnvironmentImplTest.groovy
@@ -73,7 +73,7 @@ class DataFetchingEnvironmentImplTest extends Specification {
         dfe.getVariables() == variables
         dfe.getOperationDefinition() == operationDefinition
         dfe.getExecutionId() == executionId
-        dfe.getDataLoader("dataLoader") == dataLoader
+        dfe.getDataLoader("dataLoader") != null
     }
 
     def "create environment from existing one will copy everything to new instance"() {
@@ -118,7 +118,7 @@ class DataFetchingEnvironmentImplTest extends Specification {
         dfe.getDocument() == dfeCopy.getDocument()
         dfe.getOperationDefinition() == dfeCopy.getOperationDefinition()
         dfe.getVariables() == dfeCopy.getVariables()
-        dfe.getDataLoader("dataLoader") == dataLoader
+        dfe.getDataLoader("dataLoader") != null
         dfe.getLocale() == dfeCopy.getLocale()
         dfe.getLocalContext() == dfeCopy.getLocalContext()
     }

diff --git a/src/test/groovy/readme/DataLoaderBatchingExamples.java b/src/test/groovy/readme/DataLoaderBatchingExamples.java
@@ -171,7 +171,7 @@ public CompletableFuture<Void> clear() {
             }
         };
 
-        DataLoaderOptions options = DataLoaderOptions.newOptions().setValueCache(crossRequestValueCache);
+        DataLoaderOptions options = DataLoaderOptions.newOptions().setValueCache(crossRequestValueCache).build();
 
         DataLoader<String, Object> dataLoader = DataLoaderFactory.newDataLoader(batchLoader, options);
     }
@@ -260,7 +260,7 @@ public Object getContext() {
         //
         // this creates an overall context for the dataloader
         //
-        DataLoaderOptions loaderOptions = DataLoaderOptions.newOptions().setBatchLoaderContextProvider(contextProvider);
+        DataLoaderOptions loaderOptions = DataLoaderOptions.newOptions().setBatchLoaderContextProvider(contextProvider).build();
         DataLoader<String, Object> characterDataLoader = DataLoaderFactory.newDataLoader(batchLoaderWithCtx, loaderOptions);
 
         // .... later in your data fetcher