DataLoader (java-dataloader 1.0.1 API)

java.lang.Object
- org.dataloader.DataLoader<K,V>

Type Parameters:

K - type parameter indicating the type of the data load keys

V - type parameter indicating the type of the data that is returned
```
public class DataLoader<K,V>
extends java.lang.Object
```
Data loader is a utility class that allows batch loading of data that is identified by a set of unique keys. For each key that is loaded a separate CompletableFuture is returned, that completes as the batch function completes.
With batching enabled the execution will start after calling dispatch(), causing the queue of loaded keys to be sent to the batch function, clears the queue, and returns a promise to the values.
As batch functions are executed the resulting futures are cached using a cache implementation of choice, so they will only execute once. Individual cache keys can be cleared, so they will be re-fetched when referred to again. It is also possible to clear the cache entirely, and prime it with values before they are used.
Both caching and batching can be disabled. Configuration of the data loader is done by providing a DataLoaderOptions instance on creation.

Constructor Summary

Constructors
Constructor and Description
`DataLoader(BatchLoader<K,V> batchLoadFunction)` Creates a new data loader with the provided batch load function, and default options.
`DataLoader(BatchLoader<K,V> batchLoadFunction, DataLoaderOptions options)` Creates a new data loader with the provided batch load function and options.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`DataLoader<K,V>`	`clear(K key)` Clears the future with the specified key from the cache, if caching is enabled, so it will be re-fetched on the next load request.
`DataLoader<K,V>`	`clearAll()` Clears the entire cache map of the loader.
`java.util.concurrent.CompletableFuture<java.util.List<V>>`	`dispatch()` Dispatches the queued load requests to the batch execution function and returns a promise of the result.
`java.util.List<V>`	`dispatchAndJoin()` Normally `dispatch()` is an asynchronous operation but this version will 'join' on the results if dispatch and wait for them to complete.
`int`	`dispatchDepth()`
`java.lang.Object`	`getCacheKey(K key)` Gets the object that is used in the internal cache map as key, by applying the cache key function to the provided key.
`java.util.concurrent.CompletableFuture<V>`	`load(K key)` Requests to load the data with the specified key asynchronously, and returns a future of the resulting value.
`java.util.concurrent.CompletableFuture<java.util.List<V>>`	`loadMany(java.util.List<K> keys)` Requests to load the list of data provided by the specified keys asynchronously, and returns a composite future of the resulting values.
`DataLoader<K,V>`	`prime(K key, java.lang.Exception error)` Primes the cache with the given key and error.
`DataLoader<K,V>`	`prime(K key, V value)` Primes the cache with the given key and value.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DataLoader
```
public DataLoader(BatchLoader<K,V> batchLoadFunction)
```
    Creates a new data loader with the provided batch load function, and default options.
    
    Parameters:
    
    batchLoadFunction - the batch load function to use
  - DataLoader
```
public DataLoader(BatchLoader<K,V> batchLoadFunction,
                  DataLoaderOptions options)
```
    Creates a new data loader with the provided batch load function and options.
    
    Parameters:
    
    batchLoadFunction - the batch load function to use
    
    options - the batch load options
- Method Detail
  - load
```
public java.util.concurrent.CompletableFuture<V> load(K key)
```
    Requests to load the data with the specified key asynchronously, and returns a future of the resulting value.
    If batching is enabled (the default), you'll have to call dispatch() at a later stage to start batch execution. If you forget this call the future will never be completed (unless already completed, and returned from cache).
    
    Parameters:
    
    key - the key to load
    
    Returns:
    
    the future of the value
  - loadMany
```
public java.util.concurrent.CompletableFuture<java.util.List<V>> loadMany(java.util.List<K> keys)
```
    Requests to load the list of data provided by the specified keys asynchronously, and returns a composite future of the resulting values.
    If batching is enabled (the default), you'll have to call dispatch() at a later stage to start batch execution. If you forget this call the future will never be completed (unless already completed, and returned from cache).
    
    Parameters:
    
    keys - the list of keys to load
    
    Returns:
    
    the composite future of the list of values
  - dispatch
```
public java.util.concurrent.CompletableFuture<java.util.List<V>> dispatch()
```
    Dispatches the queued load requests to the batch execution function and returns a promise of the result.
    If batching is disabled, or there are no queued requests, then a succeeded promise is returned.
    
    Returns:
    
    the promise of the queued load requests
  - dispatchAndJoin
```
public java.util.List<V> dispatchAndJoin()
```
    Normally dispatch() is an asynchronous operation but this version will 'join' on the results if dispatch and wait for them to complete. If the CompletableFuture callbacks make more calls to this data loader then the dispatchDepth() will be > 0 and this method will loop around and wait for any other extra batch loads to occur.
    
    Returns:
    
    the list of all results when the dispatchDepth() reached 0
  - dispatchDepth
```
public int dispatchDepth()
```
    Returns:
    
    the depth of the batched key loads that need to be dispatched
  - clear
```
public DataLoader<K,V> clear(K key)
```
    Clears the future with the specified key from the cache, if caching is enabled, so it will be re-fetched on the next load request.
    
    Parameters:
    
    key - the key to remove
    
    Returns:
    
    the data loader for fluent coding
  - clearAll
```
public DataLoader<K,V> clearAll()
```
    Clears the entire cache map of the loader.
    
    Returns:
    
    the data loader for fluent coding
  - prime
```
public DataLoader<K,V> prime(K key,
                             V value)
```
    Primes the cache with the given key and value.
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    the data loader for fluent coding
  - prime
```
public DataLoader<K,V> prime(K key,
                             java.lang.Exception error)
```
    Primes the cache with the given key and error.
    
    Parameters:
    
    key - the key
    
    error - the exception to prime instead of a value
    
    Returns:
    
    the data loader for fluent coding
  - getCacheKey
```
public java.lang.Object getCacheKey(K key)
```
    Gets the object that is used in the internal cache map as key, by applying the cache key function to the provided key.
    If no cache key function is present in DataLoaderOptions, then the returned value equals the input key.
    
    Parameters:
    
    key - the input key
    
    Returns:
    
    the cache key after the input is transformed with the cache key function

Class DataLoader<K,V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DataLoader

DataLoader

Method Detail

load

loadMany

dispatch

dispatchAndJoin

dispatchDepth

clear

clearAll

prime

prime

getCacheKey