1616package feign;
1717
1818import java.io.IOException;
19- import java.lang.reflect.Type;
2019
2120import javax.inject.Inject;
2221import javax.inject.Provider;
3029import static feign.Util.checkNotNull;
3130import static feign.Util.ensureClosed;
3231
33- final class MethodHandler {
32+ abstract class MethodHandler {
3433
3534 /**
3635 * Those using guava will implement as {@code Function<Object[], RequestTemplate>}.
@@ -53,33 +52,48 @@ static class Factory {
5352
5453 public MethodHandler create(Target<?> target, MethodMetadata md,
5554 BuildTemplateFromArgs buildTemplateFromArgs, Options options, Decoder decoder, ErrorDecoder errorDecoder) {
56- return new MethodHandler (target, client, retryer, wire, md, buildTemplateFromArgs, options, decoder, errorDecoder);
55+ return new SynchronousMethodHandler (target, client, retryer, wire, md, buildTemplateFromArgs, options, decoder, errorDecoder);
5756 }
5857 }
5958
60- private final MethodMetadata metadata;
61- private final Target<?> target;
62- private final Client client;
63- private final Provider<Retryer> retryer;
64- private final Wire wire;
65-
66- private final BuildTemplateFromArgs buildTemplateFromArgs;
67- private final Options options;
68- private final Decoder decoder;
69- private final ErrorDecoder errorDecoder;
70-
71- // cannot inject wildcards in dagger
72- @SuppressWarnings("rawtypes")
73- private MethodHandler(Target target, Client client, Provider<Retryer> retryer, Wire wire, MethodMetadata metadata,
74- BuildTemplateFromArgs buildTemplateFromArgs, Options options, Decoder decoder, ErrorDecoder errorDecoder) {
59+ static final class SynchronousMethodHandler extends MethodHandler {
60+ private final Decoder decoder;
61+
62+ private SynchronousMethodHandler(Target<?> target, Client client, Provider<Retryer> retryer, Wire wire, MethodMetadata metadata,
63+ BuildTemplateFromArgs buildTemplateFromArgs, Options options, Decoder decoder, ErrorDecoder errorDecoder) {
64+ super(target, client, retryer, wire, metadata, buildTemplateFromArgs, options, errorDecoder);
65+ this.decoder = checkNotNull(decoder, "decoder for %s", target);
66+ }
67+
68+ @Override protected Object decode(Object[] argv, Response response) throws Throwable {
69+ if (metadata.returnType().equals(Response.class)) {
70+ return response;
71+ } else if (metadata.returnType() == void.class) {
72+ return null;
73+ }
74+ return decoder.decode(metadata.configKey(), response, metadata.returnType());
75+ }
76+ }
77+
78+ protected final MethodMetadata metadata;
79+ protected final Target<?> target;
80+ protected final Client client;
81+ protected final Provider<Retryer> retryer;
82+ protected final Wire wire;
83+
84+ protected final BuildTemplateFromArgs buildTemplateFromArgs;
85+ protected final Options options;
86+ protected final ErrorDecoder errorDecoder;
87+
88+ private MethodHandler(Target<?> target, Client client, Provider<Retryer> retryer, Wire wire, MethodMetadata metadata,
89+ BuildTemplateFromArgs buildTemplateFromArgs, Options options, ErrorDecoder errorDecoder) {
7590 this.target = checkNotNull(target, "target");
7691 this.client = checkNotNull(client, "client for %s", target);
7792 this.retryer = checkNotNull(retryer, "retryer for %s", target);
7893 this.wire = checkNotNull(wire, "wire for %s", target);
7994 this.metadata = checkNotNull(metadata, "metadata for %s", target);
8095 this.buildTemplateFromArgs = checkNotNull(buildTemplateFromArgs, "metadata for %s", target);
8196 this.options = checkNotNull(options, "options for %s", target);
82- this.decoder = checkNotNull(decoder, "decoder for %s", target);
8397 this.errorDecoder = checkNotNull(errorDecoder, "errorDecoder for %s", target);
8498 }
8599
@@ -88,45 +102,38 @@ public Object invoke(Object[] argv) throws Throwable {
88102 Retryer retryer = this.retryer.get();
89103 while (true) {
90104 try {
91- return executeAndDecode(metadata.configKey() , template, metadata.returnType() );
105+ return executeAndDecode(argv , template);
92106 } catch (RetryableException e) {
93107 retryer.continueOrPropagate(e);
94108 continue;
95109 }
96110 }
97111 }
98112
99- public Object executeAndDecode(String configKey , RequestTemplate template, Type returnType )
113+ public Object executeAndDecode(Object[] argv , RequestTemplate template)
100114 throws Throwable {
101115 // create the request from a mutable copy of the input template.
102116 Request request = target.apply(new RequestTemplate(template));
103117 wire.wireRequest(target, request);
104- Response response = execute(request);
118+ Response response;
119+ try {
120+ response = client.execute(request, options);
121+ } catch (IOException e) {
122+ throw errorExecuting(request, e);
123+ }
105124 try {
106125 response = wire.wireAndRebufferResponse(target, response);
107126 if (response.status() >= 200 && response.status() < 300) {
108- if (returnType.equals(Response.class)) {
109- return response;
110- } else if (returnType == void.class) {
111- return null;
112- }
113- return decoder.decode(configKey, response, returnType);
127+ return decode(argv, response);
114128 } else {
115- throw errorDecoder.decode(configKey, response);
129+ throw errorDecoder.decode(metadata. configKey() , response);
116130 }
117- } catch (Throwable e) {
131+ } catch (IOException e) {
132+ throw errorReading(request, response, e);
133+ } finally {
118134 ensureClosed(response.body());
119- if (IOException.class.isInstance(e))
120- throw errorReading(request, response, IOException.class.cast(e));
121- throw e;
122135 }
123136 }
124137
125- private Response execute(Request request) {
126- try {
127- return client.execute(request, options);
128- } catch (IOException e) {
129- throw errorExecuting(request, e);
130- }
131- }
138+ protected abstract Object decode(Object[] argv, Response response) throws Throwable;
132139}
0 commit comments