Adds Feign.Builder.mapAndDecode() (OpenFeign#534)

odin-delrio · adriancole · commit 56c105df9efc · 2017-05-06T11:10:11.000+08:00
Adds `Feign.Builder.mapAndDecode()` to allow response preprocessing before decoding it
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,6 @@
+### Version 9.5
+* Adds `Feign.Builder.mapAndDecode()` to allow response preprocessing before decoding it.
+
 ### Version 9.4.1
 * 404 responses are no longer swallowed for `void` return types.
 
diff --git a/README.md b/README.md
@@ -187,6 +187,16 @@ GitHub github = Feign.builder()
                      .target(GitHub.class, "https://api.github.com");
 ```
 
+If you need to pre-process the response before give it to the Decoder, you can use the `mapAndDecode` builder method.
+An example use case is dealing with an API that only serves jsonp, you will maybe need to unwrap the jsonp before
+send it to the Json decoder of your choice:
+
+```java
+JsonpApi jsonpApi = Feign.builder()
+                         .mapAndDecode((response, type) -> jsopUnwrap(response, type), new GsonDecoder())
+                         .target(JsonpApi.class, "https://some-jsonp-api.com");
+```
+
 ### Encoders
 The simplest way to send a request body to a server is to define a `POST` method that has a `String` or `byte[]` parameter without any annotations on it. You will likely need to add a `Content-Type` header.
 
diff --git a/core/src/main/java/feign/Feign.java b/core/src/main/java/feign/Feign.java
@@ -15,6 +15,7 @@
  */
 package feign;
 
+import java.io.IOException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 import java.util.ArrayList;
@@ -143,6 +144,14 @@ public Builder decoder(Decoder decoder) {
       return this;
     }
 
+    /**
+     * Allows to map the response before passing it to the decoder.
+     */
+    public Builder mapAndDecode(ResponseMapper mapper, Decoder decoder) {
+      this.decoder = new ResponseMappingDecoder(mapper, decoder);
+      return this;
+    }
+
     /**
      * This flag indicates that the {@link #decoder(Decoder) decoder} should process responses with
      * 404 status, specifically returning null or empty instead of throwing {@link FeignException}.
@@ -219,4 +228,20 @@ public Feign build() {
       return new ReflectiveFeign(handlersByName, invocationHandlerFactory);
     }
   }
+
+  static class ResponseMappingDecoder implements Decoder {
+
+    private final ResponseMapper mapper;
+    private final Decoder delegate;
+
+    ResponseMappingDecoder(ResponseMapper mapper, Decoder decoder) {
+      this.mapper = mapper;
+      this.delegate = decoder;
+    }
+
+    @Override
+    public Object decode(Response response, Type type) throws IOException {
+      return delegate.decode(mapper.map(response, type), type);
+    }
+  }
 }
diff --git a/core/src/main/java/feign/ResponseMapper.java b/core/src/main/java/feign/ResponseMapper.java
@@ -0,0 +1,27 @@
+package feign;
+
+import java.lang.reflect.Type;
+
+/**
+ * Map function to apply to the response before decoding it.
+ *
+ * <pre>{@code
+ * new ResponseMapper() {
+ *      @Override
+ *      public Response map(Response response, Type type) {
+ *          try {
+ *            return response
+ *              .toBuilder()
+ *              .body(Util.toString(response.body().asReader()).toUpperCase().getBytes())
+ *              .build();
+ *          } catch (IOException e) {
+ *              throw new RuntimeException(e);
+ *          }
+ *      }
+ *  };
+ * }</pre>
+ */
+public interface ResponseMapper {
+
+  Response map(Response response, Type type);
+}
diff --git a/core/src/test/java/feign/FeignTest.java b/core/src/test/java/feign/FeignTest.java
@@ -24,6 +24,7 @@
 
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.LinkedHashMap;
 import okio.Buffer;
 import org.assertj.core.api.Fail;
@@ -50,6 +51,7 @@
 import feign.codec.Encoder;
 import feign.codec.ErrorDecoder;
 import feign.codec.StringDecoder;
+import feign.Feign.ResponseMappingDecoder;
 
 import static feign.Util.UTF_8;
 import static feign.assertj.MockWebServerAssertions.assertThat;
@@ -706,6 +708,49 @@ public void encodedQueryParam() throws Exception {
             .hasPath("/?trim=5.2FSi+");
   }
 
+  @Test
+  public void responseMapperIsAppliedBeforeDelegate() throws IOException {
+    ResponseMappingDecoder decoder = new ResponseMappingDecoder(upperCaseResponseMapper(), new StringDecoder());
+    String output = (String) decoder.decode(responseWithText("response"), String.class);
+
+    assertThat(output).isEqualTo("RESPONSE");
+  }
+
+  private ResponseMapper upperCaseResponseMapper() {
+    return new ResponseMapper() {
+      @Override
+      public Response map(Response response, Type type) {
+        try {
+          return response
+                  .toBuilder()
+                  .body(Util.toString(response.body().asReader()).toUpperCase().getBytes())
+                  .build();
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+      }
+    };
+  }
+
+  private Response responseWithText(String text) {
+    return Response.builder()
+            .body(text, Util.UTF_8)
+            .status(200)
+            .headers(new HashMap<String, Collection<String>>())
+            .build();
+  }
+
+  @Test
+  public void mapAndDecodeExecutesMapFunction() {
+    server.enqueue(new MockResponse().setBody("response!"));
+
+    TestInterface api = new Feign.Builder()
+            .mapAndDecode(upperCaseResponseMapper(), new StringDecoder())
+            .target(TestInterface.class, "http://localhost:" + server.getPort());
+
+    assertEquals(api.post(), "RESPONSE!");
+  }
+
   interface TestInterface {
 
     @RequestLine("POST /")
diff --git a/hystrix/src/main/java/feign/hystrix/HystrixFeign.java b/hystrix/src/main/java/feign/hystrix/HystrixFeign.java
@@ -13,6 +13,7 @@
 import feign.Logger;
 import feign.Request;
 import feign.RequestInterceptor;
+import feign.ResponseMapper;
 import feign.Retryer;
 import feign.Target;
 import feign.codec.Decoder;
@@ -164,6 +165,11 @@ public Builder decoder(Decoder decoder) {
       return (Builder) super.decoder(decoder);
     }
 
+    @Override
+    public Builder mapAndDecode(ResponseMapper mapper, Decoder decoder) {
+      return (Builder) super.mapAndDecode(mapper, decoder);
+    }
+
     @Override
     public Builder decode404() {
       return (Builder) super.decode404();
