Add support for multiple ResponseInterceptors

core/src/main/java/feign/AsyncFeign.java

@@ -14,8 +14,8 @@
 package feign;
 
 import feign.InvocationHandlerFactory.MethodHandler;
-import feign.ReflectiveFeign.ParseHandlersByName;
 import feign.Logger.Level;
+import feign.ReflectiveFeign.ParseHandlersByName;
 import feign.Request.Options;
 import feign.Target.HardCodedTarget;
 import feign.codec.Decoder;
@@ -197,7 +197,7 @@ public AsyncFeign<C> build() {
                   decoder,
                   errorDecoder,
                   dismiss404,
-                  closeAfterDecode, responseInterceptor),
+                  closeAfterDecode, executionChain()),
               AsyncResponseHandler.class,
               capabilities);
 

core/src/main/java/feign/AsyncResponseHandler.java

@@ -27,13 +27,10 @@
 class AsyncResponseHandler {
   private final ResponseHandler responseHandler;
 
-  AsyncResponseHandler(Level logLevel, Logger logger, Decoder decoder,
-      ErrorDecoder errorDecoder, boolean dismiss404, boolean closeAfterDecode,
-      ResponseInterceptor responseInterceptor) {
-    this.responseHandler = new ResponseHandler(
-        logLevel, logger, decoder,
-        errorDecoder, dismiss404, closeAfterDecode,
-        responseInterceptor);
+  AsyncResponseHandler(Level logLevel, Logger logger, Decoder decoder, ErrorDecoder errorDecoder,
+      boolean dismiss404, boolean closeAfterDecode, ResponseInterceptor.Chain executionChain) {
+    this.responseHandler = new ResponseHandler(logLevel, logger, decoder, errorDecoder, dismiss404,
+        closeAfterDecode, executionChain);
   }
 
   public CompletableFuture<Object> handleResponse(String configKey,

core/src/main/java/feign/BaseBuilder.java

@@ -35,7 +35,7 @@ public abstract class BaseBuilder<B extends BaseBuilder<B>> {
 
   protected final List<RequestInterceptor> requestInterceptors =
       new ArrayList<>();
-  protected ResponseInterceptor responseInterceptor = ResponseInterceptor.DEFAULT;
+  protected final List<ResponseInterceptor> responseInterceptors = new ArrayList<>();
   protected Logger.Level logLevel = Logger.Level.NONE;
   protected Contract contract = new Contract.Default();
   protected Retryer retryer = new Retryer.Default();
@@ -197,11 +197,23 @@ public B requestInterceptors(Iterable<RequestInterceptor> requestInterceptors) {
     return thisB;
   }
 
+  /**
+   * Sets the full set of request interceptors for the builder, overwriting any previous
+   * interceptors.
+   */
+  public B responseInterceptors(Iterable<ResponseInterceptor> responseInterceptors) {
+    this.responseInterceptors.clear();
+    for (ResponseInterceptor responseInterceptor : responseInterceptors) {
+      this.responseInterceptors.add(responseInterceptor);
+    }
+    return thisB;
+  }
+
   /**
    * Adds a single response interceptor to the builder.
    */
   public B responseInterceptor(ResponseInterceptor responseInterceptor) {
-    this.responseInterceptor = responseInterceptor;
+    this.responseInterceptors.add(responseInterceptor);
     return thisB;
   }
 
@@ -269,5 +281,19 @@ List<Field> getFieldsToEnrich() {
         .collect(Collectors.toList());
   }
 
+  protected ResponseInterceptor.Chain executionChain() {
+    ResponseInterceptor.Chain endOfChain =
+        ResponseInterceptor.Chain.DEFAULT;
+
+    ResponseInterceptor.Chain executionChain = this.responseInterceptors.stream()
+        .reduce(ResponseInterceptor::andThen)
+        .map(interceptor -> interceptor.apply(endOfChain))
+        .orElse(endOfChain);
+
+    return (ResponseInterceptor.Chain) Capability.enrich(executionChain,
+        ResponseInterceptor.Chain.class, capabilities);
+
+  }
+
 
 }

core/src/main/java/feign/Capability.java

@@ -90,6 +90,10 @@ default ResponseInterceptor enrich(ResponseInterceptor responseInterceptor) {
     return responseInterceptor;
   }
 
+  default ResponseInterceptor.Chain enrich(ResponseInterceptor.Chain chain) {
+    return chain;
+  }
+
   default Logger enrich(Logger logger) {
     return logger;
   }

core/src/main/java/feign/Feign.java

@@ -13,13 +13,13 @@
  */
 package feign;
 
+import feign.InvocationHandlerFactory.MethodHandler;
 import feign.ReflectiveFeign.ParseHandlersByName;
 import feign.Request.Options;
 import feign.Target.HardCodedTarget;
 import feign.codec.Decoder;
 import feign.codec.Encoder;
 import feign.codec.ErrorDecoder;
-import feign.InvocationHandlerFactory.MethodHandler;
 import java.io.IOException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
@@ -202,7 +202,7 @@ public Feign build() {
 
       MethodHandler.Factory<Object> synchronousMethodHandlerFactory =
           new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors,
-              responseInterceptor, logger, logLevel, dismiss404, closeAfterDecode,
+              executionChain(), logger, logLevel, dismiss404, closeAfterDecode,
               propagationPolicy, options, decoder, errorDecoder);
       ParseHandlersByName<Object> handlersByName =
           new ParseHandlersByName<>(contract, encoder, queryMapEncoder,

core/src/main/java/feign/ResponseHandler.java

@@ -13,13 +13,13 @@
  */
 package feign;
 
+import static feign.FeignException.errorReading;
+import static feign.Util.ensureClosed;
 import feign.Logger.Level;
 import feign.codec.Decoder;
 import feign.codec.ErrorDecoder;
 import java.io.IOException;
 import java.lang.reflect.Type;
-import static feign.FeignException.errorReading;
-import static feign.Util.ensureClosed;
 
 /**
  * The response handler that is used to provide synchronous support on top of standard response
@@ -37,19 +37,18 @@ public class ResponseHandler {
   private final boolean dismiss404;
   private final boolean closeAfterDecode;
 
-  private final ResponseInterceptor responseInterceptor;
+  private final ResponseInterceptor.Chain executionChain;
 
-  public ResponseHandler(Level logLevel, Logger logger, Decoder decoder,
-      ErrorDecoder errorDecoder, boolean dismiss404, boolean closeAfterDecode,
-      ResponseInterceptor responseInterceptor) {
+  public ResponseHandler(Level logLevel, Logger logger, Decoder decoder, ErrorDecoder errorDecoder,
+      boolean dismiss404, boolean closeAfterDecode, ResponseInterceptor.Chain executionChain) {
     super();
     this.logLevel = logLevel;
     this.logger = logger;
     this.decoder = decoder;
     this.errorDecoder = errorDecoder;
     this.dismiss404 = dismiss404;
     this.closeAfterDecode = closeAfterDecode;
-    this.responseInterceptor = responseInterceptor;
+    this.executionChain = executionChain;
   }
 
   public Object handleResponse(String configKey,
@@ -119,8 +118,8 @@ private Object decode(Response response, Type type) throws IOException {
     }
 
     try {
-      final Object result = responseInterceptor.aroundDecode(
-          new InvocationContext(decoder, type, response));
+      final Object result = executionChain.next(
+          new ResponseInterceptor.Context(decoder, type, response));
       if (closeAfterDecode) {
         ensureClosed(response.body());
       }

core/src/main/java/feign/ResponseInterceptor.java

@@ -13,26 +13,101 @@
  */
 package feign;
 
+import static feign.FeignException.errorReading;
+import feign.codec.DecodeException;
+import feign.codec.Decoder;
 import java.io.IOException;
+import java.lang.reflect.Type;
 import java.util.function.Function;
 
 /**
- * Zero or One {@code ResponseInterceptor} may be configured for purposes such as verify or modify
- * headers of response, verify the business status of decoded object. Once interceptors are applied,
- * {@link ResponseInterceptor#aroundDecode(Response, Function)} is called around decode method
- * called
+ * Interceptor for purposes such as verify or modify headers of response, verify the business status
+ * of decoded object. Once interceptors are applied,
+ * {@link ResponseInterceptor#intercept(Response, Function)} is called around decode method called
  */
 public interface ResponseInterceptor {
 
-  ResponseInterceptor DEFAULT = InvocationContext::proceed;
-
   /**
-   * Called for response around decode, must either manually invoke
-   * {@link InvocationContext#proceed} or manually create a new response object
+   * Called for response around decode, must either manually invoke {@link Chain#next(Context)} or
+   * manually create a new response object
    *
    * @param invocationContext information surrounding the response been decoded
    * @return decoded response
    */
-  Object aroundDecode(InvocationContext invocationContext) throws IOException;
+  Object intercept(Context context, Chain chain) throws IOException;
+
+  /**
+   * Return a new {@link ResponseInterceptor} that invokes the current interceptor first and then
+   * the one that is passed in.
+   * 
+   * @param nextInterceptor the interceptor to delegate to after the current
+   * @return a new interceptor that chains the two
+   */
+  default ResponseInterceptor andThen(ResponseInterceptor nextInterceptor) {
+    return (ic, chain) -> intercept(ic,
+        nextContext -> nextInterceptor.intercept(nextContext, chain));
+  }
+
+  /**
+   * Contract for delegation to the rest of the chain.
+   */
+  public interface Chain {
+    Chain DEFAULT = ic -> {
+      try {
+        return ic.decoder().decode(ic.response(), ic.returnType());
+      } catch (final FeignException e) {
+        throw e;
+      } catch (final RuntimeException e) {
+        throw new DecodeException(ic.response().status(), e.getMessage(),
+            ic.response().request(), e);
+      } catch (IOException e) {
+        throw errorReading(ic.response().request(), ic.response(), e);
+      }
+    };
+
+    /**
+     * Delegate to the rest of the chain to execute the request.
+     * 
+     * @param context the request to execute the {@link Chain} .
+     * @return the response
+     */
+    Object next(Context context) throws IOException;
+  }
+
+  /**
+   * Apply this interceptor to the given {@code Chain} resulting in an intercepted chain.
+   * 
+   * @param chain the chain to add interception around
+   * @return a new chain instance
+   */
+  default Chain apply(Chain chain) {
+    return request -> intercept(request, chain);
+  }
+
+  public class Context {
+
+    private final Decoder decoder;
+    private final Type returnType;
+    private final Response response;
+
+    Context(Decoder decoder, Type returnType, Response response) {
+      this.decoder = decoder;
+      this.returnType = returnType;
+      this.response = response;
+    }
+
+    public Decoder decoder() {
+      return decoder;
+    }
+
+    public Type returnType() {
+      return returnType;
+    }
+
+    public Response response() {
+      return response;
+    }
+
+  }
 
 }