Initial refactoring for Java 8 requirement

failsafe-lib · Dec 25, 2018 · 70e544d · 70e544d
1 parent 5d919d5
commit 70e544d
Show file tree

Hide file tree

Showing 24 changed files with 856 additions and 735 deletions.
diff --git a/README-1x.md b/README-1x.md
diff --git a/README.md b/README.md
@@ -10,7 +10,7 @@
 
 ## Introduction
 
-Failsafe is a lightweight, zero-dependency library for handling failures. It was designed to be as easy to use as possible, with a concise API for handling everyday use cases and the flexibility to handle everything else. Failsafe features:
+Failsafe is a lightweight, zero-dependency library for handling failures for Java 8+. It was designed to be as easy to use as possible, with a concise API for handling everyday use cases and the flexibility to handle everything else. Failsafe features:
 
 * [Retries](#retries)
 * [Circuit breakers](#circuit-breakers)
@@ -21,8 +21,6 @@ Failsafe is a lightweight, zero-dependency library for handling failures. It was
 * [CompletableFuture](#completablefuture-integration) and [functional interface](#functional-interface-integration) integration
 * [Execution tracking](#execution-tracking)
 
-Supports Java 6+ though the documentation uses lambdas for simplicity.
-
 ## Setup
 
 Add the latest [Failsafe Maven dependency][maven] to your project.
@@ -50,16 +48,6 @@ Failsafe.with(retryPolicy).run(() -> connect());
 Connection connection = Failsafe.with(retryPolicy).get(() -> connect());
 ```
 
-Java 6 and 7 are also supported:
-
-```java
-Connection connection = Failsafe.with(retryPolicy).get(new Callable<Connection>() {
-  public Connection call() {
-    return connect();
-  }
-});
-```
-
 #### Retry Policies
 
 Failsafe's [retry policies][RetryPolicy] provide flexibility in allowing you to express when retries should be performed.
@@ -255,6 +243,7 @@ breaker.close();
 
 if (breaker.allowsExecution()) {
   try {
+    breaker.preExecute();
     doSomething();
     breaker.recordSuccess();
   } catch (Exception e) {
@@ -353,17 +342,6 @@ Failsafe.with(retryPolicy)
   .get(this::connect);
 ```
 
-Java 6 and 7 users can extend the [Listeners] class and override individual event handlers:
-
-```java
-Failsafe.with(retryPolicy)
-  .with(new Listeners<Connection>() {
-    public void onRetry(Connection cxn, Throwable failure, ExecutionContext ctx) {
-      log.warn("Failure #{}. Retrying.", ctx.getExecutions());
-    }
-  }).get(() -> connect());
-```
-
 [CircuitBreaker] related event listeners can also be registered:
 
 ```java
@@ -389,7 +367,7 @@ Failsafe can also perform asynchronous executions and retries on 3rd party sched
 
 #### CompletableFuture Integration
 
-Java 8 users can use Failsafe to retry [CompletableFuture] or [CompletionStage] calls:
+Failsafe can be used to retry [CompletableFuture] or [CompletionStage] calls:
 
 ```java
 Failsafe.with(retryPolicy)
@@ -401,7 +379,7 @@ Failsafe.with(retryPolicy)
 
 #### Functional Interface Integration
 
-Failsafe can be used to create retryable Java 8 functional interfaces:
+Failsafe can be used to create retryable functional interfaces:
 
 ```java
 Function<String, Connection> connect = address -> Failsafe.with(retryPolicy).get(() -> connect(address));

diff --git a/pom.xml b/pom.xml
@@ -14,11 +14,6 @@
   <name>Failsafe</name>
   <url>http://github.com/jhalterman/failsafe/</url>
 
-  <properties>
-    <devCompileVersion>1.8</devCompileVersion>
-    <releaseCompileVersion>1.6</releaseCompileVersion>
-  </properties>
-
   <licenses>
     <license>
       <name>Apache License, Version 2.0</name>
@@ -89,8 +84,8 @@
         <artifactId>maven-compiler-plugin</artifactId>
         <version>3.2</version>
         <configuration>
-          <source>${devCompileVersion}</source>
-          <target>${devCompileVersion}</target>
+          <source>1.8</source>
+          <target>1.8</target>
         </configuration>
       </plugin>
       <plugin>
@@ -188,22 +183,6 @@
       <id>release</id>
       <build>
         <plugins>
-          <plugin>
-            <groupId>org.apache.maven.plugins</groupId>
-            <artifactId>maven-compiler-plugin</artifactId>
-            <version>3.2</version>
-            <executions>
-              <execution>
-                <id>default-compile</id>
-                <configuration>
-                  <compilerArguments>
-                    <source>${releaseCompileVersion}</source>
-                    <target>${releaseCompileVersion}</target>
-                  </compilerArguments>
-                </configuration>
-              </execution>
-            </executions>
-          </plugin>
           <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-source-plugin</artifactId>

diff --git a/src/main/java/net/jodah/failsafe/AbstractExecution.java b/src/main/java/net/jodah/failsafe/AbstractExecution.java
@@ -25,9 +25,8 @@
 import java.util.concurrent.TimeUnit;
 
 public abstract class AbstractExecution extends ExecutionContext {
-  final FailsafeConfig<Object, ?> config;
   final EventHandler<Object> eventHandler;
-  final Callable<Object> callable;
+  Callable<Object> callable;
 
   // Internally mutable state
   volatile Object lastResult;
@@ -41,20 +40,11 @@ public abstract class AbstractExecution extends ExecutionContext {
   volatile boolean completed;
   volatile boolean success;
 
-  /**
-   * Creates a new standalone AbstractExecution for the {@code config}.
-   */
-  AbstractExecution(FailsafeConfig<Object, ?> config) {
-    this(null, config);
-  }
-
   /**
    * Creates a new AbstractExecution for the {@code callable} and {@code config}.
    */
-  AbstractExecution(Callable<Object> callable, FailsafeConfig<Object, ?> config) {
+  AbstractExecution(FailsafeConfig<Object, ?> config) {
     super(new Duration(System.nanoTime(), TimeUnit.NANOSECONDS));
-    this.config = config;
-    this.callable = callable;
     eventHandler = config.eventHandler;
 
     PolicyExecutor next = null;
@@ -76,8 +66,9 @@ public abstract class AbstractExecution extends ExecutionContext {
     head = next;
   }
 
-  void addPolicy(FailsafePolicy policy) {
-    head = buildPolicyExecutor(policy, head);
+  @SuppressWarnings("unchecked")
+  void inject(Callable<?> callable) {
+    this.callable = (Callable<Object>) callable;
   }
 
   private PolicyExecutor buildPolicyExecutor(FailsafePolicy policy, PolicyExecutor next) {

diff --git a/src/main/java/net/jodah/failsafe/AsyncExecution.java b/src/main/java/net/jodah/failsafe/AsyncExecution.java
@@ -33,13 +33,17 @@ public final class AsyncExecution extends AbstractExecution {
   private volatile boolean retryCalled;
 
   @SuppressWarnings("unchecked")
-  <T> AsyncExecution(Callable<T> callable, Scheduler scheduler, FailsafeFuture<T> future,
-      FailsafeConfig<Object, ?> config) {
-    super((Callable<Object>) callable, config);
+  <T> AsyncExecution(Scheduler scheduler, FailsafeFuture<T> future, FailsafeConfig<?, ?> config) {
+    super((FailsafeConfig<Object, ?>) config);
     this.scheduler = scheduler;
     this.future = (FailsafeFuture<Object>) future;
   }
 
+  <T> AsyncExecution(Callable<T> callable, Scheduler scheduler, FailsafeFuture<T> future, FailsafeConfig<?, ?> config) {
+    this(scheduler, future, config);
+    inject(callable);
+  }
+
   /**
    * Completes the execution and the associated {@code FutureResult}.
    *