Using Dataloader

================

to implement inefficient code with naive loading of a graph of data.

Using ``java-dataloader`` will help you to make this a more efficient process by both caching and batching requests for that graph of data items. If ``dataloader``

.. code-block:: json

]

In this case it would be *15* calls over the network. Even though the group of people have a lot of common friends.

With `dataloader` you can make the `graphql` query much more efficient.

the data loader is called to "promise" to deliver a person object. At each level `dataloader.dispatch()` will be

called to fire off the batch requests for that part of the query. With caching turned on (the default) then

If you use capabilities like `java.util.concurrent.CompletableFuture.supplyAsync()` then you can make it even more efficient by making the

the remote calls asynchronous to the rest of the query. This will make it even more timely since multiple calls can happen at once

GraphQL graphQL = GraphQL.newGraphQL(buildSchema())

.instrumentation(dispatcherInstrumentation)

.build();

One thing to note is the above only works if you use `DataLoaderDispatcherInstrumentation` which makes sure `dataLoader.dispatch()`

is called. If this was not in place, then all the promises to data will never be dispatched ot the batch loader function

longer than the web request say.

But if you are doing per request data loaders then creating a new set of ``GraphQL`` and ``DataLoader`` objects per

Structure your code so that the schema is statically held, perhaps in a static variable or in a singleton IoC component but

build out a new ``GraphQL`` set of objects on each request.