Feature/decoder interceptor to response interceptor

core/src/main/java/feign/InvocationContext.java

@@ -14,33 +14,32 @@
 package feign;
 
 import static feign.FeignException.errorReading;
+import static feign.Util.ensureClosed;
 import feign.codec.DecodeException;
 import feign.codec.Decoder;
+import feign.codec.ErrorDecoder;
 import java.io.IOException;
 import java.lang.reflect.Type;
 
 public class InvocationContext {
-
+  private static final long MAX_RESPONSE_BUFFER_SIZE = 8192L;
+  private final String configKey;
   private final Decoder decoder;
+  private final ErrorDecoder errorDecoder;
+  private final boolean dismiss404;
+  private final boolean closeAfterDecode;
   private final Type returnType;
   private final Response response;
 
-  InvocationContext(Decoder decoder, Type returnType, Response response) {
+  InvocationContext(String configKey, Decoder decoder, ErrorDecoder errorDecoder,
+      boolean dismiss404, boolean closeAfterDecode, Response response, Type returnType) {
+    this.configKey = configKey;
     this.decoder = decoder;
-    this.returnType = returnType;
+    this.errorDecoder = errorDecoder;
+    this.dismiss404 = dismiss404;
+    this.closeAfterDecode = closeAfterDecode;
     this.response = response;
-  }
-
-  public Object proceed() {
-    try {
-      return decoder.decode(response, returnType);
-    } catch (final FeignException e) {
-      throw e;
-    } catch (final RuntimeException e) {
-      throw new DecodeException(response.status(), e.getMessage(), response.request(), e);
-    } catch (IOException e) {
-      throw errorReading(response.request(), response, e);
-    }
+    this.returnType = returnType;
   }
 
   public Decoder decoder() {
@@ -55,4 +54,72 @@ public Response response() {
     return response;
   }
 
+  public Object proceed() throws Exception {
+    if (returnType == Response.class) {
+      return disconnectResponseBodyIfNeeded(response);
+    }
+
+    try {
+      final boolean shouldDecodeResponseBody =
+              (response.status() >= 200 && response.status() < 300) || (response.status() == 404 && dismiss404
+                      && !isVoidType(returnType));
+
+      if (!shouldDecodeResponseBody) {
+        throw decodeError(configKey, response);
+      }
+
+      if (isVoidType(returnType)) {
+        ensureClosed(response.body());
+        return null;
+      }
+
+      try {
+        return decoder.decode(response, returnType);
+      }
+      catch (final FeignException e) {
+        throw e;
+      }
+      catch (final RuntimeException e) {
+        throw new DecodeException(response.status(), e.getMessage(), response.request(), e);
+      }
+      catch (IOException e) {
+        throw errorReading(response.request(), response, e);
+      }
+    }
+    finally {
+      if (closeAfterDecode) {
+        ensureClosed(response.body());
+      }
+    }
+  }
+
+  private static Response disconnectResponseBodyIfNeeded(Response response) throws IOException {
+    final boolean shouldDisconnectResponseBody = response.body() != null
+        && response.body().length() != null
+        && response.body().length() <= MAX_RESPONSE_BUFFER_SIZE;
+    if (!shouldDisconnectResponseBody) {
+      return response;
+    }
+
+    try {
+      final byte[] bodyData = Util.toByteArray(response.body().asInputStream());
+      return response.toBuilder().body(bodyData).build();
+    } finally {
+      ensureClosed(response.body());
+    }
+  }
+
+  private Exception decodeError(String methodKey, Response response) {
+    try {
+      return errorDecoder.decode(methodKey, response);
+    } finally {
+      ensureClosed(response.body());
+    }
+  }
+
+  private boolean isVoidType(Type returnType) {
+    return returnType == Void.class
+        || returnType == void.class
+        || returnType.getTypeName().equals("kotlin.Unit");
+  }
 }

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

@@ -59,32 +59,20 @@ public Object handleResponse(String configKey,
       throws Exception {
     try {
       response = logAndRebufferResponseIfNeeded(configKey, response, elapsedTime);
-      if (returnType == Response.class) {
-        return disconnectResponseBodyIfNeeded(response);
-      }
-
-      final boolean shouldDecodeResponseBody = (response.status() >= 200 && response.status() < 300)
-          || (response.status() == 404 && dismiss404 && !isVoidType(returnType));
-
-      if (!shouldDecodeResponseBody) {
-        throw decodeError(configKey, response);
-      }
-
-      return decode(response, returnType);
+      return responseInterceptor.apply(
+          new InvocationContext(configKey, decoder, errorDecoder, dismiss404, closeAfterDecode, response,
+              returnType));
     } catch (final IOException e) {
       if (logLevel != Level.NONE) {
         logger.logIOException(configKey, logLevel, e, elapsedTime);
       }
       throw errorReading(response.request(), response, e);
+    } catch (Exception e) {
+      ensureClosed(response.body());
+      throw e;
     }
   }
 
-  private boolean isVoidType(Type returnType) {
-    return returnType == Void.class
-        || returnType == void.class
-        || returnType.getTypeName().equals("kotlin.Unit");
-  }
-
   private Response logAndRebufferResponseIfNeeded(String configKey,
                                                   Response response,
                                                   long elapsedTime)
@@ -95,47 +83,4 @@ private Response logAndRebufferResponseIfNeeded(String configKey,
 
     return logger.logAndRebufferResponse(configKey, logLevel, response, elapsedTime);
   }
-
-  private static Response disconnectResponseBodyIfNeeded(Response response) throws IOException {
-    final boolean shouldDisconnectResponseBody = response.body() != null
-        && response.body().length() != null
-        && response.body().length() <= MAX_RESPONSE_BUFFER_SIZE;
-    if (!shouldDisconnectResponseBody) {
-      return response;
-    }
-
-    try {
-      final byte[] bodyData = Util.toByteArray(response.body().asInputStream());
-      return response.toBuilder().body(bodyData).build();
-    } finally {
-      ensureClosed(response.body());
-    }
-  }
-
-  private Object decode(Response response, Type type) throws IOException {
-    if (isVoidType(type)) {
-      ensureClosed(response.body());
-      return null;
-    }
-
-    try {
-      final Object result = responseInterceptor.aroundDecode(
-          new InvocationContext(decoder, type, response));
-      if (closeAfterDecode) {
-        ensureClosed(response.body());
-      }
-      return result;
-    } catch (Exception e) {
-      ensureClosed(response.body());
-      throw e;
-    }
-  }
-
-  private Exception decodeError(String methodKey, Response response) {
-    try {
-      return errorDecoder.decode(methodKey, response);
-    } finally {
-      ensureClosed(response.body());
-    }
-  }
 }

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

@@ -27,12 +27,11 @@ 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 by {@link ResponseHandler} after refreshing the response and wrapped around the whole decode process,
+   * must either manually invoke {@link InvocationContext#proceed} or manually create a new response object
    *
-   * @param invocationContext information surrounding the response been decoded
+   * @param invocationContext information surrounding the response being decoded
    * @return decoded response
    */
-  Object aroundDecode(InvocationContext invocationContext) throws IOException;
-
+  Object apply(InvocationContext invocationContext) throws Exception;
 }