Package org.dataloader.registries

Class ScheduledDataLoaderRegistry

  • All Implemented Interfaces:
    java.lang.AutoCloseable
    @ExperimentalApi
@NullMarked
public class ScheduledDataLoaderRegistry
extends DataLoaderRegistry
implements java.lang.AutoCloseable
    This DataLoaderRegistry will use DispatchPredicates when dispatchAll() is called to test (for each DataLoader in the registry) if a dispatch should proceed. If the predicate returns false, then a task is scheduled to perform that predicate dispatch again via the ScheduledExecutorService.

    It;s possible to have a DispatchPredicate per dataloader as well as a default DispatchPredicate for the whole ScheduledDataLoaderRegistry.

    This will continue to loop (test false and reschedule) until such time as the predicate returns true, in which case no rescheduling will occur, and you will need to call dispatch again to restart the process.

    In the default mode, when tickerMode is false, the registry will continue to loop (test false and reschedule) until such time as the predicate returns true, in which case no rescheduling will occur, and you will need to call dispatch again to restart the process.

    However, when tickerMode is true, the registry will always reschedule continuously after the first ever call to dispatchAll().

    This will allow you to chain together DataLoader load calls like this : 

    
   CompletableFuture<String> future = dataLoaderA.load("A")
                                          .thenCompose(value -> dataLoaderB.load(value));

    However, it may mean your batching will not be as efficient as it might be. In environments like graphql this might mean you are too eager in fetching. The DispatchPredicate still runs to decide if dispatch should happen however in ticker mode it will be continuously rescheduled.

    When tickerMode is true, you really SHOULD close the registry say at the end of a request otherwise you will leave a job on the ScheduledExecutorService that is continuously dispatching.

    If you wanted to create a ScheduledDataLoaderRegistry that started a rescheduling immediately, just create one and call rescheduleNow().

    By default, it uses a Executors.newSingleThreadScheduledExecutor()} to schedule the tasks. However, if you are creating a ScheduledDataLoaderRegistry per request you will want to look at sharing this ScheduledExecutorService to avoid creating a new thread per registry created.

    This code is currently marked as ExperimentalApi

    • Method Detail

      • close

        public void close()
        Once closed this registry will never again reschedule checks
        Specified by:
        close in interface java.lang.AutoCloseable

      • getScheduledExecutorService

        public java.util.concurrent.ScheduledExecutorService getScheduledExecutorService()
        Returns:
        executor being used by this registry

      • getScheduleDuration

        public java.time.Duration getScheduleDuration()
        Returns:
        how long the ScheduledExecutorService task will wait before checking the predicate again

      • isTickerMode

        public boolean isTickerMode()
        Returns:
        true of the registry is in ticker mode or false otherwise

      • combine

        public ScheduledDataLoaderRegistry combine​(DataLoaderRegistry registry)
        This will combine all the current data loaders in this registry and all the data loaders from the specified registry and return a new combined registry
        Overrides:
        combine in class DataLoaderRegistry
        Parameters:
        registry - the registry to combine into this registry
        Returns:
        a new combined registry

      • getDataLoaderPredicates

        public java.util.Map<DataLoader<?,​?>,​DispatchPredicate> getDataLoaderPredicates()
        Returns:
        a map of data loaders to specific dispatch predicates

      • register

        public ScheduledDataLoaderRegistry register​(java.lang.String key,
                                            DataLoader<?,​?> dataLoader,
                                            DispatchPredicate dispatchPredicate)
        This will register a new dataloader and dispatch predicate associated with that data loader
        Parameters:
        key - the key to put the data loader under
        dataLoader - the data loader to register
        dispatchPredicate - the dispatch predicate to associate with this data loader
        Returns:
        this registry

      • dispatchAllImmediately

        public void dispatchAllImmediately()
        This will immediately dispatch the DataLoaders in the registry without testing the predicates

      • dispatchAllWithCountImmediately

        public int dispatchAllWithCountImmediately()
        This will immediately dispatch the DataLoaders in the registry without testing the predicates
        Returns:
        total number of entries that were dispatched from registered DataLoaders.

      • rescheduleNow

        public void rescheduleNow()
        This will schedule a task to check the predicate and dispatch if true right now. It will not do a pre-check of the predicate like dispatchAll() would