Now with repeated factory methods of the new different loader interfaces

Author: bbakerman

README.md

@@ -70,7 +70,7 @@ a list of keys
             }
         };
 
-        DataLoader<Long, User> userLoader = new DataLoader<>(userBatchLoader);
+        DataLoader<Long, User> userLoader = DataLoader.newDataLoader(userBatchLoader);
 
 ```
 
@@ -169,33 +169,25 @@ That said, with key caching turn on (the default), it will still be more efficie
 
 Often there is a need to call the batch loader function with some sort of call context environment, such as the calling users security
 credentials or the database connection parameters.  You can do this by implementing a 
-`org.dataloader.BatchLoaderEnvironmentProvider`.
+`org.dataloader.BatchLoaderEnvironmentProvider` and using one of the `xxxWithContext` batch loading interfaces
+such as `org.dataloader.BatchLoaderWithContext`.
 
 ```java
-        BatchLoader<String, String> batchLoader = new BatchLoader<String, String>() {
-            //
-            // the reason this method exists is for backwards compatibility.  There are a large
-            // number of existing dataloader clients out there that used this method before the call context was invented
-            // and hence to preserve compatibility we have this unfortunate method declaration.
-            //
-            @Override
-            public CompletionStage<List<String>> load(List<String> keys) {
-                throw new UnsupportedOperationException();
-            }
+        BatchLoaderEnvironment batchLoaderEnvironment = BatchLoaderEnvironment.newBatchLoaderEnvironment()
+                .context(SecurityCtx.getCallingUserCtx()).build();
+
+        DataLoaderOptions options = DataLoaderOptions.newOptions()
+                .setBatchLoaderEnvironmentProvider(() -> batchLoaderEnvironment);
 
+        BatchLoaderWithContext<String, String> batchLoader = new BatchLoaderWithContext<String, String>() {
             @Override
             public CompletionStage<List<String>> load(List<String> keys, BatchLoaderEnvironment environment) {
                 SecurityCtx callCtx = environment.getContext();
                 return callDatabaseForResults(callCtx, keys);
             }
         };
 
-        BatchLoaderEnvironment batchLoaderEnvironment = BatchLoaderEnvironment.newBatchLoaderEnvironment()
-                .context(SecurityCtx.getCallingUserCtx()).build();
-
-        DataLoaderOptions options = DataLoaderOptions.newOptions()
-                .setBatchLoaderEnvironmentProvider(() -> batchLoaderEnvironment);
-        DataLoader<String, String> loader = new DataLoader<>(batchLoader, options);
+        DataLoader<String, String> loader = DataLoader.newDataLoader(batchLoader, options);
 ```
 
 The batch loading code will now receive this environment object and it can be used to get context perhaps allowing it
@@ -214,7 +206,7 @@ For example, let's assume you want to load users from a database, you could prob
  Given say 10 user id keys you might only get 7 results back.  This can be more naturally represented in a map
  than in an order list of values when returning values from the batch loader function.
 
- You can use `org.dataloader.MapBatchLoader` for this purpose. 
+ You can use `org.dataloader.MappedBatchLoader` for this purpose. 
 
  When the map is processed by the `DataLoader` code, any keys that are missing in the map
  will be replaced with null values.  The semantics that the number of `DataLoader.load` requests
@@ -297,7 +289,7 @@ react to that, in a type safe manner.
 In certain uncommon cases, a DataLoader which does not cache may be desirable. 
 
 ```java
-    new DataLoader<String, User>(userBatchLoader, DataLoaderOptions.newOptions().setCachingEnabled(false));
+    DataLoader.newDataLoader(userBatchLoader, DataLoaderOptions.newOptions().setCachingEnabled(false));
 ``` 
 
 Calling the above will ensure that every call to `.load()` will produce a new promise, and requested keys will not be saved in memory.
@@ -391,7 +383,7 @@ However you can create your own custom cache and supply it to the data loader on
 ```java
         MyCustomCache customCache = new MyCustomCache();
         DataLoaderOptions options = DataLoaderOptions.newOptions().setCacheMap(customCache);
-        new DataLoader<String, User>(userBatchLoader, options);
+        DataLoader.newDataLoader(userBatchLoader, options);
 ```
 
 You could choose to use one of the fancy cache implementations from Guava or Kaffeine and wrap it in a `CacheMap` wrapper ready

src/main/java/org/dataloader/BatchLoader.java

@@ -78,32 +78,12 @@ public interface BatchLoader<K, V> {
     /**
      * Called to batch load the provided keys and return a promise to a list of values.
      *
-     * If you need calling context then implement the {@link #load(java.util.List, BatchLoaderEnvironment)} method
-     * instead which is the preferred method.
+     * If you need calling context then implement {@link org.dataloader.BatchLoaderWithContext}
      *
      * @param keys the collection of keys to load
      *
      * @return a promise of the values for those keys
-     *
      */
     CompletionStage<List<V>> load(List<K> keys);
-
-    /**
-     * Called to batch load the provided keys and return a promise to a list of values.  This default
-     * version can be given an environment object to that maybe be useful during the call.  A typical use case
-     * is passing in security credentials or database connection details say.
-     *
-     * This method is implemented as a default method in order to preserve the API for previous
-     * callers.  It is always called first by the {@link org.dataloader.DataLoader} code and simply
-     * delegates to the {@link #load(java.util.List)} method.
-     *
-     * @param keys        the collection of keys to load
-     * @param environment an environment object that can help with the call
-     *
-     * @return a promise of the values for those keys
-     */
-    @SuppressWarnings({"unused", "deprecation"})
-    default CompletionStage<List<V>> load(List<K> keys, BatchLoaderEnvironment environment) {
-        return load(keys);
-    }
 }
+

src/main/java/org/dataloader/BatchLoaderWithContext.java

@@ -0,0 +1,26 @@
+package org.dataloader;
+
+import java.util.List;
+import java.util.concurrent.CompletionStage;
+
+/**
+ * This form of {@link org.dataloader.BatchLoader} is given a {@link org.dataloader.BatchLoaderEnvironment} object
+ * that encapsulates the calling context.  A typical use case is passing in security credentials or database connection details
+ * say.
+ *
+ * See {@link org.dataloader.BatchLoader} for more details on the design invariants that you must implement in order to
+ * use this interface.
+ */
+public interface BatchLoaderWithContext<K, V> {
+    /**
+     * Called to batch load the provided keys and return a promise to a list of values.  This default
+     * version can be given an environment object to that maybe be useful during the call.  A typical use case
+     * is passing in security credentials or database connection details say.
+     *
+     * @param keys        the collection of keys to load
+     * @param environment an environment object that can help with the call
+     *
+     * @return a promise of the values for those keys
+     */
+    CompletionStage<List<V>> load(List<K> keys, BatchLoaderEnvironment environment);
+}