Refactor method signature of MethodHandler.Factory.create

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

@@ -205,11 +205,10 @@ public AsyncFeign<C> build() {
           new AsynchronousMethodHandler.Factory<>(
               client, retryer, requestInterceptors,
               responseHandler, logger, logLevel,
-              propagationPolicy, methodInfoResolver);
+              propagationPolicy, methodInfoResolver,
+              options, decoder, errorDecoder);
       final ParseHandlersByName<C> handlersByName =
-          new ParseHandlersByName<>(contract, options, encoder,
-              decoder, queryMapEncoder,
-              errorDecoder, methodHandlerFactory);
+          new ParseHandlersByName<>(contract, encoder, queryMapEncoder, methodHandlerFactory);
       final ReflectiveFeign<C> feign =
           new ReflectiveFeign<>(handlersByName, invocationHandlerFactory, defaultContextSupplier);
       return new AsyncFeign<>(feign);

core/src/main/java/feign/AsynchronousMethodHandler.java

@@ -246,12 +246,18 @@ static class Factory<C> implements MethodHandler.Factory<C> {
     private final Logger.Level logLevel;
     private final ExceptionPropagationPolicy propagationPolicy;
     private final MethodInfoResolver methodInfoResolver;
+    private final Options options;
+    private final Decoder decoder;
+    private final ErrorDecoder errorDecoder;
 
     Factory(AsyncClient<C> client, Retryer retryer, List<RequestInterceptor> requestInterceptors,
         AsyncResponseHandler responseHandler,
         Logger logger, Logger.Level logLevel,
         ExceptionPropagationPolicy propagationPolicy,
-        MethodInfoResolver methodInfoResolver) {
+        MethodInfoResolver methodInfoResolver,
+        Options options,
+        Decoder decoder,
+        ErrorDecoder errorDecoder) {
       this.client = checkNotNull(client, "client");
       this.retryer = checkNotNull(retryer, "retryer");
       this.requestInterceptors = checkNotNull(requestInterceptors, "requestInterceptors");
@@ -260,14 +266,14 @@ static class Factory<C> implements MethodHandler.Factory<C> {
       this.logLevel = checkNotNull(logLevel, "logLevel");
       this.propagationPolicy = propagationPolicy;
       this.methodInfoResolver = methodInfoResolver;
+      this.options = checkNotNull(options, "options");
+      this.errorDecoder = checkNotNull(errorDecoder, "errorDecoder");
+      this.decoder = checkNotNull(decoder, "decoder");
     }
 
     public MethodHandler create(Target<?> target,
                                 MethodMetadata md,
                                 RequestTemplate.Factory buildTemplateFromArgs,
-                                Options options,
-                                Decoder decoder,
-                                ErrorDecoder errorDecoder,
                                 C requestContext) {
       return new AsynchronousMethodHandler<C>(target, client, retryer, requestInterceptors,
           logger, logLevel, md, buildTemplateFromArgs, options, responseHandler,

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

@@ -203,10 +203,10 @@ public Feign build() {
       MethodHandler.Factory<Object> synchronousMethodHandlerFactory =
           new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors,
               responseInterceptor, logger, logLevel, dismiss404, closeAfterDecode,
-              propagationPolicy);
+              propagationPolicy, options, decoder, errorDecoder);
       ParseHandlersByName<Object> handlersByName =
-          new ParseHandlersByName<>(contract, options, encoder, decoder, queryMapEncoder,
-              errorDecoder, synchronousMethodHandlerFactory);
+          new ParseHandlersByName<>(contract, encoder, queryMapEncoder,
+              synchronousMethodHandlerFactory);
       return new ReflectiveFeign<>(handlersByName, invocationHandlerFactory, () -> null);
     }
   }

core/src/main/java/feign/InvocationHandlerFactory.java

@@ -38,9 +38,6 @@ interface Factory<C> {
       MethodHandler create(Target<?> target,
                            MethodMetadata md,
                            RequestTemplate.Factory buildTemplateFromArgs,
-                           Request.Options options,
-                           Decoder decoder,
-                           ErrorDecoder errorDecoder,
                            C requestContext);
     }
   }

core/src/main/java/feign/ReflectiveFeign.java

@@ -26,7 +26,6 @@
 import java.util.concurrent.CompletableFuture;
 import feign.InvocationHandlerFactory.MethodHandler;
 import feign.Param.Expander;
-import feign.Request.Options;
 import feign.codec.*;
 import feign.template.UriUtils;
 
@@ -122,28 +121,19 @@ public String toString() {
   static final class ParseHandlersByName<C> {
 
     private final Contract contract;
-    private final Options options;
     private final Encoder encoder;
-    private final Decoder decoder;
-    private final ErrorDecoder errorDecoder;
     private final QueryMapEncoder queryMapEncoder;
     private final MethodHandler.Factory<C> factory;
 
     ParseHandlersByName(
         Contract contract,
-        Options options,
         Encoder encoder,
-        Decoder decoder,
         QueryMapEncoder queryMapEncoder,
-        ErrorDecoder errorDecoder,
         MethodHandler.Factory<C> factory) {
       this.contract = contract;
-      this.options = options;
       this.factory = factory;
-      this.errorDecoder = errorDecoder;
       this.queryMapEncoder = queryMapEncoder;
       this.encoder = checkNotNull(encoder, "encoder");
-      this.decoder = checkNotNull(decoder, "decoder");
     }
 
     public Map<Method, MethodHandler> apply(Target target, C requestContext) {
@@ -180,8 +170,7 @@ private MethodHandler createMethodHandler(final Target<?> target,
       }
 
       BuildTemplateByResolvingArgs buildTemplate = getBuildTemplate(target, md);
-      return factory.create(
-          target, md, buildTemplate, options, decoder, errorDecoder, requestContext);
+      return factory.create(target, md, buildTemplate, requestContext);
     }
 
     private BuildTemplateByResolvingArgs getBuildTemplate(Target target, MethodMetadata md) {

core/src/main/java/feign/SynchronousMethodHandler.java

@@ -150,11 +150,17 @@ static class Factory implements MethodHandler.Factory<Object> {
     private final boolean dismiss404;
     private final boolean closeAfterDecode;
     private final ExceptionPropagationPolicy propagationPolicy;
+    private final Options options;
+    private final Decoder decoder;
+    private final ErrorDecoder errorDecoder;
 
     Factory(Client client, Retryer retryer, List<RequestInterceptor> requestInterceptors,
         ResponseInterceptor responseInterceptor,
         Logger logger, Logger.Level logLevel, boolean dismiss404, boolean closeAfterDecode,
-        ExceptionPropagationPolicy propagationPolicy) {
+        ExceptionPropagationPolicy propagationPolicy,
+        Options options,
+        Decoder decoder,
+        ErrorDecoder errorDecoder) {
       this.client = checkNotNull(client, "client");
       this.retryer = checkNotNull(retryer, "retryer");
       this.requestInterceptors = checkNotNull(requestInterceptors, "requestInterceptors");
@@ -164,14 +170,14 @@ static class Factory implements MethodHandler.Factory<Object> {
       this.dismiss404 = dismiss404;
       this.closeAfterDecode = closeAfterDecode;
       this.propagationPolicy = propagationPolicy;
+      this.options = checkNotNull(options, "options");
+      this.errorDecoder = checkNotNull(errorDecoder, "errorDecoder");
+      this.decoder = checkNotNull(decoder, "decoder");
     }
 
     public MethodHandler create(Target<?> target,
                                 MethodMetadata md,
                                 RequestTemplate.Factory buildTemplateFromArgs,
-                                Options options,
-                                Decoder decoder,
-                                ErrorDecoder errorDecoder,
                                 Object requestContext) {
       return new SynchronousMethodHandler(target, client, retryer, requestInterceptors,
           responseInterceptor, logger, logLevel, md, buildTemplateFromArgs, options, decoder,