> headers() {
+ return headers;
+ }
+
+ /**
+ * The character set with which the body is encoded, or null if unknown or not applicable. When
+ * this is present, you can use {@code new String(req.body(), req.charset())} to access the body
+ * as a String.
+ */
+ public Charset charset() {
+ return charset;
+ }
+
+ /**
+ * If present, this is the replayable body to send to the server. In some cases, this may be
+ * interpretable as text.
+ *
+ * @see #charset()
+ */
+ public byte[] body() {
+ return body;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder builder = new StringBuilder();
+ builder.append(method).append(' ').append(url).append(" HTTP/1.1\n");
+ for (String field : headers.keySet()) {
+ for (String value : valuesOrEmpty(headers, field)) {
+ builder.append(field).append(": ").append(value).append('\n');
+ }
+ }
+ if (body != null) {
+ builder.append('\n').append(charset != null ? new String(body, charset) : "Binary data");
+ }
+ return builder.toString();
+ }
+
+ /* Controls the per-request settings currently required to be implemented by all {@link Client clients} */
+ public static class Options {
+
+ private final int connectTimeoutMillis;
+ private final int readTimeoutMillis;
+ private final boolean followRedirects;
+
+ public Options(int connectTimeoutMillis, int readTimeoutMillis, boolean followRedirects) {
+ this.connectTimeoutMillis = connectTimeoutMillis;
+ this.readTimeoutMillis = readTimeoutMillis;
+ this.followRedirects = followRedirects;
+ }
+
+ public Options(int connectTimeoutMillis, int readTimeoutMillis){
+ this(connectTimeoutMillis, readTimeoutMillis, true);
+ }
+
+ public Options() {
+ this(10 * 1000, 60 * 1000);
+ }
+
+ /**
+ * Defaults to 10 seconds. {@code 0} implies no timeout.
+ *
+ * @see java.net.HttpURLConnection#getConnectTimeout()
+ */
+ public int connectTimeoutMillis() {
+ return connectTimeoutMillis;
+ }
+
+ /**
+ * Defaults to 60 seconds. {@code 0} implies no timeout.
+ *
+ * @see java.net.HttpURLConnection#getReadTimeout()
+ */
+ public int readTimeoutMillis() {
+ return readTimeoutMillis;
+ }
+
+
+ /**
+ * Defaults to true. {@code false} tells the client to not follow the redirections.
+ *
+ * @see HttpURLConnection#getFollowRedirects()
+ */
+ public boolean isFollowRedirects() {
+ return followRedirects;
+ }
+ }
+}
diff --git a/core/src/main/java/feign/RequestInterceptor.java b/core/src/main/java/feign/RequestInterceptor.java
new file mode 100644
index 0000000000..8e8deb219b
--- /dev/null
+++ b/core/src/main/java/feign/RequestInterceptor.java
@@ -0,0 +1,42 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign;
+
+/**
+ * Zero or more {@code RequestInterceptors} may be configured for purposes such as adding headers to
+ * all requests. No guarantees are give with regards to the order that interceptors are applied.
+ * Once interceptors are applied, {@link Target#apply(RequestTemplate)} is called to create the
+ * immutable http request sent via {@link Client#execute(Request, feign.Request.Options)}.
+ * For example:
+ *
+ * public void apply(RequestTemplate input) {
+ * input.header("X-Auth", currentToken);
+ * }
+ *
+ *
Configuration
{@code RequestInterceptors} are configured via {@link
+ * Feign.Builder#requestInterceptors}.
Implementation notes
Do not add
+ * parameters, such as {@code /path/{foo}/bar } in your implementation of {@link
+ * #apply(RequestTemplate)}.
Interceptors are applied after the template's parameters are
+ * {@link RequestTemplate#resolve(java.util.Map) resolved}. This is to ensure that you can
+ * implement signatures are interceptors.
Relationship to Retrofit 1.x
+ * This class is similar to {@code RequestInterceptor.intercept()}, except that the implementation
+ * can read, remove, or otherwise mutate any part of the request template.
+ */
+public interface RequestInterceptor {
+
+ /**
+ * Called for every request. Add data using methods on the supplied {@link RequestTemplate}.
+ */
+ void apply(RequestTemplate template);
+}
diff --git a/core/src/main/java/feign/RequestLine.java b/core/src/main/java/feign/RequestLine.java
new file mode 100644
index 0000000000..076506c104
--- /dev/null
+++ b/core/src/main/java/feign/RequestLine.java
@@ -0,0 +1,65 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * Expands the request-line supplied in the {@code value}, permitting path and query variables, or
+ * just the http method.
+ *
+ * ...
+ * @RequestLine("POST /servers")
+ * ...
+ *
+ * @RequestLine("GET /servers/{serverId}?count={count}")
+ * void get(@Param("serverId") String serverId, @Param("count") int count);
+ * ...
+ *
+ * @RequestLine("GET")
+ * Response getNext(URI nextLink);
+ * ...
+ *
+ * HTTP version suffix is optional, but permitted. There are no guarantees this version will impact
+ * that sent by the client.
+ *
+ * @RequestLine("POST /servers HTTP/1.1")
+ * ...
+ *
+ *
Note: Query params do not overwrite each other. All queries with the same
+ * name will be included in the request.
Relationship to JAXRS
The following
+ * two forms are identical.
Feign:
+ *
+ * @RequestLine("GET /servers/{serverId}?count={count}")
+ * void get(@Param("serverId") String serverId, @Param("count") int count);
+ * ...
+ *
+ *
JAX-RS:
+ *
+ * @GET @Path("/servers/{serverId}")
+ * void get(@PathParam("serverId") String serverId, @QueryParam("count") int count);
+ * ...
+ *
+ */
+@java.lang.annotation.Target(METHOD)
+@Retention(RUNTIME)
+public @interface RequestLine {
+
+ String value();
+ boolean decodeSlash() default true;
+ CollectionFormat collectionFormat() default CollectionFormat.EXPLODED;
+}
diff --git a/core/src/main/java/feign/RequestTemplate.java b/core/src/main/java/feign/RequestTemplate.java
new file mode 100644
index 0000000000..35752bbd7e
--- /dev/null
+++ b/core/src/main/java/feign/RequestTemplate.java
@@ -0,0 +1,683 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign;
+
+import java.io.Serializable;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import static feign.Util.CONTENT_LENGTH;
+import static feign.Util.UTF_8;
+import static feign.Util.checkArgument;
+import static feign.Util.checkNotNull;
+import static feign.Util.emptyToNull;
+import static feign.Util.toArray;
+import static feign.Util.valuesOrEmpty;
+
+/**
+ * Builds a request to an http target. Not thread safe.
relationship to JAXRS
+ * 2.0
A combination of {@code javax.ws.rs.client.WebTarget} and {@code
+ * javax.ws.rs.client.Invocation.Builder}, ensuring you can modify any part of the request. However,
+ * this object is mutable, so needs to be guarded with the copy constructor.
+ */
+public final class RequestTemplate implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+ private final Map> queries =
+ new LinkedHashMap>();
+ private final Map> headers =
+ new LinkedHashMap>();
+ private String method;
+ /* final to encourage mutable use vs replacing the object. */
+ private StringBuilder url = new StringBuilder();
+ private transient Charset charset;
+ private byte[] body;
+ private String bodyTemplate;
+ private boolean decodeSlash = true;
+ private CollectionFormat collectionFormat = CollectionFormat.EXPLODED;
+
+ public RequestTemplate() {
+ }
+
+ /* Copy constructor. Use this when making templates. */
+ public RequestTemplate(RequestTemplate toCopy) {
+ checkNotNull(toCopy, "toCopy");
+ this.method = toCopy.method;
+ this.url.append(toCopy.url);
+ this.queries.putAll(toCopy.queries);
+ this.headers.putAll(toCopy.headers);
+ this.charset = toCopy.charset;
+ this.body = toCopy.body;
+ this.bodyTemplate = toCopy.bodyTemplate;
+ this.decodeSlash = toCopy.decodeSlash;
+ this.collectionFormat = toCopy.collectionFormat;
+ }
+
+ private static String urlDecode(String arg) {
+ try {
+ return URLDecoder.decode(arg, UTF_8.name());
+ } catch (UnsupportedEncodingException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ static String urlEncode(Object arg) {
+ try {
+ return URLEncoder.encode(String.valueOf(arg), UTF_8.name());
+ } catch (UnsupportedEncodingException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private static boolean isHttpUrl(CharSequence value) {
+ return value.length() >= 4 && value.subSequence(0, 3).equals("http".substring(0, 3));
+ }
+
+ private static CharSequence removeTrailingSlash(CharSequence charSequence) {
+ if (charSequence != null && charSequence.length() > 0 && charSequence.charAt(charSequence.length() - 1) == '/') {
+ return charSequence.subSequence(0, charSequence.length() - 1);
+ } else {
+ return charSequence;
+ }
+ }
+
+ /**
+ * Expands a {@code template}, such as {@code username}, using the {@code variables} supplied. Any
+ * unresolved parameters will remain.
Note that if you'd like curly braces literally in the
+ * {@code template}, urlencode them first.
+ *
+ * @param template URI template that can be in level 1 RFC6570
+ * form.
+ * @param variables to the URI template
+ * @return expanded template, leaving any unresolved parameters literal
+ */
+ public static String expand(String template, Map variables) {
+ // skip expansion if there's no valid variables set. ex. {a} is the
+ // first valid
+ if (checkNotNull(template, "template").length() < 3) {
+ return template;
+ }
+ checkNotNull(variables, "variables for %s", template);
+
+ boolean inVar = false;
+ StringBuilder var = new StringBuilder();
+ StringBuilder builder = new StringBuilder();
+ for (char c : template.toCharArray()) {
+ switch (c) {
+ case '{':
+ if (inVar) {
+ // '{{' is an escape: write the brace and don't interpret as a variable
+ builder.append("{");
+ inVar = false;
+ break;
+ }
+ inVar = true;
+ break;
+ case '}':
+ if (!inVar) { // then write the brace literally
+ builder.append('}');
+ break;
+ }
+ inVar = false;
+ String key = var.toString();
+ Object value = variables.get(var.toString());
+ if (value != null) {
+ builder.append(value);
+ } else {
+ builder.append('{').append(key).append('}');
+ }
+ var = new StringBuilder();
+ break;
+ default:
+ if (inVar) {
+ var.append(c);
+ } else {
+ builder.append(c);
+ }
+ }
+ }
+ return builder.toString();
+ }
+
+ private static Map> parseAndDecodeQueries(String queryLine) {
+ Map> map = new LinkedHashMap>();
+ if (emptyToNull(queryLine) == null) {
+ return map;
+ }
+ if (queryLine.indexOf('&') == -1) {
+ putKV(queryLine, map);
+ } else {
+ char[] chars = queryLine.toCharArray();
+ int start = 0;
+ int i = 0;
+ for (; i < chars.length; i++) {
+ if (chars[i] == '&') {
+ putKV(queryLine.substring(start, i), map);
+ start = i + 1;
+ }
+ }
+ putKV(queryLine.substring(start, i), map);
+ }
+ return map;
+ }
+
+ private static void putKV(String stringToParse, Map> map) {
+ String key;
+ String value;
+ // note that '=' can be a valid part of the value
+ int firstEq = stringToParse.indexOf('=');
+ if (firstEq == -1) {
+ key = urlDecode(stringToParse);
+ value = null;
+ } else {
+ key = urlDecode(stringToParse.substring(0, firstEq));
+ value = urlDecode(stringToParse.substring(firstEq + 1));
+ }
+ Collection values = map.containsKey(key) ? map.get(key) : new ArrayList();
+ values.add(value);
+ map.put(key, values);
+ }
+
+ /** {@link #resolve(Map, Map)}, which assumes no parameter is encoded */
+ public RequestTemplate resolve(Map unencoded) {
+ return resolve(unencoded, Collections.emptyMap());
+ }
+
+ /**
+ * Resolves any template parameters in the requests path, query, or headers against the supplied
+ * unencoded arguments.
relationship to JAXRS 2.0
This call is
+ * similar to {@code javax.ws.rs.client.WebTarget.resolveTemplates(templateValues, true)} , except
+ * that the template values apply to any part of the request, not just the URL
+ */
+ RequestTemplate resolve(Map unencoded, Map alreadyEncoded) {
+ replaceQueryValues(unencoded, alreadyEncoded);
+ Map encoded = new LinkedHashMap();
+ for (Entry entry : unencoded.entrySet()) {
+ final String key = entry.getKey();
+ final Object objectValue = entry.getValue();
+ String encodedValue = encodeValueIfNotEncoded(key, objectValue, alreadyEncoded);
+ encoded.put(key, encodedValue);
+ }
+ String resolvedUrl = expand(url.toString(), encoded).replace("+", "%20");
+ if (decodeSlash) {
+ resolvedUrl = resolvedUrl.replace("%2F", "/");
+ }
+ url = new StringBuilder(resolvedUrl);
+
+ Map> resolvedHeaders = new LinkedHashMap>();
+ for (String field : headers.keySet()) {
+ Collection resolvedValues = new ArrayList();
+ for (String value : valuesOrEmpty(headers, field)) {
+ String resolved = expand(value, unencoded);
+ resolvedValues.add(resolved);
+ }
+ resolvedHeaders.put(field, resolvedValues);
+ }
+ headers.clear();
+ headers.putAll(resolvedHeaders);
+ if (bodyTemplate != null) {
+ body(urlDecode(expand(bodyTemplate, encoded)));
+ }
+ return this;
+ }
+
+ private String encodeValueIfNotEncoded(String key, Object objectValue, Map alreadyEncoded) {
+ String value = String.valueOf(objectValue);
+ final Boolean isEncoded = alreadyEncoded.get(key);
+ if (isEncoded == null || !isEncoded) {
+ value = urlEncode(value);
+ }
+ return value;
+ }
+
+ /* roughly analogous to {@code javax.ws.rs.client.Target.request()}. */
+ public Request request() {
+ Map> safeCopy = new LinkedHashMap>();
+ safeCopy.putAll(headers);
+ return Request.create(
+ method, url + queryLine(),
+ Collections.unmodifiableMap(safeCopy),
+ body, charset
+ );
+ }
+
+ /* @see Request#method() */
+ public RequestTemplate method(String method) {
+ this.method = checkNotNull(method, "method");
+ checkArgument(method.matches("^[A-Z]+$"), "Invalid HTTP Method: %s", method);
+ return this;
+ }
+
+ /* @see Request#method() */
+ public String method() {
+ return method;
+ }
+
+ public RequestTemplate decodeSlash(boolean decodeSlash) {
+ this.decodeSlash = decodeSlash;
+ return this;
+ }
+
+ public boolean decodeSlash() {
+ return decodeSlash;
+ }
+
+ public RequestTemplate collectionFormat(CollectionFormat collectionFormat) {
+ this.collectionFormat = collectionFormat;
+ return this;
+ }
+
+ public CollectionFormat collectionFormat() {
+ return collectionFormat;
+ }
+
+ /* @see #url() */
+ public RequestTemplate append(CharSequence value) {
+ url.append(value);
+ url = pullAnyQueriesOutOfUrl(url);
+ return this;
+ }
+
+ /* @see #url() */
+ public RequestTemplate insert(int pos, CharSequence value) {
+ if(isHttpUrl(value)) {
+ value = removeTrailingSlash(value);
+ if(url.length() > 0 && url.charAt(0) != '/') {
+ url.insert(0, '/');
+ }
+ }
+ url.insert(pos, pullAnyQueriesOutOfUrl(new StringBuilder(value)));
+ return this;
+ }
+
+ public String url() {
+ return url.toString();
+ }
+
+ /**
+ * Replaces queries with the specified {@code name} with the {@code values} supplied.
+ *
Values can be passed in decoded or in url-encoded form depending on the value of the
+ * {@code encoded} parameter.
+ *
When the {@code value} is {@code null}, all queries with the {@code configKey} are
+ * removed.
relationship to JAXRS 2.0
Like {@code WebTarget.query},
+ * except the values can be templatized.
ex.
+ *
+ * template.query("Signature", "{signature}");
+ *
+ *
Note: behavior of RequestTemplate is not consistent if a query parameter with
+ * unsafe characters is passed as both encoded and unencoded, although no validation is performed.
+ *
ex.
+ *
+ * template.query(true, "param[]", "value");
+ * template.query(false, "param[]", "value");
+ *
+ *
+ * @param encoded whether name and values are already url-encoded
+ * @param name the name of the query
+ * @param values can be a single null to imply removing all values. Else no values are expected
+ * to be null.
+ * @see #queries()
+ */
+ public RequestTemplate query(boolean encoded, String name, String... values) {
+ return doQuery(encoded, name, values);
+ }
+
+ /* @see #query(boolean, String, String...) */
+ public RequestTemplate query(boolean encoded, String name, Iterable values) {
+ return doQuery(encoded, name, values);
+ }
+
+ /**
+ * Shortcut for {@code query(false, String, String...)}
+ * @see #query(boolean, String, String...)
+ */
+ public RequestTemplate query(String name, String... values) {
+ return doQuery(false, name, values);
+ }
+
+ /**
+ * Shortcut for {@code query(false, String, Iterable)}
+ * @see #query(boolean, String, String...)
+ */
+ public RequestTemplate query(String name, Iterable values) {
+ return doQuery(false, name, values);
+ }
+
+ private RequestTemplate doQuery(boolean encoded, String name, String... values) {
+ checkNotNull(name, "name");
+ String paramName = encoded ? name : encodeIfNotVariable(name);
+ queries.remove(paramName);
+ if (values != null && values.length > 0 && values[0] != null) {
+ ArrayList paramValues = new ArrayList();
+ for (String value : values) {
+ paramValues.add(encoded ? value : encodeIfNotVariable(value));
+ }
+ this.queries.put(paramName, paramValues);
+ }
+ return this;
+ }
+
+ private RequestTemplate doQuery(boolean encoded, String name, Iterable values) {
+ if (values != null) {
+ return doQuery(encoded, name, toArray(values, String.class));
+ }
+ return doQuery(encoded, name, (String[]) null);
+ }
+
+ private static String encodeIfNotVariable(String in) {
+ if (in == null || in.indexOf('{') == 0) {
+ return in;
+ }
+ return urlEncode(in);
+ }
+
+ /**
+ * Replaces all existing queries with the newly supplied url decoded queries.
+ *
relationship to JAXRS 2.0
Like {@code WebTarget.queries}, except the
+ * values can be templatized.
ex.
+ *
+ * template.queries(ImmutableMultimap.of("Signature", "{signature}"));
+ *
+ *
+ * @param queries if null, remove all queries. else value to replace all queries with.
+ * @see #queries()
+ */
+ public RequestTemplate queries(Map> queries) {
+ if (queries == null || queries.isEmpty()) {
+ this.queries.clear();
+ } else {
+ for (Entry> entry : queries.entrySet()) {
+ query(entry.getKey(), toArray(entry.getValue(), String.class));
+ }
+ }
+ return this;
+ }
+
+ /**
+ * Returns an immutable copy of the url decoded queries.
+ *
+ * @see Request#url()
+ */
+ public Map> queries() {
+ Map> decoded = new LinkedHashMap>();
+ for (String field : queries.keySet()) {
+ Collection decodedValues = new ArrayList();
+ for (String value : valuesOrEmpty(queries, field)) {
+ if (value != null) {
+ decodedValues.add(urlDecode(value));
+ } else {
+ decodedValues.add(null);
+ }
+ }
+ decoded.put(urlDecode(field), decodedValues);
+ }
+ return Collections.unmodifiableMap(decoded);
+ }
+
+ /**
+ * Replaces headers with the specified {@code configKey} with the {@code values} supplied.
+ * When the {@code value} is {@code null}, all headers with the {@code configKey} are removed.
+ *
relationship to JAXRS 2.0
Like {@code WebTarget.queries} and
+ * {@code javax.ws.rs.client.Invocation.Builder.header}, except the values can be templatized.
+ *
ex.
+ *
+ * template.query("X-Application-Version", "{version}");
+ *
+ *
+ * @param name the name of the header
+ * @param values can be a single null to imply removing all values. Else no values are expected to
+ * be null.
+ * @see #headers()
+ */
+ public RequestTemplate header(String name, String... values) {
+ checkNotNull(name, "header name");
+ if (values == null || (values.length == 1 && values[0] == null)) {
+ headers.remove(name);
+ } else {
+ List headers = new ArrayList();
+ headers.addAll(Arrays.asList(values));
+ this.headers.put(name, headers);
+ }
+ return this;
+ }
+
+ /* @see #header(String, String...) */
+ public RequestTemplate header(String name, Iterable values) {
+ if (values != null) {
+ return header(name, toArray(values, String.class));
+ }
+ return header(name, (String[]) null);
+ }
+
+ /**
+ * Replaces all existing headers with the newly supplied headers.
relationship to
+ * JAXRS 2.0
Like {@code Invocation.Builder.headers(MultivaluedMap)}, except the
+ * values can be templatized.
ex.
+ *
+ * template.headers(mapOf("X-Application-Version", asList("{version}")));
+ *
+ *
+ * @param headers if null, remove all headers. else value to replace all headers with.
+ * @see #headers()
+ */
+ public RequestTemplate headers(Map> headers) {
+ if (headers == null || headers.isEmpty()) {
+ this.headers.clear();
+ } else {
+ this.headers.putAll(headers);
+ }
+ return this;
+ }
+
+ /**
+ * Returns an immutable copy of the current headers.
+ *
+ * @see Request#headers()
+ */
+ public Map> headers() {
+ return Collections.unmodifiableMap(headers);
+ }
+
+ /**
+ * replaces the {@link feign.Util#CONTENT_LENGTH} header.
Usually populated by an {@link
+ * feign.codec.Encoder}.
+ *
+ * @see Request#body()
+ */
+ public RequestTemplate body(byte[] bodyData, Charset charset) {
+ this.bodyTemplate = null;
+ this.charset = charset;
+ this.body = bodyData;
+ int bodyLength = bodyData != null ? bodyData.length : 0;
+ header(CONTENT_LENGTH, String.valueOf(bodyLength));
+ return this;
+ }
+
+ /**
+ * replaces the {@link feign.Util#CONTENT_LENGTH} header.
Usually populated by an {@link
+ * feign.codec.Encoder}.
+ *
+ * @see Request#body()
+ */
+ public RequestTemplate body(String bodyText) {
+ byte[] bodyData = bodyText != null ? bodyText.getBytes(UTF_8) : null;
+ return body(bodyData, UTF_8);
+ }
+
+ /**
+ * The character set with which the body is encoded, or null if unknown or not applicable. When
+ * this is present, you can use {@code new String(req.body(), req.charset())} to access the body
+ * as a String.
+ */
+ public Charset charset() {
+ return charset;
+ }
+
+ /**
+ * @see Request#body()
+ */
+ public byte[] body() {
+ return body;
+ }
+
+ /**
+ * populated by {@link Body}
+ *
+ * @see Request#body()
+ */
+ public RequestTemplate bodyTemplate(String bodyTemplate) {
+ this.bodyTemplate = bodyTemplate;
+ this.charset = null;
+ this.body = null;
+ return this;
+ }
+
+ /**
+ * @see Request#body()
+ * @see #expand(String, Map)
+ */
+ public String bodyTemplate() {
+ return bodyTemplate;
+ }
+
+ /**
+ * if there are any query params in the URL, this will extract them out.
+ */
+ private StringBuilder pullAnyQueriesOutOfUrl(StringBuilder url) {
+ // parse out queries
+ int queryIndex = url.indexOf("?");
+ if (queryIndex != -1) {
+ String queryLine = url.substring(queryIndex + 1);
+ Map> firstQueries = parseAndDecodeQueries(queryLine);
+ if (!queries.isEmpty()) {
+ firstQueries.putAll(queries);
+ queries.clear();
+ }
+ //Since we decode all queries, we want to use the
+ //query()-method to re-add them to ensure that all
+ //logic (such as url-encoding) are executed, giving
+ //a valid queryLine()
+ for (String key : firstQueries.keySet()) {
+ Collection values = firstQueries.get(key);
+ if (allValuesAreNull(values)) {
+ //Queries where all values are null will
+ //be ignored by the query(key, value)-method
+ //So we manually avoid this case here, to ensure that
+ //we still fulfill the contract (ex. parameters without values)
+ queries.put(urlEncode(key), values);
+ } else {
+ query(key, values);
+ }
+
+ }
+ return new StringBuilder(url.substring(0, queryIndex));
+ }
+ return url;
+ }
+
+ private boolean allValuesAreNull(Collection values) {
+ if (values == null || values.isEmpty()) {
+ return true;
+ }
+ for (String val : values) {
+ if (val != null) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return request().toString();
+ }
+
+ /** {@link #replaceQueryValues(Map, Map)}, which assumes no parameter is encoded */
+ public void replaceQueryValues(Map unencoded) {
+ replaceQueryValues(unencoded, Collections.emptyMap());
+ }
+
+ /**
+ * Replaces query values which are templated with corresponding values from the {@code unencoded}
+ * map. Any unresolved queries are removed.
+ */
+ void replaceQueryValues(Map unencoded, Map alreadyEncoded) {
+ Iterator>> iterator = queries.entrySet().iterator();
+ while (iterator.hasNext()) {
+ Entry> entry = iterator.next();
+ if (entry.getValue() == null) {
+ continue;
+ }
+ Collection values = new ArrayList();
+ for (String value : entry.getValue()) {
+ if (value.indexOf('{') == 0 && value.indexOf('}') == value.length() - 1) {
+ Object variableValue = unencoded.get(value.substring(1, value.length() - 1));
+ // only add non-null expressions
+ if (variableValue == null) {
+ continue;
+ }
+ if (variableValue instanceof Iterable) {
+ for (Object val : Iterable.class.cast(variableValue)) {
+ String encodedValue = encodeValueIfNotEncoded(entry.getKey(), val, alreadyEncoded);
+ values.add(encodedValue);
+ }
+ } else {
+ String encodedValue = encodeValueIfNotEncoded(entry.getKey(), variableValue, alreadyEncoded);
+ values.add(encodedValue);
+ }
+ } else {
+ values.add(value);
+ }
+ }
+ if (values.isEmpty()) {
+ iterator.remove();
+ } else {
+ entry.setValue(values);
+ }
+ }
+ }
+
+ public String queryLine() {
+ if (queries.isEmpty()) {
+ return "";
+ }
+ StringBuilder queryBuilder = new StringBuilder("?");
+ for (String field : queries.keySet()) {
+ Collection values = valuesOrEmpty(queries, field);
+ CharSequence fieldAndValues = collectionFormat.join(field, values);
+ queryBuilder.append(queryBuilder.length() == 1 || fieldAndValues.length() == 0 ? "" : "&");
+ queryBuilder.append(fieldAndValues);
+ }
+ return queryBuilder.toString();
+ }
+
+ interface Factory {
+
+ /**
+ * create a request template using args passed to a method invocation.
+ */
+ RequestTemplate create(Object[] argv);
+ }
+}
diff --git a/core/src/main/java/feign/Response.java b/core/src/main/java/feign/Response.java
new file mode 100644
index 0000000000..dfbbf7eac0
--- /dev/null
+++ b/core/src/main/java/feign/Response.java
@@ -0,0 +1,386 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign;
+
+import java.io.ByteArrayInputStream;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.charset.Charset;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TreeMap;
+
+import static feign.Util.UTF_8;
+import static feign.Util.checkNotNull;
+import static feign.Util.checkState;
+import static feign.Util.decodeOrDefault;
+import static feign.Util.valuesOrEmpty;
+
+/**
+ * An immutable response to an http invocation which only returns string content.
+ */
+public final class Response implements Closeable {
+
+ private final int status;
+ private final String reason;
+ private final Map> headers;
+ private final Body body;
+ private final Request request;
+
+ private Response(Builder builder) {
+ checkState(builder.status >= 200, "Invalid status code: %s", builder.status);
+ this.status = builder.status;
+ this.reason = builder.reason; //nullable
+ this.headers = Collections.unmodifiableMap(caseInsensitiveCopyOf(builder.headers));
+ this.body = builder.body; //nullable
+ this.request = builder.request; //nullable
+ }
+
+ /**
+ * @deprecated To be removed in Feign 10
+ */
+ @Deprecated
+ public static Response create(int status, String reason, Map> headers,
+ InputStream inputStream, Integer length) {
+ return Response.builder()
+ .status(status)
+ .reason(reason)
+ .headers(headers)
+ .body(InputStreamBody.orNull(inputStream, length))
+ .build();
+ }
+
+ /**
+ * @deprecated To be removed in Feign 10
+ */
+ @Deprecated
+ public static Response create(int status, String reason, Map> headers,
+ byte[] data) {
+ return Response.builder()
+ .status(status)
+ .reason(reason)
+ .headers(headers)
+ .body(ByteArrayBody.orNull(data))
+ .build();
+ }
+
+ /**
+ * @deprecated To be removed in Feign 10
+ */
+ @Deprecated
+ public static Response create(int status, String reason, Map> headers,
+ String text, Charset charset) {
+ return Response.builder()
+ .status(status)
+ .reason(reason)
+ .headers(headers)
+ .body(ByteArrayBody.orNull(text, charset))
+ .build();
+ }
+
+ /**
+ * @deprecated To be removed in Feign 10
+ */
+ @Deprecated
+ public static Response create(int status, String reason, Map> headers,
+ Body body) {
+ return Response.builder()
+ .status(status)
+ .reason(reason)
+ .headers(headers)
+ .body(body)
+ .build();
+ }
+
+ public Builder toBuilder(){
+ return new Builder(this);
+ }
+
+ public static Builder builder(){
+ return new Builder();
+ }
+
+ public static final class Builder {
+ int status;
+ String reason;
+ Map> headers;
+ Body body;
+ Request request;
+
+ Builder() {
+ }
+
+ Builder(Response source) {
+ this.status = source.status;
+ this.reason = source.reason;
+ this.headers = source.headers;
+ this.body = source.body;
+ this.request = source.request;
+ }
+
+ /** @see Response#status*/
+ public Builder status(int status) {
+ this.status = status;
+ return this;
+ }
+
+ /** @see Response#reason */
+ public Builder reason(String reason) {
+ this.reason = reason;
+ return this;
+ }
+
+ /** @see Response#headers */
+ public Builder headers(Map> headers) {
+ this.headers = headers;
+ return this;
+ }
+
+ /** @see Response#body */
+ public Builder body(Body body) {
+ this.body = body;
+ return this;
+ }
+
+ /** @see Response#body */
+ public Builder body(InputStream inputStream, Integer length) {
+ this.body = InputStreamBody.orNull(inputStream, length);
+ return this;
+ }
+
+ /** @see Response#body */
+ public Builder body(byte[] data) {
+ this.body = ByteArrayBody.orNull(data);
+ return this;
+ }
+
+ /** @see Response#body */
+ public Builder body(String text, Charset charset) {
+ this.body = ByteArrayBody.orNull(text, charset);
+ return this;
+ }
+
+ /** @see Response#request
+ *
+ * NOTE: will add null check in version 10 which may require changes
+ * to custom feign.Client or loggers
+ */
+ public Builder request(Request request) {
+ this.request = request;
+ return this;
+ }
+
+ public Response build() {
+ return new Response(this);
+ }
+ }
+
+ /**
+ * status code. ex {@code 200}
+ *
+ * See rfc2616
+ */
+ public int status() {
+ return status;
+ }
+
+ /**
+ * Nullable and not set when using http/2
+ *
+ * See https://github.com/http2/http2-spec/issues/202
+ */
+ public String reason() {
+ return reason;
+ }
+
+ /**
+ * Returns a case-insensitive mapping of header names to their values.
+ */
+ public Map> headers() {
+ return headers;
+ }
+
+ /**
+ * if present, the response had a body
+ */
+ public Body body() {
+ return body;
+ }
+
+ /**
+ * if present, the request that generated this response
+ */
+ public Request request() {
+ return request;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder builder = new StringBuilder("HTTP/1.1 ").append(status);
+ if (reason != null) builder.append(' ').append(reason);
+ builder.append('\n');
+ for (String field : headers.keySet()) {
+ for (String value : valuesOrEmpty(headers, field)) {
+ builder.append(field).append(": ").append(value).append('\n');
+ }
+ }
+ if (body != null) builder.append('\n').append(body);
+ return builder.toString();
+ }
+
+ @Override
+ public void close() {
+ Util.ensureClosed(body);
+ }
+
+ public interface Body extends Closeable {
+
+ /**
+ * length in bytes, if known. Null if unknown or greater than {@link Integer#MAX_VALUE}.
+ *
+ *
Note
This is an integer as
+ * most implementations cannot do bodies greater than 2GB.
+ */
+ Integer length();
+
+ /**
+ * True if {@link #asInputStream()} and {@link #asReader()} can be called more than once.
+ */
+ boolean isRepeatable();
+
+ /**
+ * It is the responsibility of the caller to close the stream.
+ */
+ InputStream asInputStream() throws IOException;
+
+ /**
+ * It is the responsibility of the caller to close the stream.
+ */
+ Reader asReader() throws IOException;
+ }
+
+ private static final class InputStreamBody implements Response.Body {
+
+ private final InputStream inputStream;
+ private final Integer length;
+ private InputStreamBody(InputStream inputStream, Integer length) {
+ this.inputStream = inputStream;
+ this.length = length;
+ }
+
+ private static Body orNull(InputStream inputStream, Integer length) {
+ if (inputStream == null) {
+ return null;
+ }
+ return new InputStreamBody(inputStream, length);
+ }
+
+ @Override
+ public Integer length() {
+ return length;
+ }
+
+ @Override
+ public boolean isRepeatable() {
+ return false;
+ }
+
+ @Override
+ public InputStream asInputStream() throws IOException {
+ return inputStream;
+ }
+
+ @Override
+ public Reader asReader() throws IOException {
+ return new InputStreamReader(inputStream, UTF_8);
+ }
+
+ @Override
+ public void close() throws IOException {
+ inputStream.close();
+ }
+ }
+
+ private static final class ByteArrayBody implements Response.Body {
+
+ private final byte[] data;
+
+ public ByteArrayBody(byte[] data) {
+ this.data = data;
+ }
+
+ private static Body orNull(byte[] data) {
+ if (data == null) {
+ return null;
+ }
+ return new ByteArrayBody(data);
+ }
+
+ private static Body orNull(String text, Charset charset) {
+ if (text == null) {
+ return null;
+ }
+ checkNotNull(charset, "charset");
+ return new ByteArrayBody(text.getBytes(charset));
+ }
+
+ @Override
+ public Integer length() {
+ return data.length;
+ }
+
+ @Override
+ public boolean isRepeatable() {
+ return true;
+ }
+
+ @Override
+ public InputStream asInputStream() throws IOException {
+ return new ByteArrayInputStream(data);
+ }
+
+ @Override
+ public Reader asReader() throws IOException {
+ return new InputStreamReader(asInputStream(), UTF_8);
+ }
+
+ @Override
+ public void close() throws IOException {
+ }
+
+ @Override
+ public String toString() {
+ return decodeOrDefault(data, UTF_8, "Binary data");
+ }
+ }
+
+ private static Map> caseInsensitiveCopyOf(Map> headers) {
+ Map> result = new TreeMap>(String.CASE_INSENSITIVE_ORDER);
+
+ for (Map.Entry> entry : headers.entrySet()) {
+ String headerName = entry.getKey();
+ if (!result.containsKey(headerName)) {
+ result.put(headerName.toLowerCase(Locale.ROOT), new LinkedList());
+ }
+ result.get(headerName).addAll(entry.getValue());
+ }
+ return result;
+ }
+}
diff --git a/core/src/main/java/feign/ResponseMapper.java b/core/src/main/java/feign/ResponseMapper.java
new file mode 100644
index 0000000000..d02af6adb9
--- /dev/null
+++ b/core/src/main/java/feign/ResponseMapper.java
@@ -0,0 +1,40 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign;
+
+import java.lang.reflect.Type;
+
+/**
+ * Map function to apply to the response before decoding it.
+ *
+ * {@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);
+ * }
+ * }
+ * };
+ * }
+ */
+public interface ResponseMapper {
+
+ Response map(Response response, Type type);
+}
diff --git a/core/src/main/java/feign/RetryableException.java b/core/src/main/java/feign/RetryableException.java
new file mode 100644
index 0000000000..e3e912f744
--- /dev/null
+++ b/core/src/main/java/feign/RetryableException.java
@@ -0,0 +1,51 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign;
+
+import java.util.Date;
+
+/**
+ * This exception is raised when the {@link Response} is deemed to be retryable, typically via an
+ * {@link feign.codec.ErrorDecoder} when the {@link Response#status() status} is 503.
+ */
+public class RetryableException extends FeignException {
+
+ private static final long serialVersionUID = 1L;
+
+ private final Long retryAfter;
+
+ /**
+ * @param retryAfter usually corresponds to the {@link feign.Util#RETRY_AFTER} header.
+ */
+ public RetryableException(String message, Throwable cause, Date retryAfter) {
+ super(message, cause);
+ this.retryAfter = retryAfter != null ? retryAfter.getTime() : null;
+ }
+
+ /**
+ * @param retryAfter usually corresponds to the {@link feign.Util#RETRY_AFTER} header.
+ */
+ public RetryableException(String message, Date retryAfter) {
+ super(message);
+ this.retryAfter = retryAfter != null ? retryAfter.getTime() : null;
+ }
+
+ /**
+ * Sometimes corresponds to the {@link feign.Util#RETRY_AFTER} header present in {@code 503}
+ * status. Other times parsed from an application-specific response. Null if unknown.
+ */
+ public Date retryAfter() {
+ return retryAfter != null ? new Date(retryAfter) : null;
+ }
+}
diff --git a/core/src/main/java/feign/Retryer.java b/core/src/main/java/feign/Retryer.java
new file mode 100644
index 0000000000..0cacec3ffa
--- /dev/null
+++ b/core/src/main/java/feign/Retryer.java
@@ -0,0 +1,114 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+/**
+ * Cloned for each invocation to {@link Client#execute(Request, feign.Request.Options)}.
+ * Implementations may keep state to determine if retry operations should continue or not.
+ */
+public interface Retryer extends Cloneable {
+
+ /**
+ * if retry is permitted, return (possibly after sleeping). Otherwise propagate the exception.
+ */
+ void continueOrPropagate(RetryableException e);
+
+ Retryer clone();
+
+ public static class Default implements Retryer {
+
+ private final int maxAttempts;
+ private final long period;
+ private final long maxPeriod;
+ int attempt;
+ long sleptForMillis;
+
+ public Default() {
+ this(100, SECONDS.toMillis(1), 5);
+ }
+
+ public Default(long period, long maxPeriod, int maxAttempts) {
+ this.period = period;
+ this.maxPeriod = maxPeriod;
+ this.maxAttempts = maxAttempts;
+ this.attempt = 1;
+ }
+
+ // visible for testing;
+ protected long currentTimeMillis() {
+ return System.currentTimeMillis();
+ }
+
+ public void continueOrPropagate(RetryableException e) {
+ if (attempt++ >= maxAttempts) {
+ throw e;
+ }
+
+ long interval;
+ if (e.retryAfter() != null) {
+ interval = e.retryAfter().getTime() - currentTimeMillis();
+ if (interval > maxPeriod) {
+ interval = maxPeriod;
+ }
+ if (interval < 0) {
+ return;
+ }
+ } else {
+ interval = nextMaxInterval();
+ }
+ try {
+ Thread.sleep(interval);
+ } catch (InterruptedException ignored) {
+ Thread.currentThread().interrupt();
+ throw e;
+ }
+ sleptForMillis += interval;
+ }
+
+ /**
+ * Calculates the time interval to a retry attempt.
The interval increases exponentially
+ * with each attempt, at a rate of nextInterval *= 1.5 (where 1.5 is the backoff factor), to the
+ * maximum interval.
+ *
+ * @return time in nanoseconds from now until the next attempt.
+ */
+ long nextMaxInterval() {
+ long interval = (long) (period * Math.pow(1.5, attempt - 1));
+ return interval > maxPeriod ? maxPeriod : interval;
+ }
+
+ @Override
+ public Retryer clone() {
+ return new Default(period, maxPeriod, maxAttempts);
+ }
+ }
+
+ /**
+ * Implementation that never retries request. It propagates the RetryableException.
+ */
+ Retryer NEVER_RETRY = new Retryer() {
+
+ @Override
+ public void continueOrPropagate(RetryableException e) {
+ throw e;
+ }
+
+ @Override
+ public Retryer clone() {
+ return this;
+ }
+ };
+}
diff --git a/core/src/main/java/feign/SynchronousMethodHandler.java b/core/src/main/java/feign/SynchronousMethodHandler.java
new file mode 100644
index 0000000000..01e4a2fed4
--- /dev/null
+++ b/core/src/main/java/feign/SynchronousMethodHandler.java
@@ -0,0 +1,205 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import feign.InvocationHandlerFactory.MethodHandler;
+import feign.Request.Options;
+import feign.codec.DecodeException;
+import feign.codec.Decoder;
+import feign.codec.ErrorDecoder;
+
+import static feign.FeignException.errorExecuting;
+import static feign.FeignException.errorReading;
+import static feign.Util.checkNotNull;
+import static feign.Util.ensureClosed;
+
+final class SynchronousMethodHandler implements MethodHandler {
+
+ private static final long MAX_RESPONSE_BUFFER_SIZE = 8192L;
+
+ private final MethodMetadata metadata;
+ private final Target target;
+ private final Client client;
+ private final Retryer retryer;
+ private final List requestInterceptors;
+ private final Logger logger;
+ private final Logger.Level logLevel;
+ private final RequestTemplate.Factory buildTemplateFromArgs;
+ private final Options options;
+ private final Decoder decoder;
+ private final ErrorDecoder errorDecoder;
+ private final boolean decode404;
+ private final boolean closeAfterDecode;
+
+ private SynchronousMethodHandler(Target target, Client client, Retryer retryer,
+ List requestInterceptors, Logger logger,
+ Logger.Level logLevel, MethodMetadata metadata,
+ RequestTemplate.Factory buildTemplateFromArgs, Options options,
+ Decoder decoder, ErrorDecoder errorDecoder, boolean decode404,
+ boolean closeAfterDecode) {
+ this.target = checkNotNull(target, "target");
+ this.client = checkNotNull(client, "client for %s", target);
+ this.retryer = checkNotNull(retryer, "retryer for %s", target);
+ this.requestInterceptors =
+ checkNotNull(requestInterceptors, "requestInterceptors for %s", target);
+ this.logger = checkNotNull(logger, "logger for %s", target);
+ this.logLevel = checkNotNull(logLevel, "logLevel for %s", target);
+ this.metadata = checkNotNull(metadata, "metadata for %s", target);
+ this.buildTemplateFromArgs = checkNotNull(buildTemplateFromArgs, "metadata for %s", target);
+ this.options = checkNotNull(options, "options for %s", target);
+ this.errorDecoder = checkNotNull(errorDecoder, "errorDecoder for %s", target);
+ this.decoder = checkNotNull(decoder, "decoder for %s", target);
+ this.decode404 = decode404;
+ this.closeAfterDecode = closeAfterDecode;
+ }
+
+ @Override
+ public Object invoke(Object[] argv) throws Throwable {
+ RequestTemplate template = buildTemplateFromArgs.create(argv);
+ Retryer retryer = this.retryer.clone();
+ while (true) {
+ try {
+ return executeAndDecode(template);
+ } catch (RetryableException e) {
+ retryer.continueOrPropagate(e);
+ if (logLevel != Logger.Level.NONE) {
+ logger.logRetry(metadata.configKey(), logLevel);
+ }
+ continue;
+ }
+ }
+ }
+
+ Object executeAndDecode(RequestTemplate template) throws Throwable {
+ Request request = targetRequest(template);
+
+ if (logLevel != Logger.Level.NONE) {
+ logger.logRequest(metadata.configKey(), logLevel, request);
+ }
+
+ Response response;
+ long start = System.nanoTime();
+ try {
+ response = client.execute(request, options);
+ // ensure the request is set. TODO: remove in Feign 10
+ response.toBuilder().request(request).build();
+ } catch (IOException e) {
+ if (logLevel != Logger.Level.NONE) {
+ logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
+ }
+ throw errorExecuting(request, e);
+ }
+ long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
+
+ boolean shouldClose = true;
+ try {
+ if (logLevel != Logger.Level.NONE) {
+ response =
+ logger.logAndRebufferResponse(metadata.configKey(), logLevel, response, elapsedTime);
+ // ensure the request is set. TODO: remove in Feign 10
+ response.toBuilder().request(request).build();
+ }
+ if (Response.class == metadata.returnType()) {
+ if (response.body() == null) {
+ return response;
+ }
+ if (response.body().length() == null ||
+ response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {
+ shouldClose = false;
+ return response;
+ }
+ // Ensure the response body is disconnected
+ byte[] bodyData = Util.toByteArray(response.body().asInputStream());
+ return response.toBuilder().body(bodyData).build();
+ }
+ if (response.status() >= 200 && response.status() < 300) {
+ if (void.class == metadata.returnType()) {
+ return null;
+ } else {
+ shouldClose = closeAfterDecode;
+ return decode(response);
+ }
+ } else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
+ shouldClose = closeAfterDecode;
+ return decode(response);
+ } else {
+ throw errorDecoder.decode(metadata.configKey(), response);
+ }
+ } catch (IOException e) {
+ if (logLevel != Logger.Level.NONE) {
+ logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime);
+ }
+ throw errorReading(request, response, e);
+ } finally {
+ if (shouldClose) {
+ ensureClosed(response.body());
+ }
+ }
+ }
+
+ long elapsedTime(long start) {
+ return TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
+ }
+
+ Request targetRequest(RequestTemplate template) {
+ for (RequestInterceptor interceptor : requestInterceptors) {
+ interceptor.apply(template);
+ }
+ return target.apply(new RequestTemplate(template));
+ }
+
+ Object decode(Response response) throws Throwable {
+ try {
+ return decoder.decode(response, metadata.returnType());
+ } catch (FeignException e) {
+ throw e;
+ } catch (RuntimeException e) {
+ throw new DecodeException(e.getMessage(), e);
+ }
+ }
+
+ static class Factory {
+
+ private final Client client;
+ private final Retryer retryer;
+ private final List requestInterceptors;
+ private final Logger logger;
+ private final Logger.Level logLevel;
+ private final boolean decode404;
+ private final boolean closeAfterDecode;
+
+ Factory(Client client, Retryer retryer, List requestInterceptors,
+ Logger logger, Logger.Level logLevel, boolean decode404, boolean closeAfterDecode) {
+ this.client = checkNotNull(client, "client");
+ this.retryer = checkNotNull(retryer, "retryer");
+ this.requestInterceptors = checkNotNull(requestInterceptors, "requestInterceptors");
+ this.logger = checkNotNull(logger, "logger");
+ this.logLevel = checkNotNull(logLevel, "logLevel");
+ this.decode404 = decode404;
+ this.closeAfterDecode = closeAfterDecode;
+ }
+
+ public MethodHandler create(Target target, MethodMetadata md,
+ RequestTemplate.Factory buildTemplateFromArgs,
+ Options options, Decoder decoder, ErrorDecoder errorDecoder) {
+ return new SynchronousMethodHandler(target, client, retryer, requestInterceptors, logger,
+ logLevel, md, buildTemplateFromArgs, options, decoder,
+ errorDecoder, decode404, closeAfterDecode);
+ }
+ }
+}
diff --git a/core/src/main/java/feign/Target.java b/core/src/main/java/feign/Target.java
new file mode 100644
index 0000000000..e2e02b31da
--- /dev/null
+++ b/core/src/main/java/feign/Target.java
@@ -0,0 +1,191 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign;
+
+import static feign.Util.checkNotNull;
+import static feign.Util.emptyToNull;
+
+/**
+ *
relationship to JAXRS 2.0
Similar to {@code
+ * javax.ws.rs.client.WebTarget}, as it produces requests. However, {@link RequestTemplate} is a
+ * closer match to {@code WebTarget}.
+ *
+ * @param type of the interface this target applies to.
+ */
+public interface Target {
+
+ /* The type of the interface this target applies to. ex. {@code Route53}. */
+ Class type();
+
+ /* configuration key associated with this target. For example, {@code route53}. */
+ String name();
+
+ /* base HTTP URL of the target. For example, {@code https://api/v2}. */
+ String url();
+
+ /**
+ * Targets a template to this target, adding the {@link #url() base url} and any target-specific
+ * headers or query parameters.
For example:
+ *
+ * public Request apply(RequestTemplate input) {
+ * input.insert(0, url());
+ * input.replaceHeader("X-Auth", currentToken);
+ * return input.asRequest();
+ * }
+ *
+ *
relationship to JAXRS 2.0
This call is similar to {@code
+ * javax.ws.rs.client.WebTarget.request()}, except that we expect transient, but necessary
+ * decoration to be applied on invocation.
+ */
+ public Request apply(RequestTemplate input);
+
+ public static class HardCodedTarget implements Target {
+
+ private final Class type;
+ private final String name;
+ private final String url;
+
+ public HardCodedTarget(Class type, String url) {
+ this(type, url, url);
+ }
+
+ public HardCodedTarget(Class type, String name, String url) {
+ this.type = checkNotNull(type, "type");
+ this.name = checkNotNull(emptyToNull(name), "name");
+ this.url = checkNotNull(emptyToNull(url), "url");
+ }
+
+ @Override
+ public Class type() {
+ return type;
+ }
+
+ @Override
+ public String name() {
+ return name;
+ }
+
+ @Override
+ public String url() {
+ return url;
+ }
+
+ /* no authentication or other special activity. just insert the url. */
+ @Override
+ public Request apply(RequestTemplate input) {
+ if (input.url().indexOf("http") != 0) {
+ input.insert(0, url());
+ }
+ return input.request();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof HardCodedTarget) {
+ HardCodedTarget other = (HardCodedTarget) obj;
+ return type.equals(other.type)
+ && name.equals(other.name)
+ && url.equals(other.url);
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = 17;
+ result = 31 * result + type.hashCode();
+ result = 31 * result + name.hashCode();
+ result = 31 * result + url.hashCode();
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ if (name.equals(url)) {
+ return "HardCodedTarget(type=" + type.getSimpleName() + ", url=" + url + ")";
+ }
+ return "HardCodedTarget(type=" + type.getSimpleName() + ", name=" + name + ", url=" + url
+ + ")";
+ }
+ }
+
+ public static final class EmptyTarget implements Target {
+
+ private final Class type;
+ private final String name;
+
+ EmptyTarget(Class type, String name) {
+ this.type = checkNotNull(type, "type");
+ this.name = checkNotNull(emptyToNull(name), "name");
+ }
+
+ public static EmptyTarget create(Class type) {
+ return new EmptyTarget(type, "empty:" + type.getSimpleName());
+ }
+
+ public static EmptyTarget create(Class