Update SNAPSHOT to 2.2.7.RELEASE

* Encode Pageable.Sort with percent encoded comma. Fixes gh-440.

* Replace ifs with assert in FeignPageableEncodingTests

.gitignore

@@ -20,4 +20,5 @@ _site/
 *.swo
 .vscode/
 .flattened-pom.xml
+.sdkmanrc
 

README.adoc

@@ -28,6 +28,8 @@ image:https://api.codacy.com/project/badge/Grade/97b04c4e609c4b4f86b415e4437a648
 :project-full-name: Spring Cloud OpenFeign
 :all: {asterisk}{asterisk}
 
+:core_path: {project-root}/spring-cloud-openfeign-core
+
 This project provides OpenFeign integrations for Spring Boot apps through autoconfiguration
 and binding to the Spring Environment and other Spring programming model idioms.
 
@@ -314,3 +316,7 @@ Go to `File` -> `Settings` -> `Other settings` -> `Checkstyle`. There click on t
 - `checkstyle.additional.suppressions.file` - this variable corresponds to suppressions in your local project. E.g. you're working on `spring-cloud-contract`. Then point to the `project-root/src/checkstyle/checkstyle-suppressions.xml` folder. Example for `spring-cloud-contract` would be: `/home/username/spring-cloud-contract/src/checkstyle/checkstyle-suppressions.xml`.
 
 IMPORTANT: Remember to set the `Scan Scope` to `All sources` since we apply checkstyle rules for production and test sources.
+
+== License
+
+The project license file is available https://raw.githubusercontent.com/spring-cloud/spring-cloud-openfeign/master/LICENSE.txt[here].

SECURITY.md

@@ -1,5 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-To report security vulnerabilities, please go to https://pivotal.io/security.

docs/pom.xml

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-openfeign</artifactId>
-		<version>2.2.4.BUILD-SNAPSHOT</version>
+		<version>2.2.7.RELEASE</version>
 	</parent>
 	<artifactId>spring-cloud-openfeign-docs</artifactId>
 	<packaging>pom</packaging>

docs/src/main/asciidoc/README.adoc

@@ -19,3 +19,7 @@ include::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/maste
 == Contributing
 
 include::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/docs/src/main/asciidoc/contributing.adoc[]
+
+== License
+
+The project license file is available https://raw.githubusercontent.com/spring-cloud/spring-cloud-openfeign/master/LICENSE.txt[here].

docs/src/main/asciidoc/_attributes.adoc

@@ -14,3 +14,5 @@
 :sc-ext: java
 :project-full-name: Spring Cloud OpenFeign
 :all: {asterisk}{asterisk}
+
+:core_path: {project-root}/spring-cloud-openfeign-core

docs/src/main/asciidoc/_configprops.adoc

@@ -1,24 +1,27 @@
 |===
 |Name | Default | Description
 
+|feign.autoconfiguration.jackson.enabled | `false` | If true, PageJacksonModule and SortJacksonModule bean will be provided for Jackson page decoding.
+|feign.circuitbreaker.enabled | `false` | If true, an OpenFeign client will be wrapped with a Spring Cloud CircuitBreaker circuit breaker.
 |feign.client.config |  | 
-|feign.client.default-config | default | 
-|feign.client.default-to-properties | true | 
-|feign.compression.request.enabled | false | Enables the request sent by Feign to be compressed.
-|feign.compression.request.mime-types | [text/xml, application/xml, application/json] | The list of supported mime types.
-|feign.compression.request.min-request-size | 2048 | The minimum threshold content size.
-|feign.compression.response.enabled | false | Enables the response from Feign to be compressed.
-|feign.compression.response.useGzipDecoder | false | Enables the default gzip decoder to be used.
-|feign.httpclient.connection-timeout | 2000 | 
-|feign.httpclient.connection-timer-repeat | 3000 | 
-|feign.httpclient.disable-ssl-validation | false | 
-|feign.httpclient.enabled | true | Enables the use of the Apache HTTP Client by Feign.
-|feign.httpclient.follow-redirects | true | 
-|feign.httpclient.max-connections | 200 | 
-|feign.httpclient.max-connections-per-route | 50 | 
-|feign.httpclient.time-to-live | 900 | 
+|feign.client.decode-slash | `true` | Feign clients do not encode slash `/` characters by default. To change this behavior, set the `decodeSlash` to `false`.
+|feign.client.default-config | `default` | 
+|feign.client.default-to-properties | `true` | 
+|feign.compression.request.enabled | `false` | Enables the request sent by Feign to be compressed.
+|feign.compression.request.mime-types | `[text/xml, application/xml, application/json]` | The list of supported mime types.
+|feign.compression.request.min-request-size | `2048` | The minimum threshold content size.
+|feign.compression.response.enabled | `false` | Enables the response from Feign to be compressed.
+|feign.compression.response.useGzipDecoder | `false` | Enables the default gzip decoder to be used.
+|feign.httpclient.connection-timeout | `2000` | 
+|feign.httpclient.connection-timer-repeat | `3000` | 
+|feign.httpclient.disable-ssl-validation | `false` | 
+|feign.httpclient.enabled | `true` | Enables the use of the Apache HTTP Client by Feign.
+|feign.httpclient.follow-redirects | `true` | 
+|feign.httpclient.max-connections | `200` | 
+|feign.httpclient.max-connections-per-route | `50` | 
+|feign.httpclient.time-to-live | `900` | 
 |feign.httpclient.time-to-live-unit |  | 
-|feign.hystrix.enabled | false | If true, an OpenFeign client will be wrapped with a Hystrix circuit breaker.
-|feign.okhttp.enabled | false | Enables the use of the OK HTTP Client by Feign.
+|feign.hystrix.enabled | `false` | If true, an OpenFeign client will be wrapped with a Hystrix circuit breaker.
+|feign.okhttp.enabled | `false` | Enables the use of the OK HTTP Client by Feign.
 
 |===

docs/src/main/asciidoc/sagan-index.adoc

@@ -24,3 +24,18 @@ public class WebApplication {
 }
 
 ```
+
+## Contributing
+
+We welcome contributions. You can read more on how to contribute to the project https://github.com/spring-cloud/spring-cloud-openfeign/blob/master/README.adoc#3-contributing[here].
+
+## Community Support
+
+* You can report issues through https://github.com/spring-cloud/spring-cloud-openfeign/issues[Github].
+* We monitor https://stackoverflow.com/[StackOverflow] for questions with the `spring-cloud-feign` tag.
+* You can contact our team at https://gitter.im/spring-cloud/spring-cloud[Gitter].
+
+## Commercial Support
+
+Commercial Support is provided as part of the https://spring.io/support[VMware Spring Runtime] offering.
+

docs/src/main/asciidoc/spring-cloud-openfeign.adoc

@@ -15,7 +15,7 @@ To use Feign create an interface and annotate it.
 It has pluggable annotation support including Feign annotations and JAX-RS annotations.
 Feign also supports pluggable encoders and decoders.
 Spring Cloud adds support for Spring MVC annotations and for using the same `HttpMessageConverters` used by default in Spring Web.
-Spring Cloud integrates Ribbon and Eureka, as well as Spring Cloud LoadBalancer to provide a load-balanced http client when using Feign.
+Spring Cloud integrates Ribbon and Eureka, Spring Cloud CircuitBreaker, as well as Spring Cloud LoadBalancer to provide a load-balanced http client when using Feign.
 
 [[netflix-feign-starter]]
 === How to Include Feign
@@ -55,7 +55,7 @@ public interface StoreClient {
 }
 ----
 
-In the `@FeignClient` annotation the String value ("stores" above) is an arbitrary client name, which is used to create either a https://github.com/Netflix/ribbon[Ribbon] load-balancer (see <<spring-cloud-ribbon,below for details of Ribbon support>>) or https://github.com/spring-cloud/spring-cloud-commons/blob/master/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/reactive/ReactiveLoadBalancer.java[Spring Cloud LoadBalancer].
+In the `@FeignClient` annotation the String value ("stores" above) is an arbitrary client name, which is used to create either a https://github.com/Netflix/ribbon[Ribbon] load-balancer (see <<spring-cloud-ribbon,below for details of Ribbon support>> and <<spring-cloud-circuitbreaker,below for details of Spring Cloud CircuitBreaker support>>) or https://github.com/spring-cloud/spring-cloud-commons/blob/master/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/reactive/ReactiveLoadBalancer.java[Spring Cloud LoadBalancer].
 You can also specify a URL using the `url` attribute
 (absolute value or just a hostname). The name of the bean in the
 application context is the fully qualified name of the interface.
@@ -112,13 +112,14 @@ public interface StoreClient {
 }
 ----
 
-Spring Cloud Netflix provides the following beans by default for feign (`BeanType` beanName: `ClassName`):
+Spring Cloud OpenFeign provides the following beans by default for feign (`BeanType` beanName: `ClassName`):
 
 * `Decoder` feignDecoder: `ResponseEntityDecoder` (which wraps a `SpringDecoder`)
 * `Encoder` feignEncoder: `SpringEncoder`
 * `Logger` feignLogger: `Slf4jLogger`
 * `Contract` feignContract: `SpringMvcContract`
 * `Feign.Builder` feignBuilder: `HystrixFeign.Builder`
+* `Feign.Builder` feignBuilder: `FeignCircuitBreaker.Builder`
 * `Client` feignClient: if Ribbon is in the classpath and is enabled it is a `LoadBalancerFeignClient`, otherwise if Spring Cloud LoadBalancer is in the classpath, `FeignBlockingLoadBalancerClient` is used.
 If none of them is in the classpath, the default feign client is used.
 
@@ -175,6 +176,10 @@ feign:
         loggerLevel: full
         errorDecoder: com.example.SimpleErrorDecoder
         retryer: com.example.SimpleRetryer
+       defaultQueryParameters:
+          query: queryValue
+        defaultRequestHeaders:
+          header: headerValue
         requestInterceptors:
           - com.example.FooRequestInterceptor
           - com.example.BarRequestInterceptor
@@ -188,6 +193,8 @@ Default configurations can be specified in the `@EnableFeignClients` attribute `
 
 If you prefer using configuration properties to configured all `@FeignClient`, you can create configuration properties with `default` feign name.
 
+You can use `feign.client.config.feignName.defaultQueryParameters` and `feign.client.config.feignName.defaultRequestHeaders` to specify query parameters and headers that will be sent with every request of the client named `feignName`.
+
 application.yml
 [source,yaml]
 ----
@@ -268,6 +275,44 @@ public FeignClientConfigurer feignClientConfigurer() {
 }
 ----
 
+TIP: By default, Feign clients do not encode slash `/` characters. You can change this behaviour, by setting the value of `feign.client.decodeSlash` to `false`.
+
+[[timeout-handling]]
+=== Timeout Handling
+
+We can configure timeouts on both the default and the named client. OpenFeign works with two timeout parameters:
+
+- `connectTimeout` prevents blocking the caller due to the long server processing time.
+- `readTimeout` is applied from the time of connection establishment and is triggered when returning the response takes too long.
+
+NOTE: In case the server is not running or available a packet results in _connection refused_. The communication ends either with an error message or in a fallback. This can happen _before_ the `connectTimeout` if it is set very low. The time taken to perform a lookup and to receive such a packet causes a significant part of this delay. It is subject to change based on the remote host that involves a DNS lookup.
+
+When Hystrix <<spring-cloud-openfeign#spring-cloud-feign-hystrix,is enabled>>, its timeout configuration link:https://github.com/Netflix/Hystrix/wiki/Configuration#execution.isolation.thread.timeoutInMilliseconds[defaults] to 1000 milliseconds. Hence, it might occur before the client timeout that we configured earlier. Increasing this timeout prevents it from happening.
+
+[source,yaml]
+----
+feign:
+  client:
+    config:
+      default:
+        connectTimeout: 5000
+        readTimeout: 5000
+  hystrix:
+    enabled: true
+
+hystrix:
+  command:
+    default:
+      execution:
+        timeout:
+          enabled: true
+        isolation:
+          thread:
+            timeoutInMilliseconds: 60000
+----
+
+NOTE: When the Hystrix timeout is enabled and its timeout is set longer than that of a feign client, `HystrixTimeoutException` wraps a feign exception. Otherwise, the only difference is the cause of the exception. The purpose of `HystrixTimeoutException` is to wrap any runtime exception that occurs first and throw an instance of itself.
+
 === Creating Feign Clients Manually
 
 In some cases it might be necessary to customize your Feign Clients in a way that is not
@@ -305,7 +350,7 @@ class FooController {
 ----
 
 NOTE: In the above example `FeignClientsConfiguration.class` is the default configuration
-provided by Spring Cloud Netflix.
+provided by Spring Cloud OpenFeign.
 
 NOTE: `PROD-SVC` is the name of the service the Clients will be making requests to.
 
@@ -386,9 +431,47 @@ static class HystrixClientFallbackFactory implements FallbackFactory<HystrixClie
 
 WARNING: There is a limitation with the implementation of fallbacks in Feign and how Hystrix fallbacks work. Fallbacks are currently not supported for methods that return `com.netflix.hystrix.HystrixCommand` and `rx.Observable`.
 
+[[spring-cloud-feign-circuitbreaker]]
+=== Feign Spring Cloud CircuitBreaker Support
+
+If Spring Cloud CircuitBreaker is on the classpath and `feign.circuitbreaker.enabled=true`, Feign will wrap all methods with a circuit breaker.
+
+To disable Spring Cloud CircuitBreaker support on a per-client basis create a vanilla `Feign.Builder` with the "prototype" scope, e.g.:
+
+[source,java,indent=0]
+----
+@Configuration
+public class FooConfiguration {
+    	@Bean
+	@Scope("prototype")
+	public Feign.Builder feignBuilder() {
+		return Feign.builder();
+	}
+}
+----
+
+The circuit breaker name follows this pattern `<feignClientName>_<calledMethod>`. When calling a `@FeignClient` with name `foo` and the called interface method is `bar` then the circuit breaker name will be `foo_bar`.
+
+[[spring-cloud-feign-circuitbreaker-fallback]]
+=== Feign Spring Cloud CircuitBreaker Fallbacks
+
+Spring Cloud CircuitBreaker supports the notion of a fallback: a default code path that is executed when they circuit is open or there is an error. To enable fallbacks for a given `@FeignClient` set the `fallback` attribute to the class name that implements the fallback. You also need to declare your implementation as a Spring bean.
+
+[source,java,indent=0]
+----
+include::{core_path}/src/test/java/org/springframework/cloud/openfeign/circuitbreaker/CircuitBreakerTests.java[tags=client_with_fallback, indent=0]
+----
+
+If one needs access to the cause that made the fallback trigger, one can use the `fallbackFactory` attribute inside `@FeignClient`.
+
+[source,java,indent=0]
+----
+include::{core_path}/src/test/java/org/springframework/cloud/openfeign/circuitbreaker/CircuitBreakerTests.java[tags=client_with_fallback_factory, indent=0]
+----
+
 === Feign and `@Primary`
 
-When using Feign with Hystrix fallbacks, there are multiple beans in the `ApplicationContext` of the same type. This will cause `@Autowired` to not work because there isn't exactly one bean, or one marked as primary. To work around this, Spring Cloud Netflix marks all Feign instances as `@Primary`, so Spring Framework will know which bean to inject. In some cases, this may not be desirable. To turn off this behavior set the `primary` attribute of `@FeignClient` to false.
+When using Feign with Hystrix fallbacks, there are multiple beans in the `ApplicationContext` of the same type. This will cause `@Autowired` to not work because there isn't exactly one bean, or one marked as primary. To work around this, Spring Cloud OpenFeign marks all Feign instances as `@Primary`, so Spring Framework will know which bean to inject. In some cases, this may not be desirable. To turn off this behavior set the `primary` attribute of `@FeignClient` to false.
 
 [source,java,indent=0]
 ----
@@ -565,7 +648,7 @@ If a map is passed as the method argument, the `@MatrixVariable` path segment is
 If a different object is passed, either the `name` provided in the `@MatrixVariable` annotation (if defined) or the annotated variable name is
 joined with the provided method argument using `=`.
 
-IMPORTANT:: Even though, on the server side, Spring does not require the users to name the path segment placeholder same as the matrix variable name, since it would be too ambiguous on the client side, Sprig Cloud OpenFeign requires that you add a path segment placeholder with a name matching either the `name` provided in the `@MatrixVariable` annotation (if defined) or the annotated variable name.
+IMPORTANT:: Even though, on the server side, Spring does not require the users to name the path segment placeholder same as the matrix variable name, since it would be too ambiguous on the client side, Spring Cloud OpenFeign requires that you add a path segment placeholder with a name matching either the `name` provided in the `@MatrixVariable` annotation (if defined) or the annotated variable name.
 
 For example:
 
@@ -621,6 +704,14 @@ To work around this problem you can use an `ObjectProvider` when autowiring your
 ObjectProvider<TestFeginClient> testFeginClient;
 ----
 
+=== Spring Data Support
+You may consider enabling Jackson Modules for the support `org.springframework.data.domain.Page` and `org.springframework.data.domain.Sort` decoding.
+
+[source,java]
+----
+feign.autoconfiguration.jackson.enabled=true
+----
+
 == Configuration properties
 
 To see the list of all Sleuth related configuration properties please check link:appendix.html[the Appendix page].

pom.xml

@@ -4,14 +4,14 @@
 		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>spring-cloud-openfeign</artifactId>
-	<version>2.2.4.BUILD-SNAPSHOT</version>
+	<version>2.2.7.RELEASE</version>
 	<packaging>pom</packaging>
 	<name>Spring Cloud OpenFeign</name>
 	<description>Spring Cloud OpenFeign</description>
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-build</artifactId>
-		<version>2.3.1.BUILD-SNAPSHOT</version>
+		<version>2.3.2.RELEASE</version>
 		<relativePath/>
 	</parent>
 	<scm>
@@ -25,12 +25,11 @@
 	</scm>
 	<properties>
 		<main.basedir>${basedir}</main.basedir>
-		<jackson.version>2.7.3</jackson.version>
-		<spring-cloud-commons.version>2.2.4.BUILD-SNAPSHOT</spring-cloud-commons.version>
-		<spring-cloud-netflix.version>2.2.4.BUILD-SNAPSHOT</spring-cloud-netflix.version>
+		<jackson.version>2.11.3</jackson.version>
+		<spring-cloud-commons.version>2.2.7.RELEASE</spring-cloud-commons.version>
+		<spring-cloud-netflix.version>2.2.7.RELEASE</spring-cloud-netflix.version>
 
 		<!-- Plugin versions -->
-		<maven-compiler-plugin.version>3.6.1</maven-compiler-plugin.version>
 		<maven-eclipse-plugin.version>2.10</maven-eclipse-plugin.version>
 		<!-- Sonar -->
 		<surefire.plugin.version>2.19.1</surefire.plugin.version>
@@ -68,7 +67,6 @@
 			</plugin>
 			<plugin>
 				<artifactId>maven-compiler-plugin</artifactId>
-				<version>${maven-compiler-plugin.version}</version>
 				<configuration>
 					<source>1.8</source>
 					<target>1.8</target>

spring-cloud-openfeign-core/pom.xml

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-openfeign</artifactId>
-		<version>2.2.4.BUILD-SNAPSHOT</version>
+		<version>2.2.7.RELEASE</version>
 		<relativePath>..</relativePath> <!-- lookup parent from repository -->
 	</parent>
 	<artifactId>spring-cloud-openfeign-core</artifactId>
@@ -217,13 +217,13 @@
 		<dependency>
 			<groupId>com.google.protobuf</groupId>
 			<artifactId>protobuf-java</artifactId>
-			<version>3.4.0</version>
+			<version>3.14.0</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
 			<groupId>io.vavr</groupId>
 			<artifactId>vavr</artifactId>
-			<version>0.10.0</version>
+			<version>0.10.3</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
@@ -231,12 +231,6 @@
 			<artifactId>spring-cloud-loadbalancer</artifactId>
 			<optional>true</optional>
 		</dependency>
-		<dependency>
-			<groupId>pl.pragmatists</groupId>
-			<artifactId>JUnitParams</artifactId>
-			<version>1.1.1</version>
-			<scope>test</scope>
-		</dependency>
 	</dependencies>
 	<profiles>
 		<profile>

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FallbackFactory.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import static feign.Util.checkNotNull;
+
+/**
+ * Used to control the fallback given its cause.
+ *
+ * Ex.
+ *
+ * <pre>
+ * {@code
+ * // This instance will be invoked if there are errors of any kind.
+ * FallbackFactory<GitHub> fallbackFactory = cause -> (owner, repo) -> {
+ *   if (cause instanceof FeignException && ((FeignException) cause).status() == 403) {
+ *     return Collections.emptyList();
+ *   } else {
+ *     return Arrays.asList("yogi");
+ *   }
+ * };
+ *
+ * GitHub github = FeignCircuitBreaker.builder()
+ *                             ...
+ *                             .target(GitHub.class, "https://api.github.com", fallbackFactory);
+ * }
+ * </pre>
+ *
+ * @param <T> the feign interface type
+ */
+public interface FallbackFactory<T> {
+
+	/**
+	 * Returns an instance of the fallback appropriate for the given cause.
+	 * @param cause cause of an exception.
+	 * @return fallback
+	 */
+	T create(Throwable cause);
+
+	final class Default<T> implements FallbackFactory<T> {
+
+		final Log logger;
+
+		final T constant;
+
+		public Default(T constant) {
+			this(constant, LogFactory.getLog(Default.class));
+		}
+
+		Default(T constant, Log logger) {
+			this.constant = checkNotNull(constant, "fallback");
+			this.logger = checkNotNull(logger, "logger");
+		}
+
+		@Override
+		public T create(Throwable cause) {
+			if (logger.isTraceEnabled()) {
+				logger.trace("fallback due to: " + cause.getMessage(), cause);
+			}
+			return constant;
+		}
+
+		@Override
+		public String toString() {
+			return constant.toString();
+		}
+
+	}
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignAutoConfiguration.java

@@ -16,6 +16,7 @@
 
 package org.springframework.cloud.openfeign;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Timer;
@@ -24,11 +25,14 @@ import java.util.concurrent.TimeUnit;
 
 import javax.annotation.PreDestroy;
 
+import com.fasterxml.jackson.databind.Module;
 import feign.Client;
 import feign.Feign;
 import feign.httpclient.ApacheHttpClient;
 import feign.okhttp.OkHttpClient;
 import okhttp3.ConnectionPool;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.config.RegistryBuilder;
@@ -36,25 +40,34 @@ import org.apache.http.conn.HttpClientConnectionManager;
 import org.apache.http.impl.client.CloseableHttpClient;
 
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.client.actuator.HasFeatures;
+import org.springframework.cloud.client.circuitbreaker.CircuitBreaker;
+import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
 import org.springframework.cloud.commons.httpclient.ApacheHttpClientConnectionManagerFactory;
 import org.springframework.cloud.commons.httpclient.ApacheHttpClientFactory;
 import org.springframework.cloud.commons.httpclient.OkHttpClientConnectionPoolFactory;
 import org.springframework.cloud.commons.httpclient.OkHttpClientFactory;
 import org.springframework.cloud.openfeign.support.DefaultGzipDecoderConfiguration;
 import org.springframework.cloud.openfeign.support.FeignHttpClientProperties;
+import org.springframework.cloud.openfeign.support.PageJacksonModule;
+import org.springframework.cloud.openfeign.support.SortJacksonModule;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Sort;
 
 /**
  * @author Spencer Gibb
  * @author Julien Roy
+ * @author Grzegorz Poznachowski
+ * @author Nikita Konev
  */
 @Configuration(proxyBeanMethods = false)
 @ConditionalOnClass(Feign.class)
@@ -63,6 +76,8 @@ import org.springframework.context.annotation.Import;
 @Import(DefaultGzipDecoderConfiguration.class)
 public class FeignAutoConfiguration {
 
+	private static final Log LOG = LogFactory.getLog(FeignAutoConfiguration.class);
+
 	@Autowired(required = false)
 	private List<FeignClientSpecification> configurations = new ArrayList<>();
 
@@ -78,6 +93,39 @@ public class FeignAutoConfiguration {
 		return context;
 	}
 
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnClass({ Module.class, Page.class, Sort.class })
+	@ConditionalOnProperty(value = "feign.autoconfiguration.jackson.enabled",
+			havingValue = "true")
+	protected static class FeignJacksonConfiguration {
+
+		@Bean
+		@ConditionalOnMissingBean(PageJacksonModule.class)
+		public PageJacksonModule pageJacksonModule() {
+			return new PageJacksonModule();
+		}
+
+		@Bean
+		@ConditionalOnMissingBean(SortJacksonModule.class)
+		public SortJacksonModule sortModule() {
+			return new SortJacksonModule();
+		}
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnMissingClass({ "feign.hystrix.HystrixFeign",
+			"org.springframework.cloud.client.circuitbreaker.CircuitBreaker" })
+	protected static class DefaultFeignTargeterConfiguration {
+
+		@Bean
+		@ConditionalOnMissingBean
+		public Targeter feignTargeter() {
+			return new DefaultTargeter();
+		}
+
+	}
+
 	@Configuration(proxyBeanMethods = false)
 	@ConditionalOnClass(name = "feign.hystrix.HystrixFeign")
 	protected static class HystrixFeignTargeterConfiguration {
@@ -91,13 +139,22 @@ public class FeignAutoConfiguration {
 	}
 
 	@Configuration(proxyBeanMethods = false)
-	@ConditionalOnMissingClass("feign.hystrix.HystrixFeign")
-	protected static class DefaultFeignTargeterConfiguration {
+	@ConditionalOnClass(CircuitBreaker.class)
+	@ConditionalOnProperty("feign.circuitbreaker.enabled")
+	protected static class CircuitBreakerPresentFeignTargeterConfiguration {
+
+		@Bean
+		@ConditionalOnMissingBean(CircuitBreakerFactory.class)
+		public Targeter defaultFeignTargeter() {
+			return new DefaultTargeter();
+		}
 
 		@Bean
 		@ConditionalOnMissingBean
-		public Targeter feignTargeter() {
-			return new DefaultTargeter();
+		@ConditionalOnBean(CircuitBreakerFactory.class)
+		public Targeter circuitBreakerFeignTargeter(
+				CircuitBreakerFactory circuitBreakerFactory) {
+			return new FeignCircuitBreakerTargeter(circuitBreakerFactory);
 		}
 
 	}
@@ -163,10 +220,17 @@ public class FeignAutoConfiguration {
 		}
 
 		@PreDestroy
-		public void destroy() throws Exception {
+		public void destroy() {
 			this.connectionManagerTimer.cancel();
 			if (this.httpClient != null) {
-				this.httpClient.close();
+				try {
+					this.httpClient.close();
+				}
+				catch (IOException e) {
+					if (LOG.isErrorEnabled()) {
+						LOG.error("Could not correctly close httpClient.");
+					}
+				}
 			}
 		}
 

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignBuilderCustomizer.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2013-2019 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign;
+
+import feign.Feign;
+
+/**
+ * Allows application to customize the Feign builder.
+ *
+ * @author Matt King
+ */
+@FunctionalInterface
+public interface FeignBuilderCustomizer {
+
+	void customize(Feign.Builder builder);
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignCircuitBreaker.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign;
+
+import feign.Feign;
+import feign.Target;
+
+import org.springframework.cloud.client.circuitbreaker.CircuitBreaker;
+import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
+
+/**
+ * Allows Feign interfaces to work with {@link CircuitBreaker}.
+ *
+ * @author Marcin Grzejszczak
+ * @since 3.0.0
+ */
+public final class FeignCircuitBreaker {
+
+	private FeignCircuitBreaker() {
+		throw new IllegalStateException("Don't instantiate a utility class");
+	}
+
+	/**
+	 * @return builder for Feign CircuitBreaker integration
+	 */
+	public static Builder builder() {
+		return new Builder();
+	}
+
+	/**
+	 * Builder for Feign CircuitBreaker integration.
+	 */
+	public static final class Builder extends Feign.Builder {
+
+		private CircuitBreakerFactory circuitBreakerFactory;
+
+		private String feignClientName;
+
+		Builder circuitBreakerFactory(CircuitBreakerFactory circuitBreakerFactory) {
+			this.circuitBreakerFactory = circuitBreakerFactory;
+			return this;
+		}
+
+		Builder feignClientName(String feignClientName) {
+			this.feignClientName = feignClientName;
+			return this;
+		}
+
+		public <T> T target(Target<T> target, T fallback) {
+			return build(
+					fallback != null ? new FallbackFactory.Default<T>(fallback) : null)
+							.newInstance(target);
+		}
+
+		public <T> T target(Target<T> target,
+				FallbackFactory<? extends T> fallbackFactory) {
+			return build(fallbackFactory).newInstance(target);
+		}
+
+		@Override
+		public <T> T target(Target<T> target) {
+			return build(null).newInstance(target);
+		}
+
+		public Feign build(final FallbackFactory<?> nullableFallbackFactory) {
+			super.invocationHandlerFactory(
+					(target, dispatch) -> new FeignCircuitBreakerInvocationHandler(
+							circuitBreakerFactory, feignClientName, target, dispatch,
+							nullableFallbackFactory));
+			return super.build();
+		}
+
+	}
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignCircuitBreakerDisabledConditions.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign;
+
+import org.springframework.boot.autoconfigure.condition.AnyNestedCondition;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+
+class FeignCircuitBreakerDisabledConditions extends AnyNestedCondition {
+
+	FeignCircuitBreakerDisabledConditions() {
+		super(ConfigurationPhase.PARSE_CONFIGURATION);
+	}
+
+	@ConditionalOnMissingClass("org.springframework.cloud.client.circuitbreaker.CircuitBreaker")
+	static class CircuitBreakerClassMissing {
+
+	}
+
+	@ConditionalOnProperty(value = "feign.circuitbreaker.enabled", havingValue = "false",
+			matchIfMissing = true)
+	static class CircuitBreakerDisabled {
+
+	}
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignCircuitBreakerInvocationHandler.java

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import feign.InvocationHandlerFactory;
+import feign.Target;
+
+import org.springframework.cloud.client.circuitbreaker.CircuitBreaker;
+import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
+
+import static feign.Util.checkNotNull;
+
+class FeignCircuitBreakerInvocationHandler implements InvocationHandler {
+
+	private final CircuitBreakerFactory factory;
+
+	private final String feignClientName;
+
+	private final Target<?> target;
+
+	private final Map<Method, InvocationHandlerFactory.MethodHandler> dispatch;
+
+	private final FallbackFactory<?> nullableFallbackFactory;
+
+	private final Map<Method, Method> fallbackMethodMap;
+
+	FeignCircuitBreakerInvocationHandler(CircuitBreakerFactory factory,
+			String feignClientName, Target<?> target,
+			Map<Method, InvocationHandlerFactory.MethodHandler> dispatch,
+			FallbackFactory<?> nullableFallbackFactory) {
+		this.factory = factory;
+		this.feignClientName = feignClientName;
+		this.target = checkNotNull(target, "target");
+		this.dispatch = checkNotNull(dispatch, "dispatch");
+		this.fallbackMethodMap = toFallbackMethod(dispatch);
+		this.nullableFallbackFactory = nullableFallbackFactory;
+	}
+
+	@Override
+	public Object invoke(final Object proxy, final Method method, final Object[] args)
+			throws Throwable {
+		// early exit if the invoked method is from java.lang.Object
+		// code is the same as ReflectiveFeign.FeignInvocationHandler
+		if ("equals".equals(method.getName())) {
+			try {
+				Object otherHandler = args.length > 0 && args[0] != null
+						? Proxy.getInvocationHandler(args[0]) : null;
+				return equals(otherHandler);
+			}
+			catch (IllegalArgumentException e) {
+				return false;
+			}
+		}
+		else if ("hashCode".equals(method.getName())) {
+			return hashCode();
+		}
+		else if ("toString".equals(method.getName())) {
+			return toString();
+		}
+		String circuitName = this.feignClientName + "_" + method.getName();
+		CircuitBreaker circuitBreaker = this.factory.create(circuitName);
+		Supplier<Object> supplier = asSupplier(method, args);
+		if (this.nullableFallbackFactory != null) {
+			Function<Throwable, Object> fallbackFunction = throwable -> {
+				Object fallback = this.nullableFallbackFactory.create(throwable);
+				try {
+					return this.fallbackMethodMap.get(method).invoke(fallback, args);
+				}
+				catch (Exception e) {
+					throw new IllegalStateException(e);
+				}
+			};
+			return circuitBreaker.run(supplier, fallbackFunction);
+		}
+		return circuitBreaker.run(supplier);
+	}
+
+	private Supplier<Object> asSupplier(final Method method, final Object[] args) {
+		return () -> {
+			try {
+				return this.dispatch.get(method).invoke(args);
+			}
+			catch (RuntimeException throwable) {
+				throw throwable;
+			}
+			catch (Throwable throwable) {
+				throw new RuntimeException(throwable);
+			}
+		};
+	}
+
+	/**
+	 * If the method param of InvocationHandler.invoke is not accessible, i.e in a
+	 * package-private interface, the fallback call will cause of access restrictions. But
+	 * methods in dispatch are copied methods. So setting access to dispatch method
+	 * doesn't take effect to the method in InvocationHandler.invoke. Use map to store a
+	 * copy of method to invoke the fallback to bypass this and reducing the count of
+	 * reflection calls.
+	 * @return cached methods map for fallback invoking
+	 */
+	static Map<Method, Method> toFallbackMethod(
+			Map<Method, InvocationHandlerFactory.MethodHandler> dispatch) {
+		Map<Method, Method> result = new LinkedHashMap<Method, Method>();
+		for (Method method : dispatch.keySet()) {
+			method.setAccessible(true);
+			result.put(method, method);
+		}
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj instanceof FeignCircuitBreakerInvocationHandler) {
+			FeignCircuitBreakerInvocationHandler other = (FeignCircuitBreakerInvocationHandler) obj;
+			return this.target.equals(other.target);
+		}
+		return false;
+	}
+
+	@Override
+	public int hashCode() {
+		return this.target.hashCode();
+	}
+
+	@Override
+	public String toString() {
+		return this.target.toString();
+	}
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignCircuitBreakerTargeter.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign;
+
+import feign.Feign;
+import feign.Target;
+
+import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
+import org.springframework.util.StringUtils;
+
+@SuppressWarnings("unchecked")
+class FeignCircuitBreakerTargeter implements Targeter {
+
+	private final CircuitBreakerFactory circuitBreakerFactory;
+
+	FeignCircuitBreakerTargeter(CircuitBreakerFactory circuitBreakerFactory) {
+		this.circuitBreakerFactory = circuitBreakerFactory;
+	}
+
+	@Override
+	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
+			FeignContext context, Target.HardCodedTarget<T> target) {
+		if (!(feign instanceof FeignCircuitBreaker.Builder)) {
+			return feign.target(target);
+		}
+		FeignCircuitBreaker.Builder builder = (FeignCircuitBreaker.Builder) feign;
+		String name = !StringUtils.hasText(factory.getContextId()) ? factory.getName()
+				: factory.getContextId();
+		Class<?> fallback = factory.getFallback();
+		if (fallback != void.class) {
+			return targetWithFallback(name, context, target, builder, fallback);
+		}
+		Class<?> fallbackFactory = factory.getFallbackFactory();
+		if (fallbackFactory != void.class) {
+			return targetWithFallbackFactory(name, context, target, builder,
+					fallbackFactory);
+		}
+		return builder(name, builder).target(target);
+	}
+
+	private <T> T targetWithFallbackFactory(String feignClientName, FeignContext context,
+			Target.HardCodedTarget<T> target, FeignCircuitBreaker.Builder builder,
+			Class<?> fallbackFactoryClass) {
+		FallbackFactory<? extends T> fallbackFactory = (FallbackFactory<? extends T>) getFromContext(
+				"fallbackFactory", feignClientName, context, fallbackFactoryClass,
+				FallbackFactory.class);
+		return builder(feignClientName, builder).target(target, fallbackFactory);
+	}
+
+	private <T> T targetWithFallback(String feignClientName, FeignContext context,
+			Target.HardCodedTarget<T> target, FeignCircuitBreaker.Builder builder,
+			Class<?> fallback) {
+		T fallbackInstance = getFromContext("fallback", feignClientName, context,
+				fallback, target.type());
+		return builder(feignClientName, builder).target(target, fallbackInstance);
+	}
+
+	private <T> T getFromContext(String fallbackMechanism, String feignClientName,
+			FeignContext context, Class<?> beanType, Class<T> targetType) {
+		Object fallbackInstance = context.getInstance(feignClientName, beanType);
+		if (fallbackInstance == null) {
+			throw new IllegalStateException(String.format(
+					"No " + fallbackMechanism
+							+ " instance of type %s found for feign client %s",
+					beanType, feignClientName));
+		}
+
+		if (!targetType.isAssignableFrom(beanType)) {
+			throw new IllegalStateException(String.format("Incompatible "
+					+ fallbackMechanism
+					+ " instance. Fallback/fallbackFactory of type %s is not assignable to %s for feign client %s",
+					beanType, targetType, feignClientName));
+		}
+		return (T) fallbackInstance;
+	}
+
+	private FeignCircuitBreaker.Builder builder(String feignClientName,
+			FeignCircuitBreaker.Builder builder) {
+		return builder.circuitBreakerFactory(this.circuitBreakerFactory)
+				.feignClientName(feignClientName);
+	}
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClient.java

@@ -109,6 +109,7 @@ public @interface FeignClient {
 	 * annotated by {@link FeignClient}. The fallback factory must be a valid spring bean.
 	 *
 	 * @see feign.hystrix.FallbackFactory for details.
+	 * @see FallbackFactory for details.
 	 * @return fallback factory for the specified Feign client interface
 	 */
 	Class<?> fallbackFactory() default void.class;

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClientFactoryBean.java

@@ -16,6 +16,8 @@
 
 package org.springframework.cloud.openfeign;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.TimeUnit;
@@ -36,6 +38,8 @@ import feign.codec.ErrorDecoder;
 
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.FactoryBean;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
@@ -44,6 +48,7 @@ import org.springframework.cloud.openfeign.loadbalancer.FeignBlockingLoadBalance
 import org.springframework.cloud.openfeign.ribbon.LoadBalancerFeignClient;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
+import org.springframework.core.annotation.AnnotationAwareOrderComparator;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
@@ -54,9 +59,11 @@ import org.springframework.util.StringUtils;
  * @author Gregor Zurowski
  * @author Matt King
  * @author Olga Maciaszek-Sharma
+ * @author Ilia Ilinykh
+ * @author Marcin Grzejszczak
  */
-class FeignClientFactoryBean
-		implements FactoryBean<Object>, InitializingBean, ApplicationContextAware {
+public class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean,
+		ApplicationContextAware, BeanFactoryAware {
 
 	/***********************************
 	 * WARNING! Nothing in this class should be @Autowired. It causes NPEs because of some
@@ -79,6 +86,8 @@ class FeignClientFactoryBean
 
 	private ApplicationContext applicationContext;
 
+	private BeanFactory beanFactory;
+
 	private Class<?> fallback = void.class;
 
 	private Class<?> fallbackFactory = void.class;
@@ -107,13 +116,27 @@ class FeignClientFactoryBean
 		// @formatter:on
 
 		configureFeign(context, builder);
+		applyBuildCustomizers(context, builder);
 
 		return builder;
 	}
 
+	private void applyBuildCustomizers(FeignContext context, Feign.Builder builder) {
+		Map<String, FeignBuilderCustomizer> customizerMap = context
+				.getInstances(contextId, FeignBuilderCustomizer.class);
+
+		if (customizerMap != null) {
+			customizerMap.values().stream()
+					.sorted(AnnotationAwareOrderComparator.INSTANCE)
+					.forEach(feignBuilderCustomizer -> feignBuilderCustomizer
+							.customize(builder));
+		}
+	}
+
 	protected void configureFeign(FeignContext context, Feign.Builder builder) {
-		FeignClientProperties properties = applicationContext
-				.getBean(FeignClientProperties.class);
+		FeignClientProperties properties = beanFactory != null
+				? beanFactory.getBean(FeignClientProperties.class)
+				: applicationContext.getBean(FeignClientProperties.class);
 
 		FeignClientConfigurer feignClientConfigurer = getOptional(context,
 				FeignClientConfigurer.class);
@@ -173,7 +196,10 @@ class FeignClientFactoryBean
 		Map<String, RequestInterceptor> requestInterceptors = getInheritedAwareInstances(
 				context, RequestInterceptor.class);
 		if (requestInterceptors != null) {
-			builder.requestInterceptors(requestInterceptors.values());
+			List<RequestInterceptor> interceptors = new ArrayList<>(
+					requestInterceptors.values());
+			AnnotationAwareOrderComparator.sort(interceptors);
+			builder.requestInterceptors(interceptors);
 		}
 		QueryMapEncoder queryMapEncoder = getInheritedAwareOptional(context,
 				QueryMapEncoder.class);
@@ -238,6 +264,16 @@ class FeignClientFactoryBean
 			builder.encoder(getOrInstantiate(config.getEncoder()));
 		}
 
+		if (Objects.nonNull(config.getDefaultRequestHeaders())) {
+			builder.requestInterceptor(requestTemplate -> requestTemplate
+					.headers(config.getDefaultRequestHeaders()));
+		}
+
+		if (Objects.nonNull(config.getDefaultQueryParameters())) {
+			builder.requestInterceptor(requestTemplate -> requestTemplate
+					.queries(config.getDefaultQueryParameters()));
+		}
+
 		if (Objects.nonNull(config.getDecoder())) {
 			builder.decoder(getOrInstantiate(config.getDecoder()));
 		}
@@ -253,7 +289,8 @@ class FeignClientFactoryBean
 
 	private <T> T getOrInstantiate(Class<T> tClass) {
 		try {
-			return applicationContext.getBean(tClass);
+			return beanFactory != null ? beanFactory.getBean(tClass)
+					: applicationContext.getBean(tClass);
 		}
 		catch (NoSuchBeanDefinitionException e) {
 			return BeanUtils.instantiateClass(tClass);
@@ -306,7 +343,7 @@ class FeignClientFactoryBean
 	}
 
 	@Override
-	public Object getObject() throws Exception {
+	public Object getObject() {
 		return getTarget();
 	}
 
@@ -316,7 +353,9 @@ class FeignClientFactoryBean
 	 * information
 	 */
 	<T> T getTarget() {
-		FeignContext context = applicationContext.getBean(FeignContext.class);
+		FeignContext context = beanFactory != null
+				? beanFactory.getBean(FeignContext.class)
+				: applicationContext.getBean(FeignContext.class);
 		Feign.Builder builder = feign(context);
 
 		if (!StringUtils.hasText(url)) {
@@ -438,7 +477,8 @@ class FeignClientFactoryBean
 
 	@Override
 	public void setApplicationContext(ApplicationContext context) throws BeansException {
-		this.applicationContext = context;
+		applicationContext = context;
+		beanFactory = context;
 	}
 
 	public Class<?> getFallback() {
@@ -467,6 +507,7 @@ class FeignClientFactoryBean
 		}
 		FeignClientFactoryBean that = (FeignClientFactoryBean) o;
 		return Objects.equals(applicationContext, that.applicationContext)
+				&& Objects.equals(beanFactory, that.beanFactory)
 				&& decode404 == that.decode404
 				&& inheritParentContext == that.inheritParentContext
 				&& Objects.equals(fallback, that.fallback)
@@ -477,8 +518,8 @@ class FeignClientFactoryBean
 
 	@Override
 	public int hashCode() {
-		return Objects.hash(applicationContext, decode404, inheritParentContext, fallback,
-				fallbackFactory, name, path, type, url);
+		return Objects.hash(applicationContext, beanFactory, decode404,
+				inheritParentContext, fallback, fallbackFactory, name, path, type, url);
 	}
 
 	@Override
@@ -489,9 +530,15 @@ class FeignClientFactoryBean
 				.append("decode404=").append(decode404).append(", ")
 				.append("inheritParentContext=").append(inheritParentContext).append(", ")
 				.append("applicationContext=").append(applicationContext).append(", ")
+				.append("beanFactory=").append(beanFactory).append(", ")
 				.append("fallback=").append(fallback).append(", ")
 				.append("fallbackFactory=").append(fallbackFactory).append("}")
 				.toString();
 	}
 
+	@Override
+	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+		this.beanFactory = beanFactory;
+	}
+
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClientProperties.java

@@ -16,6 +16,7 @@
 
 package org.springframework.cloud.openfeign;
 
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -34,6 +35,8 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
 
 /**
  * @author Eko Kurniawan Khannedy
+ * @author Ilia Ilinykh
+ * @author Ram Anaswara
  */
 @ConfigurationProperties("feign.client")
 public class FeignClientProperties {
@@ -44,8 +47,14 @@ public class FeignClientProperties {
 
 	private Map<String, FeignClientConfiguration> config = new HashMap<>();
 
+	/**
+	 * Feign clients do not encode slash `/` characters by default. To change this
+	 * behavior, set the `decodeSlash` to `false`.
+	 */
+	private boolean decodeSlash = true;
+
 	public boolean isDefaultToProperties() {
-		return this.defaultToProperties;
+		return defaultToProperties;
 	}
 
 	public void setDefaultToProperties(boolean defaultToProperties) {
@@ -53,7 +62,7 @@ public class FeignClientProperties {
 	}
 
 	public String getDefaultConfig() {
-		return this.defaultConfig;
+		return defaultConfig;
 	}
 
 	public void setDefaultConfig(String defaultConfig) {
@@ -61,13 +70,21 @@ public class FeignClientProperties {
 	}
 
 	public Map<String, FeignClientConfiguration> getConfig() {
-		return this.config;
+		return config;
 	}
 
 	public void setConfig(Map<String, FeignClientConfiguration> config) {
 		this.config = config;
 	}
 
+	public boolean isDecodeSlash() {
+		return decodeSlash;
+	}
+
+	public void setDecodeSlash(boolean decodeSlash) {
+		this.decodeSlash = decodeSlash;
+	}
+
 	@Override
 	public boolean equals(Object o) {
 		if (this == o) {
@@ -77,14 +94,15 @@ public class FeignClientProperties {
 			return false;
 		}
 		FeignClientProperties that = (FeignClientProperties) o;
-		return this.defaultToProperties == that.defaultToProperties
-				&& Objects.equals(this.defaultConfig, that.defaultConfig)
-				&& Objects.equals(this.config, that.config);
+		return defaultToProperties == that.defaultToProperties
+				&& Objects.equals(defaultConfig, that.defaultConfig)
+				&& Objects.equals(config, that.config)
+				&& Objects.equals(decodeSlash, that.decodeSlash);
 	}
 
 	@Override
 	public int hashCode() {
-		return Objects.hash(this.defaultToProperties, this.defaultConfig, this.config);
+		return Objects.hash(defaultToProperties, defaultConfig, config, decodeSlash);
 	}
 
 	/**
@@ -104,6 +122,10 @@ public class FeignClientProperties {
 
 		private List<Class<RequestInterceptor>> requestInterceptors;
 
+		private Map<String, Collection<String>> defaultRequestHeaders;
+
+		private Map<String, Collection<String>> defaultQueryParameters;
+
 		private Boolean decode404;
 
 		private Class<Decoder> decoder;
@@ -115,7 +137,7 @@ public class FeignClientProperties {
 		private ExceptionPropagationPolicy exceptionPropagationPolicy;
 
 		public Logger.Level getLoggerLevel() {
-			return this.loggerLevel;
+			return loggerLevel;
 		}
 
 		public void setLoggerLevel(Logger.Level loggerLevel) {
@@ -123,7 +145,7 @@ public class FeignClientProperties {
 		}
 
 		public Integer getConnectTimeout() {
-			return this.connectTimeout;
+			return connectTimeout;
 		}
 
 		public void setConnectTimeout(Integer connectTimeout) {
@@ -131,7 +153,7 @@ public class FeignClientProperties {
 		}
 
 		public Integer getReadTimeout() {
-			return this.readTimeout;
+			return readTimeout;
 		}
 
 		public void setReadTimeout(Integer readTimeout) {
@@ -139,7 +161,7 @@ public class FeignClientProperties {
 		}
 
 		public Class<Retryer> getRetryer() {
-			return this.retryer;
+			return retryer;
 		}
 
 		public void setRetryer(Class<Retryer> retryer) {
@@ -147,7 +169,7 @@ public class FeignClientProperties {
 		}
 
 		public Class<ErrorDecoder> getErrorDecoder() {
-			return this.errorDecoder;
+			return errorDecoder;
 		}
 
 		public void setErrorDecoder(Class<ErrorDecoder> errorDecoder) {
@@ -155,7 +177,7 @@ public class FeignClientProperties {
 		}
 
 		public List<Class<RequestInterceptor>> getRequestInterceptors() {
-			return this.requestInterceptors;
+			return requestInterceptors;
 		}
 
 		public void setRequestInterceptors(
@@ -163,8 +185,26 @@ public class FeignClientProperties {
 			this.requestInterceptors = requestInterceptors;
 		}
 
+		public Map<String, Collection<String>> getDefaultRequestHeaders() {
+			return defaultRequestHeaders;
+		}
+
+		public void setDefaultRequestHeaders(
+				Map<String, Collection<String>> defaultRequestHeaders) {
+			this.defaultRequestHeaders = defaultRequestHeaders;
+		}
+
+		public Map<String, Collection<String>> getDefaultQueryParameters() {
+			return defaultQueryParameters;
+		}
+
+		public void setDefaultQueryParameters(
+				Map<String, Collection<String>> defaultQueryParameters) {
+			this.defaultQueryParameters = defaultQueryParameters;
+		}
+
 		public Boolean getDecode404() {
-			return this.decode404;
+			return decode404;
 		}
 
 		public void setDecode404(Boolean decode404) {
@@ -172,7 +212,7 @@ public class FeignClientProperties {
 		}
 
 		public Class<Decoder> getDecoder() {
-			return this.decoder;
+			return decoder;
 		}
 
 		public void setDecoder(Class<Decoder> decoder) {
@@ -180,7 +220,7 @@ public class FeignClientProperties {
 		}
 
 		public Class<Encoder> getEncoder() {
-			return this.encoder;
+			return encoder;
 		}
 
 		public void setEncoder(Class<Encoder> encoder) {
@@ -188,7 +228,7 @@ public class FeignClientProperties {
 		}
 
 		public Class<Contract> getContract() {
-			return this.contract;
+			return contract;
 		}
 
 		public void setContract(Class<Contract> contract) {
@@ -213,26 +253,29 @@ public class FeignClientProperties {
 				return false;
 			}
 			FeignClientConfiguration that = (FeignClientConfiguration) o;
-			return this.loggerLevel == that.loggerLevel
-					&& Objects.equals(this.connectTimeout, that.connectTimeout)
-					&& Objects.equals(this.readTimeout, that.readTimeout)
-					&& Objects.equals(this.retryer, that.retryer)
-					&& Objects.equals(this.errorDecoder, that.errorDecoder)
-					&& Objects.equals(this.requestInterceptors, that.requestInterceptors)
-					&& Objects.equals(this.decode404, that.decode404)
-					&& Objects.equals(this.encoder, that.encoder)
-					&& Objects.equals(this.decoder, that.decoder)
-					&& Objects.equals(this.contract, that.contract)
-					&& Objects.equals(this.exceptionPropagationPolicy,
-							that.exceptionPropagationPolicy);
+			return loggerLevel == that.loggerLevel
+					&& Objects.equals(connectTimeout, that.connectTimeout)
+					&& Objects.equals(readTimeout, that.readTimeout)
+					&& Objects.equals(retryer, that.retryer)
+					&& Objects.equals(errorDecoder, that.errorDecoder)
+					&& Objects.equals(requestInterceptors, that.requestInterceptors)
+					&& Objects.equals(decode404, that.decode404)
+					&& Objects.equals(encoder, that.encoder)
+					&& Objects.equals(decoder, that.decoder)
+					&& Objects.equals(contract, that.contract)
+					&& Objects.equals(exceptionPropagationPolicy,
+							that.exceptionPropagationPolicy)
+					&& Objects.equals(defaultRequestHeaders, that.defaultRequestHeaders)
+					&& Objects.equals(defaultQueryParameters,
+							that.defaultQueryParameters);
 		}
 
 		@Override
 		public int hashCode() {
-			return Objects.hash(this.loggerLevel, this.connectTimeout, this.readTimeout,
-					this.retryer, this.errorDecoder, this.requestInterceptors,
-					this.decode404, this.encoder, this.decoder, this.contract,
-					this.exceptionPropagationPolicy);
+			return Objects.hash(loggerLevel, connectTimeout, readTimeout, retryer,
+					errorDecoder, requestInterceptors, decode404, encoder, decoder,
+					contract, exceptionPropagationPolicy, defaultQueryParameters,
+					defaultRequestHeaders);
 		}
 
 	}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClientsConfiguration.java

@@ -19,7 +19,6 @@ package org.springframework.cloud.openfeign;
 import java.util.ArrayList;
 import java.util.List;
 
-import com.fasterxml.jackson.databind.Module;
 import com.netflix.hystrix.HystrixCommand;
 import feign.Contract;
 import feign.Feign;
@@ -35,18 +34,19 @@ import feign.optionals.OptionalDecoder;
 import org.springframework.beans.factory.ObjectFactory;
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.autoconfigure.data.web.SpringDataWebProperties;
 import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
+import org.springframework.cloud.client.circuitbreaker.CircuitBreaker;
+import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
 import org.springframework.cloud.openfeign.clientconfig.FeignClientConfigurer;
 import org.springframework.cloud.openfeign.support.AbstractFormWriter;
-import org.springframework.cloud.openfeign.support.PageJacksonModule;
 import org.springframework.cloud.openfeign.support.PageableSpringEncoder;
 import org.springframework.cloud.openfeign.support.ResponseEntityDecoder;
-import org.springframework.cloud.openfeign.support.SortJacksonModule;
 import org.springframework.cloud.openfeign.support.SpringDecoder;
 import org.springframework.cloud.openfeign.support.SpringEncoder;
 import org.springframework.cloud.openfeign.support.SpringMvcContract;
@@ -82,6 +82,9 @@ public class FeignClientsConfiguration {
 	@Autowired(required = false)
 	private SpringDataWebProperties springDataWebProperties;
 
+	@Autowired(required = false)
+	private FeignClientProperties feignClientProperties;
+
 	@Bean
 	@ConditionalOnMissingBean
 	public Decoder feignDecoder() {
@@ -118,7 +121,10 @@ public class FeignClientsConfiguration {
 	@Bean
 	@ConditionalOnMissingBean
 	public Contract feignContract(ConversionService feignConversionService) {
-		return new SpringMvcContract(this.parameterProcessors, feignConversionService);
+		boolean decodeSlash = feignClientProperties == null
+				|| feignClientProperties.isDecodeSlash();
+		return new SpringMvcContract(this.parameterProcessors, feignConversionService,
+				decodeSlash);
 	}
 
 	@Bean
@@ -149,18 +155,6 @@ public class FeignClientsConfiguration {
 		return new DefaultFeignLoggerFactory(this.logger);
 	}
 
-	@Bean
-	@ConditionalOnClass(name = "org.springframework.data.domain.Page")
-	public Module pageJacksonModule() {
-		return new PageJacksonModule();
-	}
-
-	@Bean
-	@ConditionalOnClass(name = "org.springframework.data.domain.Page")
-	public Module sortModule() {
-		return new SortJacksonModule();
-	}
-
 	@Bean
 	@ConditionalOnMissingBean(FeignClientConfigurer.class)
 	public FeignClientConfigurer feignClientConfigurer() {
@@ -206,4 +200,26 @@ public class FeignClientsConfiguration {
 
 	}
 
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnClass(CircuitBreaker.class)
+	@ConditionalOnProperty("feign.circuitbreaker.enabled")
+	protected static class CircuitBreakerPresentFeignBuilderConfiguration {
+
+		@Bean
+		@Scope("prototype")
+		@ConditionalOnMissingBean({ Feign.Builder.class, CircuitBreakerFactory.class })
+		public Feign.Builder defaultFeignBuilder(Retryer retryer) {
+			return Feign.builder().retryer(retryer);
+		}
+
+		@Bean
+		@Scope("prototype")
+		@ConditionalOnMissingBean
+		@ConditionalOnBean(CircuitBreakerFactory.class)
+		public Feign.Builder circuitBreakerFeignBuilder() {
+			return FeignCircuitBreaker.builder();
+		}
+
+	}
+
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClientsRegistrar.java

@@ -16,21 +16,23 @@
 
 package org.springframework.cloud.openfeign;
 
-import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
-import java.util.Arrays;
 import java.util.HashSet;
-import java.util.List;
+import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
 
 import org.springframework.beans.factory.FactoryBean;
 import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
+import org.springframework.beans.factory.annotation.AnnotatedGenericBeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinitionHolder;
+import org.springframework.beans.factory.config.BeanExpressionContext;
+import org.springframework.beans.factory.config.BeanExpressionResolver;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
@@ -43,12 +45,7 @@ import org.springframework.core.annotation.AnnotationAttributes;
 import org.springframework.core.env.Environment;
 import org.springframework.core.io.ResourceLoader;
 import org.springframework.core.type.AnnotationMetadata;
-import org.springframework.core.type.ClassMetadata;
-import org.springframework.core.type.classreading.MetadataReader;
-import org.springframework.core.type.classreading.MetadataReaderFactory;
-import org.springframework.core.type.filter.AbstractClassTestingTypeFilter;
 import org.springframework.core.type.filter.AnnotationTypeFilter;
-import org.springframework.core.type.filter.TypeFilter;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.StringUtils;
@@ -58,6 +55,8 @@ import org.springframework.util.StringUtils;
  * @author Jakub Narloch
  * @author Venil Noronha
  * @author Gang Li
+ * @author Michal Domagala
+ * @author Marcin Grzejszczak
  */
 class FeignClientsRegistrar
 		implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
@@ -165,60 +164,43 @@ class FeignClientsRegistrar
 
 	public void registerFeignClients(AnnotationMetadata metadata,
 			BeanDefinitionRegistry registry) {
-		ClassPathScanningCandidateComponentProvider scanner = getScanner();
-		scanner.setResourceLoader(this.resourceLoader);
-
-		Set<String> basePackages;
 
+		LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet<>();
 		Map<String, Object> attrs = metadata
 				.getAnnotationAttributes(EnableFeignClients.class.getName());
-		AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
-				FeignClient.class);
 		final Class<?>[] clients = attrs == null ? null
 				: (Class<?>[]) attrs.get("clients");
 		if (clients == null || clients.length == 0) {
-			scanner.addIncludeFilter(annotationTypeFilter);
-			basePackages = getBasePackages(metadata);
+			ClassPathScanningCandidateComponentProvider scanner = getScanner();
+			scanner.setResourceLoader(this.resourceLoader);
+			scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));
+			Set<String> basePackages = getBasePackages(metadata);
+			for (String basePackage : basePackages) {
+				candidateComponents.addAll(scanner.findCandidateComponents(basePackage));
+			}
 		}
 		else {
-			final Set<String> clientClasses = new HashSet<>();
-			basePackages = new HashSet<>();
 			for (Class<?> clazz : clients) {
-				basePackages.add(ClassUtils.getPackageName(clazz));
-				clientClasses.add(clazz.getCanonicalName());
+				candidateComponents.add(new AnnotatedGenericBeanDefinition(clazz));
 			}
-			AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
-				@Override
-				protected boolean match(ClassMetadata metadata) {
-					String cleaned = metadata.getClassName().replaceAll("\\$", ".");
-					return clientClasses.contains(cleaned);
-				}
-			};
-			scanner.addIncludeFilter(
-					new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
 		}
 
-		for (String basePackage : basePackages) {
-			Set<BeanDefinition> candidateComponents = scanner
-					.findCandidateComponents(basePackage);
-			for (BeanDefinition candidateComponent : candidateComponents) {
-				if (candidateComponent instanceof AnnotatedBeanDefinition) {
-					// verify annotated class is an interface
-					AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
-					AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
-					Assert.isTrue(annotationMetadata.isInterface(),
-							"@FeignClient can only be specified on an interface");
+		for (BeanDefinition candidateComponent : candidateComponents) {
+			if (candidateComponent instanceof AnnotatedBeanDefinition) {
+				// verify annotated class is an interface
+				AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
+				AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
+				Assert.isTrue(annotationMetadata.isInterface(),
+						"@FeignClient can only be specified on an interface");
 
-					Map<String, Object> attributes = annotationMetadata
-							.getAnnotationAttributes(
-									FeignClient.class.getCanonicalName());
+				Map<String, Object> attributes = annotationMetadata
+						.getAnnotationAttributes(FeignClient.class.getCanonicalName());
 
-					String name = getClientName(attributes);
-					registerClientConfiguration(registry, name,
-							attributes.get("configuration"));
+				String name = getClientName(attributes);
+				registerClientConfiguration(registry, name,
+						attributes.get("configuration"));
 
-					registerFeignClient(registry, annotationMetadata, attributes);
-				}
+				registerFeignClient(registry, annotationMetadata, attributes);
 			}
 		}
 	}
@@ -226,24 +208,45 @@ class FeignClientsRegistrar
 	private void registerFeignClient(BeanDefinitionRegistry registry,
 			AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
 		String className = annotationMetadata.getClassName();
-		BeanDefinitionBuilder definition = BeanDefinitionBuilder
-				.genericBeanDefinition(FeignClientFactoryBean.class);
-		validate(attributes);
-		definition.addPropertyValue("url", getUrl(attributes));
-		definition.addPropertyValue("path", getPath(attributes));
+		Class clazz = ClassUtils.resolveClassName(className, null);
+		ConfigurableBeanFactory beanFactory = registry instanceof ConfigurableBeanFactory
+				? (ConfigurableBeanFactory) registry : null;
+		String contextId = getContextId(beanFactory, attributes);
 		String name = getName(attributes);
-		definition.addPropertyValue("name", name);
-		String contextId = getContextId(attributes);
-		definition.addPropertyValue("contextId", contextId);
-		definition.addPropertyValue("type", className);
-		definition.addPropertyValue("decode404", attributes.get("decode404"));
-		definition.addPropertyValue("fallback", attributes.get("fallback"));
-		definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
+		FeignClientFactoryBean factoryBean = new FeignClientFactoryBean();
+		factoryBean.setBeanFactory(beanFactory);
+		factoryBean.setName(name);
+		factoryBean.setContextId(contextId);
+		factoryBean.setType(clazz);
+		BeanDefinitionBuilder definition = BeanDefinitionBuilder
+				.genericBeanDefinition(clazz, () -> {
+					factoryBean.setUrl(getUrl(beanFactory, attributes));
+					factoryBean.setPath(getPath(beanFactory, attributes));
+					factoryBean.setDecode404(Boolean
+							.parseBoolean(String.valueOf(attributes.get("decode404"))));
+					Object fallback = attributes.get("fallback");
+					if (fallback != null) {
+						factoryBean.setFallback(fallback instanceof Class
+								? (Class<?>) fallback
+								: ClassUtils.resolveClassName(fallback.toString(), null));
+					}
+					Object fallbackFactory = attributes.get("fallbackFactory");
+					if (fallbackFactory != null) {
+						factoryBean.setFallbackFactory(fallbackFactory instanceof Class
+								? (Class<?>) fallbackFactory
+								: ClassUtils.resolveClassName(fallbackFactory.toString(),
+										null));
+					}
+					return factoryBean.getObject();
+				});
 		definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
+		definition.setLazyInit(true);
+		validate(attributes);
 
 		String alias = contextId + "FeignClient";
 		AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
 		beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);
+		beanDefinition.setAttribute("feignClientsRegistrarFactoryBean", factoryBean);
 
 		// has a default, won't be null
 		boolean primary = (Boolean) attributes.get("primary");
@@ -269,6 +272,10 @@ class FeignClientsRegistrar
 	}
 
 	/* for testing */ String getName(Map<String, Object> attributes) {
+		return getName(null, attributes);
+	}
+
+	String getName(ConfigurableBeanFactory beanFactory, Map<String, Object> attributes) {
 		String name = (String) attributes.get("serviceId");
 		if (!StringUtils.hasText(name)) {
 			name = (String) attributes.get("name");
@@ -276,34 +283,46 @@ class FeignClientsRegistrar
 		if (!StringUtils.hasText(name)) {
 			name = (String) attributes.get("value");
 		}
-		name = resolve(name);
+		name = resolve(beanFactory, name);
 		return getName(name);
 	}
 
-	private String getContextId(Map<String, Object> attributes) {
+	private String getContextId(ConfigurableBeanFactory beanFactory,
+			Map<String, Object> attributes) {
 		String contextId = (String) attributes.get("contextId");
 		if (!StringUtils.hasText(contextId)) {
 			return getName(attributes);
 		}
 
-		contextId = resolve(contextId);
+		contextId = resolve(beanFactory, contextId);
 		return getName(contextId);
 	}
 
-	private String resolve(String value) {
+	private String resolve(ConfigurableBeanFactory beanFactory, String value) {
 		if (StringUtils.hasText(value)) {
-			return this.environment.resolvePlaceholders(value);
+			if (beanFactory == null) {
+				return this.environment.resolvePlaceholders(value);
+			}
+			BeanExpressionResolver resolver = beanFactory.getBeanExpressionResolver();
+			String resolved = beanFactory.resolveEmbeddedValue(value);
+			if (resolver == null) {
+				return resolved;
+			}
+			return String.valueOf(resolver.evaluate(resolved,
+					new BeanExpressionContext(beanFactory, null)));
 		}
 		return value;
 	}
 
-	private String getUrl(Map<String, Object> attributes) {
-		String url = resolve((String) attributes.get("url"));
+	private String getUrl(ConfigurableBeanFactory beanFactory,
+			Map<String, Object> attributes) {
+		String url = resolve(beanFactory, (String) attributes.get("url"));
 		return getUrl(url);
 	}
 
-	private String getPath(Map<String, Object> attributes) {
-		String path = resolve((String) attributes.get("path"));
+	private String getPath(ConfigurableBeanFactory beanFactory,
+			Map<String, Object> attributes) {
+		String path = resolve(beanFactory, (String) attributes.get("path"));
 		return getPath(path);
 	}
 
@@ -398,38 +417,4 @@ class FeignClientsRegistrar
 		this.environment = environment;
 	}
 
-	/**
-	 * Helper class to create a {@link TypeFilter} that matches if all the delegates
-	 * match.
-	 *
-	 * @author Oliver Gierke
-	 */
-	private static class AllTypeFilter implements TypeFilter {
-
-		private final List<TypeFilter> delegates;
-
-		/**
-		 * Creates a new {@link AllTypeFilter} to match if all the given delegates match.
-		 * @param delegates must not be {@literal null}.
-		 */
-		AllTypeFilter(List<TypeFilter> delegates) {
-			Assert.notNull(delegates, "This argument is required, it must not be null");
-			this.delegates = delegates;
-		}
-
-		@Override
-		public boolean match(MetadataReader metadataReader,
-				MetadataReaderFactory metadataReaderFactory) throws IOException {
-
-			for (TypeFilter filter : this.delegates) {
-				if (!filter.match(metadataReader, metadataReaderFactory)) {
-					return false;
-				}
-			}
-
-			return true;
-		}
-
-	}
-
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/clientconfig/HttpClientFeignConfiguration.java

@@ -16,11 +16,14 @@
 
 package org.springframework.cloud.openfeign.clientconfig;
 
+import java.io.IOException;
 import java.util.Timer;
 import java.util.TimerTask;
 
 import javax.annotation.PreDestroy;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.config.RegistryBuilder;
 import org.apache.http.conn.HttpClientConnectionManager;
@@ -48,6 +51,8 @@ import org.springframework.context.annotation.Configuration;
 @ConditionalOnMissingBean(CloseableHttpClient.class)
 public class HttpClientFeignConfiguration {
 
+	private static final Log LOG = LogFactory.getLog(HttpClientFeignConfiguration.class);
+
 	private final Timer connectionManagerTimer = new Timer(
 			"FeignApacheHttpClientConfiguration.connectionManagerTimer", true);
 
@@ -113,10 +118,17 @@ public class HttpClientFeignConfiguration {
 	}
 
 	@PreDestroy
-	public void destroy() throws Exception {
+	public void destroy() {
 		this.connectionManagerTimer.cancel();
 		if (this.httpClient != null) {
-			this.httpClient.close();
+			try {
+				this.httpClient.close();
+			}
+			catch (IOException e) {
+				if (LOG.isErrorEnabled()) {
+					LOG.error("Could not correctly close httpClient.");
+				}
+			}
 		}
 	}
 

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/DefaultFeignLoadBalancerConfiguration.java

@@ -16,12 +16,20 @@
 
 package org.springframework.cloud.openfeign.loadbalancer;
 
+import java.util.List;
+
 import feign.Client;
 
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient;
 import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.core.annotation.AnnotationAwareOrderComparator;
 
 /**
  * Configuration instantiating a {@link BlockingLoadBalancerClient}-based {@link Client}
@@ -35,9 +43,24 @@ class DefaultFeignLoadBalancerConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
+	@Conditional(OnRetryNotEnabledCondition.class)
 	public Client feignClient(BlockingLoadBalancerClient loadBalancerClient) {
 		return new FeignBlockingLoadBalancerClient(new Client.Default(null, null),
 				loadBalancerClient);
 	}
 
+	@Bean
+	@ConditionalOnMissingBean
+	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
+	@ConditionalOnBean(LoadBalancedRetryFactory.class)
+	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled",
+			havingValue = "true", matchIfMissing = true)
+	public Client feignRetryClient(BlockingLoadBalancerClient loadBalancerClient,
+			List<LoadBalancedRetryFactory> loadBalancedRetryFactories) {
+		AnnotationAwareOrderComparator.sort(loadBalancedRetryFactories);
+		return new RetryableFeignBlockingLoadBalancerClient(
+				new Client.Default(null, null), loadBalancerClient,
+				loadBalancedRetryFactories.get(0));
+	}
+
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/FeignBlockingLoadBalancerClient.java

@@ -72,12 +72,15 @@ public class FeignBlockingLoadBalancerClient implements Client {
 		}
 		String reconstructedUrl = loadBalancerClient.reconstructURI(instance, originalUri)
 				.toString();
-		Request newRequest = Request.create(request.httpMethod(), reconstructedUrl,
-				request.headers(), request.body(), request.charset(),
-				request.requestTemplate());
+		Request newRequest = buildRequest(request, reconstructedUrl);
 		return delegate.execute(newRequest, options);
 	}
 
+	protected Request buildRequest(Request request, String reconstructedUrl) {
+		return Request.create(request.httpMethod(), reconstructedUrl, request.headers(),
+				request.body(), request.charset(), request.requestTemplate());
+	}
+
 	// Visible for Sleuth instrumentation
 	public Client getDelegate() {
 		return delegate;

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/HttpClientFeignLoadBalancerConfiguration.java

@@ -16,6 +16,8 @@
 
 package org.springframework.cloud.openfeign.loadbalancer;
 
+import java.util.List;
+
 import feign.Client;
 import feign.httpclient.ApacheHttpClient;
 import org.apache.http.client.HttpClient;
@@ -24,11 +26,14 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient;
 import org.springframework.cloud.openfeign.clientconfig.HttpClientFeignConfiguration;
 import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
+import org.springframework.core.annotation.AnnotationAwareOrderComparator;
 
 /**
  * Configuration instantiating a {@link BlockingLoadBalancerClient}-based {@link Client}
@@ -46,10 +51,26 @@ class HttpClientFeignLoadBalancerConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
+	@Conditional(OnRetryNotEnabledCondition.class)
 	public Client feignClient(BlockingLoadBalancerClient loadBalancerClient,
 			HttpClient httpClient) {
 		ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
 		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient);
 	}
 
+	@Bean
+	@ConditionalOnMissingBean
+	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
+	@ConditionalOnBean(LoadBalancedRetryFactory.class)
+	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled",
+			havingValue = "true", matchIfMissing = true)
+	public Client feignRetryClient(BlockingLoadBalancerClient loadBalancerClient,
+			HttpClient httpClient,
+			List<LoadBalancedRetryFactory> loadBalancedRetryFactories) {
+		AnnotationAwareOrderComparator.sort(loadBalancedRetryFactories);
+		ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
+		return new RetryableFeignBlockingLoadBalancerClient(delegate, loadBalancerClient,
+				loadBalancedRetryFactories.get(0));
+	}
+
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/OkHttpFeignLoadBalancerConfiguration.java

@@ -16,6 +16,8 @@
 
 package org.springframework.cloud.openfeign.loadbalancer;
 
+import java.util.List;
+
 import feign.Client;
 import feign.okhttp.OkHttpClient;
 
@@ -23,11 +25,14 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient;
 import org.springframework.cloud.openfeign.clientconfig.OkHttpFeignConfiguration;
 import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
+import org.springframework.core.annotation.AnnotationAwareOrderComparator;
 
 /**
  * Configuration instantiating a {@link BlockingLoadBalancerClient}-based {@link Client}
@@ -45,10 +50,26 @@ class OkHttpFeignLoadBalancerConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
+	@Conditional(OnRetryNotEnabledCondition.class)
 	public Client feignClient(okhttp3.OkHttpClient okHttpClient,
 			BlockingLoadBalancerClient loadBalancerClient) {
 		OkHttpClient delegate = new OkHttpClient(okHttpClient);
 		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient);
 	}
 
+	@Bean
+	@ConditionalOnMissingBean
+	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
+	@ConditionalOnBean(LoadBalancedRetryFactory.class)
+	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled",
+			havingValue = "true", matchIfMissing = true)
+	public Client feignRetryClient(BlockingLoadBalancerClient loadBalancerClient,
+			okhttp3.OkHttpClient okHttpClient,
+			List<LoadBalancedRetryFactory> loadBalancedRetryFactories) {
+		AnnotationAwareOrderComparator.sort(loadBalancedRetryFactories);
+		OkHttpClient delegate = new OkHttpClient(okHttpClient);
+		return new RetryableFeignBlockingLoadBalancerClient(delegate, loadBalancerClient,
+				loadBalancedRetryFactories.get(0));
+	}
+
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/OnRetryNotEnabledCondition.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign.loadbalancer;
+
+import org.springframework.boot.autoconfigure.condition.AnyNestedCondition;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
+import org.springframework.retry.support.RetryTemplate;
+
+/**
+ * A condition that verifies that {@link RetryTemplate} is on the classpath, a
+ * {@link LoadBalancedRetryFactory} bean is present and
+ * <code>spring.cloud.loadbalancer.retry.enabled</code> is not set to <code>false</code>.
+ *
+ * @author Olga Maciaszek-Sharma
+ * @since 2.2.6
+ */
+public class OnRetryNotEnabledCondition extends AnyNestedCondition {
+
+	public OnRetryNotEnabledCondition() {
+		super(ConfigurationPhase.REGISTER_BEAN);
+	}
+
+	@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
+	static class OnNoRetryTemplateCondition {
+
+	}
+
+	@ConditionalOnMissingBean(LoadBalancedRetryFactory.class)
+	static class OnRetryFactoryCondition {
+
+	}
+
+	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled",
+			havingValue = "false")
+	static class OnLoadBalancerRetryEnabledCondition {
+
+	}
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/RetryableFeignBlockingLoadBalancerClient.java

@@ -0,0 +1,188 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign.loadbalancer;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import feign.Client;
+import feign.Request;
+import feign.Response;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import org.springframework.cloud.client.ServiceInstance;
+import org.springframework.cloud.client.loadbalancer.InterceptorRetryPolicy;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRecoveryCallback;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy;
+import org.springframework.cloud.client.loadbalancer.RetryableStatusCodeException;
+import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpRequest;
+import org.springframework.retry.RetryListener;
+import org.springframework.retry.backoff.BackOffPolicy;
+import org.springframework.retry.backoff.NoBackOffPolicy;
+import org.springframework.retry.policy.NeverRetryPolicy;
+import org.springframework.retry.support.RetryTemplate;
+
+/**
+ * A {@link Client} implementation that provides Spring Retry support for requests
+ * load-balanced with Spring Cloud LoadBalancer.
+ *
+ * @author Olga Maciaszek-Sharma
+ * @since 2.2.6
+ */
+public class RetryableFeignBlockingLoadBalancerClient implements Client {
+
+	private static final Log LOG = LogFactory
+			.getLog(FeignBlockingLoadBalancerClient.class);
+
+	private final Client delegate;
+
+	private final BlockingLoadBalancerClient loadBalancerClient;
+
+	private final LoadBalancedRetryFactory loadBalancedRetryFactory;
+
+	public RetryableFeignBlockingLoadBalancerClient(Client delegate,
+			BlockingLoadBalancerClient loadBalancerClient,
+			LoadBalancedRetryFactory loadBalancedRetryFactory) {
+		this.delegate = delegate;
+		this.loadBalancerClient = loadBalancerClient;
+		this.loadBalancedRetryFactory = loadBalancedRetryFactory;
+	}
+
+	@Override
+	public Response execute(Request request, Request.Options options) throws IOException {
+		final URI originalUri = URI.create(request.url());
+		String serviceId = originalUri.getHost();
+		final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryFactory
+				.createRetryPolicy(serviceId, loadBalancerClient);
+		RetryTemplate retryTemplate = buildRetryTemplate(serviceId, request, retryPolicy);
+		return retryTemplate.execute(context -> {
+			Request feignRequest = null;
+			// On retries the policy will choose the server and set it in the context
+			// and extract the server and update the request being made
+			if (context instanceof LoadBalancedRetryContext) {
+				ServiceInstance serviceInstance = ((LoadBalancedRetryContext) context)
+						.getServiceInstance();
+				if (serviceInstance != null) {
+					if (LOG.isDebugEnabled()) {
+						LOG.debug(String.format(
+								"Using service instance from LoadBalancedRetryContext: %s",
+								serviceInstance));
+					}
+					String reconstructedUrl = loadBalancerClient
+							.reconstructURI(serviceInstance, originalUri).toString();
+					feignRequest = buildRequest(request, reconstructedUrl);
+				}
+			}
+			if (feignRequest == null) {
+				if (LOG.isWarnEnabled()) {
+					LOG.warn(
+							"Service instance was not resolved, executing the original request");
+				}
+				feignRequest = request;
+			}
+			Response response = delegate.execute(feignRequest, options);
+			int responseStatus = response.status();
+			if (retryPolicy != null && retryPolicy.retryableStatusCode(responseStatus)) {
+				if (LOG.isDebugEnabled()) {
+					LOG.debug(
+							String.format("Retrying on status code: %d", responseStatus));
+				}
+				response.close();
+				throw new RetryableStatusCodeException(serviceId, responseStatus,
+						response, URI.create(request.url()));
+			}
+			return response;
+		}, new LoadBalancedRecoveryCallback<Response, Response>() {
+			@Override
+			protected Response createResponse(Response response, URI uri) {
+				return response;
+			}
+		});
+	}
+
+	protected Request buildRequest(Request request, String reconstructedUrl) {
+		return Request.create(request.httpMethod(), reconstructedUrl, request.headers(),
+				request.body(), request.charset(), request.requestTemplate());
+	}
+
+	private RetryTemplate buildRetryTemplate(String serviceId, Request request,
+			LoadBalancedRetryPolicy retryPolicy) {
+		RetryTemplate retryTemplate = new RetryTemplate();
+		BackOffPolicy backOffPolicy = this.loadBalancedRetryFactory
+				.createBackOffPolicy(serviceId);
+		retryTemplate.setBackOffPolicy(
+				backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy);
+		RetryListener[] retryListeners = this.loadBalancedRetryFactory
+				.createRetryListeners(serviceId);
+		if (retryListeners != null && retryListeners.length != 0) {
+			retryTemplate.setListeners(retryListeners);
+		}
+
+		retryTemplate.setRetryPolicy(retryPolicy == null ? new NeverRetryPolicy()
+				: new InterceptorRetryPolicy(toHttpRequest(request), retryPolicy,
+						loadBalancerClient, serviceId));
+		return retryTemplate;
+	}
+
+	// Visible for Sleuth instrumentation
+	public Client getDelegate() {
+		return delegate;
+	}
+
+	private HttpRequest toHttpRequest(Request request) {
+		return new HttpRequest() {
+			@Override
+			public HttpMethod getMethod() {
+				return HttpMethod.resolve(request.httpMethod().name());
+			}
+
+			@Override
+			public String getMethodValue() {
+				return getMethod().name();
+			}
+
+			@Override
+			public URI getURI() {
+				return URI.create(request.url());
+			}
+
+			@Override
+			public HttpHeaders getHeaders() {
+				Map<String, List<String>> headers = new HashMap<>();
+				Map<String, Collection<String>> feignHeaders = request.headers();
+				for (String key : feignHeaders.keySet()) {
+					headers.put(key, new ArrayList<>(feignHeaders.get(key)));
+				}
+				HttpHeaders httpHeaders = new HttpHeaders();
+				httpHeaders.putAll(headers);
+				return httpHeaders;
+			}
+		};
+	}
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/ribbon/FeignLoadBalancer.java

@@ -26,7 +26,6 @@ import java.util.List;
 import java.util.Map;
 
 import com.netflix.client.AbstractLoadBalancerAwareClient;
-import com.netflix.client.ClientException;
 import com.netflix.client.ClientRequest;
 import com.netflix.client.IResponse;
 import com.netflix.client.RequestSpecificRetryHandler;
@@ -169,7 +168,7 @@ public class FeignLoadBalancer extends
 					Map<String, Collection<String>> feignHeaders = RibbonRequest.this
 							.toRequest().headers();
 					for (String key : feignHeaders.keySet()) {
-						headers.put(key, new ArrayList<String>(feignHeaders.get(key)));
+						headers.put(key, new ArrayList<>(feignHeaders.get(key)));
 					}
 					HttpHeaders httpHeaders = new HttpHeaders();
 					httpHeaders.putAll(headers);
@@ -206,7 +205,7 @@ public class FeignLoadBalancer extends
 		}
 
 		@Override
-		public Object getPayload() throws ClientException {
+		public Object getPayload() {
 			return this.response.body();
 		}
 

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/ribbon/RetryableFeignLoadBalancer.java

@@ -36,8 +36,6 @@ import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser;
 import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
 import org.springframework.cloud.netflix.ribbon.RibbonProperties;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
-import org.springframework.retry.RetryCallback;
-import org.springframework.retry.RetryContext;
 import org.springframework.retry.RetryListener;
 import org.springframework.retry.backoff.BackOffPolicy;
 import org.springframework.retry.backoff.NoBackOffPolicy;
@@ -91,39 +89,34 @@ public class RetryableFeignLoadBalancer extends FeignLoadBalancer
 		retryTemplate.setRetryPolicy(retryPolicy == null ? new NeverRetryPolicy()
 				: new FeignRetryPolicy(request.toHttpRequest(), retryPolicy, this,
 						this.getClientName()));
-		return retryTemplate.execute(new RetryCallback<RibbonResponse, IOException>() {
-			@Override
-			public RibbonResponse doWithRetry(RetryContext retryContext)
-					throws IOException {
-				Request feignRequest = null;
-				// on retries the policy will choose the server and set it in the context
-				// extract the server and update the request being made
-				if (retryContext instanceof LoadBalancedRetryContext) {
-					ServiceInstance service = ((LoadBalancedRetryContext) retryContext)
-							.getServiceInstance();
-					if (service != null) {
-						feignRequest = ((RibbonRequest) request
-								.replaceUri(reconstructURIWithServer(
-										new Server(service.getHost(), service.getPort()),
-										request.getUri()))).toRequest();
-					}
+		return retryTemplate.execute(retryContext -> {
+			Request feignRequest = null;
+			// on retries the policy will choose the server and set it in the context
+			// extract the server and update the request being made
+			if (retryContext instanceof LoadBalancedRetryContext) {
+				ServiceInstance service = ((LoadBalancedRetryContext) retryContext)
+						.getServiceInstance();
+				if (service != null) {
+					feignRequest = ((RibbonRequest) request
+							.replaceUri(reconstructURIWithServer(
+									new Server(service.getHost(), service.getPort()),
+									request.getUri()))).toRequest();
 				}
-				if (feignRequest == null) {
-					feignRequest = request.toRequest();
-				}
-				Response response = request.client().execute(feignRequest, options);
-				if (retryPolicy != null
-						&& retryPolicy.retryableStatusCode(response.status())) {
-					byte[] byteArray = response.body() == null ? new byte[] {}
-							: StreamUtils
-									.copyToByteArray(response.body().asInputStream());
-					response.close();
-					throw new RibbonResponseStatusCodeException(
-							RetryableFeignLoadBalancer.this.clientName, response,
-							byteArray, request.getUri());
-				}
-				return new RibbonResponse(request.getUri(), response);
 			}
+			if (feignRequest == null) {
+				feignRequest = request.toRequest();
+			}
+			Response response = request.client().execute(feignRequest, options);
+			if (retryPolicy != null
+					&& retryPolicy.retryableStatusCode(response.status())) {
+				byte[] byteArray = response.body() == null ? new byte[] {}
+						: StreamUtils.copyToByteArray(response.body().asInputStream());
+				response.close();
+				throw new RibbonResponseStatusCodeException(
+						RetryableFeignLoadBalancer.this.clientName, response, byteArray,
+						request.getUri());
+			}
+			return new RibbonResponse(request.getUri(), response);
 		}, new LoadBalancedRecoveryCallback<RibbonResponse, Response>() {
 			@Override
 			protected RibbonResponse createResponse(Response response, URI uri) {

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/PageJacksonModule.java

@@ -20,6 +20,7 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.function.Function;
 
+import com.fasterxml.jackson.annotation.JsonAlias;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.core.Version;
@@ -36,6 +37,7 @@ import org.springframework.data.domain.Sort;
  * This Jackson module provides support to deserialize Spring {@link Page} objects.
  *
  * @author Pascal Büttiker
+ * @author Olga Maciaszek-Sharma
  */
 public class PageJacksonModule extends Module {
 
@@ -65,7 +67,9 @@ public class PageJacksonModule extends Module {
 
 		SimplePageImpl(@JsonProperty("content") List<T> content,
 				@JsonProperty("number") int number, @JsonProperty("size") int size,
-				@JsonProperty("totalElements") long totalElements,
+				@JsonProperty("totalElements") @JsonAlias({ "total-elements",
+						"total_elements", "totalelements",
+						"TotalElements" }) long totalElements,
 				@JsonProperty("sort") Sort sort) {
 			PageRequest pageRequest;
 			if (sort != null) {

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/PageableSpringEncoder.java

@@ -120,7 +120,7 @@ public class PageableSpringEncoder implements Encoder {
 			}
 		}
 		for (Sort.Order order : sort) {
-			sortQueries.add(order.getProperty() + "," + order.getDirection());
+			sortQueries.add(order.getProperty() + "%2C" + order.getDirection());
 		}
 		if (!sortQueries.isEmpty()) {
 			template.query(sortParameter, sortQueries);

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/ResponseEntityDecoder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 the original author or authors.
+ * Copyright 2013-2021 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,16 +26,16 @@ import feign.Response;
 import feign.codec.Decoder;
 
 import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.util.LinkedMultiValueMap;
-import org.springframework.util.MultiValueMap;
 
 /**
  * Decoder adds compatibility for Spring MVC's ResponseEntity to any other decoder via
  * composition.
  *
  * @author chad jaros
+ * @author Olga Maciaszek-Sharma
  */
 public class ResponseEntityDecoder implements Decoder {
 
@@ -81,7 +81,7 @@ public class ResponseEntityDecoder implements Decoder {
 	@SuppressWarnings("unchecked")
 	private <T> ResponseEntity<T> createResponse(Object instance, Response response) {
 
-		MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
+		HttpHeaders headers = new HttpHeaders();
 		for (String key : response.headers().keySet()) {
 			headers.put(key, new LinkedList<>(response.headers().get(key)));
 		}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/SpringMvcContract.java

@@ -57,6 +57,7 @@ import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.core.io.DefaultResourceLoader;
 import org.springframework.core.io.ResourceLoader;
+import org.springframework.http.InvalidMediaTypeException;
 import org.springframework.http.MediaType;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
@@ -77,6 +78,7 @@ import static org.springframework.core.annotation.AnnotatedElementUtils.findMerg
  * @author Aaron Whiteside
  * @author Artyom Romanenko
  * @author Darren Foong
+ * @author Ram Anaswara
  */
 public class SpringMvcContract extends Contract.BaseContract
 		implements ResourceLoaderAware {
@@ -103,6 +105,8 @@ public class SpringMvcContract extends Contract.BaseContract
 
 	private ResourceLoader resourceLoader = new DefaultResourceLoader();
 
+	private boolean decodeSlash;
+
 	public SpringMvcContract() {
 		this(Collections.emptyList());
 	}
@@ -115,6 +119,12 @@ public class SpringMvcContract extends Contract.BaseContract
 	public SpringMvcContract(
 			List<AnnotatedParameterProcessor> annotatedParameterProcessors,
 			ConversionService conversionService) {
+		this(annotatedParameterProcessors, conversionService, true);
+	}
+
+	public SpringMvcContract(
+			List<AnnotatedParameterProcessor> annotatedParameterProcessors,
+			ConversionService conversionService, boolean decodeSlash) {
 		Assert.notNull(annotatedParameterProcessors,
 				"Parameter processors can not be null.");
 		Assert.notNull(conversionService, "ConversionService can not be null.");
@@ -125,6 +135,7 @@ public class SpringMvcContract extends Contract.BaseContract
 		annotatedArgumentProcessors = toAnnotatedArgumentProcessorMap(processors);
 		this.conversionService = conversionService;
 		convertingExpanderFactory = new ConvertingExpanderFactory(conversionService);
+		this.decodeSlash = decodeSlash;
 	}
 
 	private static TypeDescriptor createTypeDescriptor(Method method, int paramIndex) {
@@ -173,13 +184,17 @@ public class SpringMvcContract extends Contract.BaseContract
 		if (clz.getInterfaces().length == 0) {
 			RequestMapping classAnnotation = findMergedAnnotation(clz,
 					RequestMapping.class);
-			if (classAnnotation != null && classAnnotation.value().length > 0) {
+			if (classAnnotation != null) {
 				// Prepend path from class annotation if specified
-				String pathValue = emptyToNull(classAnnotation.value()[0]);
-				if (pathValue != null) {
+				if (classAnnotation.value().length > 0) {
+					String pathValue = emptyToNull(classAnnotation.value()[0]);
 					pathValue = resolve(pathValue);
-					if (!pathValue.equals("/")) {
-						data.template().uri(pathValue);
+					if (!pathValue.startsWith("/")) {
+						pathValue = "/" + pathValue;
+					}
+					data.template().uri(pathValue);
+					if (data.template().decodeSlash() != decodeSlash) {
+						data.template().decodeSlash(decodeSlash);
 					}
 				}
 			}
@@ -240,8 +255,13 @@ public class SpringMvcContract extends Contract.BaseContract
 			String pathValue = emptyToNull(methodMapping.value()[0]);
 			if (pathValue != null) {
 				pathValue = resolve(pathValue);
-				if (!pathValue.equals("/")) {
-					data.template().uri(pathValue, true);
+				// Append path from @RequestMapping if value is present on method
+				if (!pathValue.startsWith("/") && !data.template().path().endsWith("/")) {
+					pathValue = "/" + pathValue;
+				}
+				data.template().uri(pathValue, true);
+				if (data.template().decodeSlash() != decodeSlash) {
+					data.template().decodeSlash(decodeSlash);
 				}
 			}
 		}
@@ -405,7 +425,13 @@ public class SpringMvcContract extends Contract.BaseContract
 
 		if (contentTypes != null && !contentTypes.isEmpty()) {
 			String type = contentTypes.iterator().next();
-			return Objects.equals(MediaType.valueOf(type), MediaType.MULTIPART_FORM_DATA);
+			try {
+				return Objects.equals(MediaType.valueOf(type),
+						MediaType.MULTIPART_FORM_DATA);
+			}
+			catch (InvalidMediaTypeException ignored) {
+				return false;
+			}
 		}
 
 		return false;

spring-cloud-openfeign-core/src/main/resources/META-INF/additional-spring-configuration-metadata.json

@@ -8,6 +8,18 @@
 			"description": "If true, an OpenFeign client will be wrapped with a Hystrix circuit breaker.",
 			"defaultValue": "false"
 		},
+		{
+			"name": "feign.autoconfiguration.jackson.enabled",
+			"type": "java.lang.Boolean",
+			"description": "If true, PageJacksonModule and SortJacksonModule bean will be provided for Jackson page decoding.",
+			"defaultValue": "false"
+		},
+		{
+			"name": "feign.circuitbreaker.enabled",
+			"type": "java.lang.Boolean",
+			"description": "If true, an OpenFeign client will be wrapped with a Spring Cloud CircuitBreaker circuit breaker.",
+			"defaultValue": "false"
+		},
 		{
 			"name": "feign.httpclient.enabled",
 			"type": "java.lang.Boolean",

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/FeignBuilderCustomizerTests.java

@@ -0,0 +1,160 @@
+/*
+ * Copyright 2013-2019 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign;
+
+import java.lang.reflect.Field;
+
+import feign.Feign;
+import feign.Logger;
+import org.junit.Test;
+
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.core.annotation.Order;
+import org.springframework.util.ReflectionUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Matt King
+ */
+public class FeignBuilderCustomizerTests {
+
+	@Test
+	public void testBuilderCustomizer() {
+		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
+				FeignBuilderCustomizerTests.SampleConfiguration2.class);
+
+		FeignClientFactoryBean clientFactoryBean = context
+				.getBean(FeignClientFactoryBean.class);
+		FeignContext feignContext = context.getBean(FeignContext.class);
+
+		Feign.Builder builder = clientFactoryBean.feign(feignContext);
+		assertFeignBuilderField(builder, "logLevel", Logger.Level.HEADERS);
+		assertFeignBuilderField(builder, "decode404", true);
+
+		context.close();
+	}
+
+	private void assertFeignBuilderField(Feign.Builder builder, String fieldName,
+			Object expectedValue) {
+		Field builderField = ReflectionUtils.findField(Feign.Builder.class, fieldName);
+		ReflectionUtils.makeAccessible(builderField);
+
+		Object value = ReflectionUtils.getField(builderField, builder);
+		assertThat(value).as("Expected value for the field '" + fieldName + "':")
+				.isEqualTo(expectedValue);
+	}
+
+	@Test
+	public void testBuildCustomizerOrdered() {
+		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
+				FeignBuilderCustomizerTests.SampleConfiguration3.class);
+
+		FeignClientFactoryBean clientFactoryBean = context
+				.getBean(FeignClientFactoryBean.class);
+		FeignContext feignContext = context.getBean(FeignContext.class);
+
+		Feign.Builder builder = clientFactoryBean.feign(feignContext);
+		assertFeignBuilderField(builder, "logLevel", Logger.Level.FULL);
+		assertFeignBuilderField(builder, "decode404", true);
+
+		context.close();
+	}
+
+	private static FeignClientFactoryBean defaultFeignClientFactoryBean() {
+		FeignClientFactoryBean feignClientFactoryBean = new FeignClientFactoryBean();
+		feignClientFactoryBean.setContextId("test");
+		feignClientFactoryBean.setName("test");
+		feignClientFactoryBean.setType(FeignClientFactoryTests.TestType.class);
+		feignClientFactoryBean.setPath("");
+		feignClientFactoryBean.setUrl("http://some.absolute.url");
+		return feignClientFactoryBean;
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@Import(FeignClientsConfiguration.class)
+	protected static class SampleConfiguration2 {
+
+		@Bean
+		FeignContext feignContext() {
+			return new FeignContext();
+		}
+
+		@Bean
+		FeignClientProperties feignClientProperties() {
+			return new FeignClientProperties();
+		}
+
+		@Bean
+		FeignBuilderCustomizer feignBuilderCustomizer() {
+			return builder -> builder.logLevel(Logger.Level.HEADERS);
+		}
+
+		@Bean
+		FeignBuilderCustomizer feignBuilderCustomizer2() {
+			return Feign.Builder::decode404;
+		}
+
+		@Bean
+		FeignClientFactoryBean feignClientFactoryBean() {
+			return defaultFeignClientFactoryBean();
+		}
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@Import(FeignClientsConfiguration.class)
+	protected static class SampleConfiguration3 {
+
+		@Bean
+		FeignContext feignContext() {
+			return new FeignContext();
+		}
+
+		@Bean
+		FeignClientProperties feignClientProperties() {
+			return new FeignClientProperties();
+		}
+
+		@Bean
+		@Order(1)
+		FeignBuilderCustomizer feignBuilderCustomizer() {
+			return builder -> builder.logLevel(Logger.Level.HEADERS);
+		}
+
+		@Bean
+		@Order(2)
+		FeignBuilderCustomizer feignBuilderCustomizer1() {
+			return builder -> builder.logLevel(Logger.Level.FULL);
+		}
+
+		@Bean
+		FeignBuilderCustomizer feignBuilderCustomizer2() {
+			return Feign.Builder::decode404;
+		}
+
+		@Bean
+		FeignClientFactoryBean feignClientFactoryBean() {
+			return defaultFeignClientFactoryBean();
+		}
+
+	}
+
+}

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/FeignClientOverrideDefaultsTests.java

@@ -24,7 +24,6 @@ import feign.QueryMapEncoder;
 import feign.Request;
 import feign.RequestInterceptor;
 import feign.RequestLine;
-import feign.RequestTemplate;
 import feign.Retryer;
 import feign.auth.BasicAuthRequestInterceptor;
 import feign.codec.Decoder;
@@ -34,8 +33,7 @@ import feign.hystrix.HystrixFeign;
 import feign.optionals.OptionalDecoder;
 import feign.querymap.BeanQueryMapEncoder;
 import feign.slf4j.Slf4jLogger;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration;
@@ -47,7 +45,6 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
 import org.springframework.test.annotation.DirtiesContext;
-import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 
@@ -56,10 +53,9 @@ import static org.assertj.core.api.Assertions.assertThat;
 /**
  * @author Spencer Gibb
  */
-@RunWith(SpringJUnit4ClassRunner.class)
 @SpringBootTest(classes = FeignClientOverrideDefaultsTests.TestConfiguration.class)
 @DirtiesContext
-public class FeignClientOverrideDefaultsTests {
+class FeignClientOverrideDefaultsTests {
 
 	@Autowired
 	private FeignContext context;
@@ -71,92 +67,89 @@ public class FeignClientOverrideDefaultsTests {
 	private BarClient bar;
 
 	@Test
-	public void clientsAvailable() {
-		assertThat(this.foo).isNotNull();
-		assertThat(this.bar).isNotNull();
+	void clientsAvailable() {
+		assertThat(foo).isNotNull();
+		assertThat(bar).isNotNull();
 	}
 
 	@Test
-	public void overrideDecoder() {
-		Decoder.Default.class.cast(this.context.getInstance("foo", Decoder.class));
-		OptionalDecoder.class.cast(this.context.getInstance("bar", Decoder.class));
+	void overrideDecoder() {
+		Decoder.Default.class.cast(context.getInstance("foo", Decoder.class));
+		OptionalDecoder.class.cast(context.getInstance("bar", Decoder.class));
 	}
 
 	@Test
-	public void overrideEncoder() {
-		Encoder.Default.class.cast(this.context.getInstance("foo", Encoder.class));
-		PageableSpringEncoder.class.cast(this.context.getInstance("bar", Encoder.class));
+	void overrideEncoder() {
+		Encoder.Default.class.cast(context.getInstance("foo", Encoder.class));
+		PageableSpringEncoder.class.cast(context.getInstance("bar", Encoder.class));
 	}
 
 	@Test
-	public void overrideLogger() {
-		Logger.JavaLogger.class.cast(this.context.getInstance("foo", Logger.class));
-		Slf4jLogger.class.cast(this.context.getInstance("bar", Logger.class));
+	void overrideLogger() {
+		Logger.JavaLogger.class.cast(context.getInstance("foo", Logger.class));
+		Slf4jLogger.class.cast(context.getInstance("bar", Logger.class));
 	}
 
 	@Test
-	public void overrideContract() {
-		Contract.Default.class.cast(this.context.getInstance("foo", Contract.class));
-		SpringMvcContract.class.cast(this.context.getInstance("bar", Contract.class));
+	void overrideContract() {
+		Contract.Default.class.cast(context.getInstance("foo", Contract.class));
+		SpringMvcContract.class.cast(context.getInstance("bar", Contract.class));
 	}
 
 	@Test
-	public void overrideLoggerLevel() {
-		assertThat(this.context.getInstance("foo", Logger.Level.class)).isNull();
-		assertThat(this.context.getInstance("bar", Logger.Level.class))
+	void overrideLoggerLevel() {
+		assertThat(context.getInstance("foo", Logger.Level.class)).isNull();
+		assertThat(context.getInstance("bar", Logger.Level.class))
 				.isEqualTo(Logger.Level.HEADERS);
 	}
 
 	@Test
-	public void overrideRetryer() {
-		assertThat(this.context.getInstance("foo", Retryer.class))
+	void overrideRetryer() {
+		assertThat(context.getInstance("foo", Retryer.class))
 				.isEqualTo(Retryer.NEVER_RETRY);
-		Retryer.Default.class.cast(this.context.getInstance("bar", Retryer.class));
+		Retryer.Default.class.cast(context.getInstance("bar", Retryer.class));
 	}
 
 	@Test
-	public void overrideErrorDecoder() {
-		assertThat(this.context.getInstance("foo", ErrorDecoder.class)).isNull();
-		ErrorDecoder.Default.class
-				.cast(this.context.getInstance("bar", ErrorDecoder.class));
+	void overrideErrorDecoder() {
+		assertThat(context.getInstance("foo", ErrorDecoder.class)).isNull();
+		ErrorDecoder.Default.class.cast(context.getInstance("bar", ErrorDecoder.class));
 	}
 
 	@Test
-	public void overrideBuilder() {
-		HystrixFeign.Builder.class
-				.cast(this.context.getInstance("foo", Feign.Builder.class));
-		Feign.Builder.class.cast(this.context.getInstance("bar", Feign.Builder.class));
+	void overrideBuilder() {
+		HystrixFeign.Builder.class.cast(context.getInstance("foo", Feign.Builder.class));
+		Feign.Builder.class.cast(context.getInstance("bar", Feign.Builder.class));
 	}
 
 	@Test
-	public void overrideRequestOptions() {
-		assertThat(this.context.getInstance("foo", Request.Options.class)).isNull();
-		Request.Options options = this.context.getInstance("bar", Request.Options.class);
+	void overrideRequestOptions() {
+		assertThat(context.getInstance("foo", Request.Options.class)).isNull();
+		Request.Options options = context.getInstance("bar", Request.Options.class);
 		assertThat(options.connectTimeoutMillis()).isEqualTo(1);
 		assertThat(options.readTimeoutMillis()).isEqualTo(1);
 	}
 
 	@Test
-	public void overrideQueryMapEncoder() {
+	void overrideQueryMapEncoder() {
 		QueryMapEncoder.Default.class
-				.cast(this.context.getInstance("foo", QueryMapEncoder.class));
-		BeanQueryMapEncoder.class
-				.cast(this.context.getInstance("bar", QueryMapEncoder.class));
+				.cast(context.getInstance("foo", QueryMapEncoder.class));
+		BeanQueryMapEncoder.class.cast(context.getInstance("bar", QueryMapEncoder.class));
 	}
 
 	@Test
-	public void addRequestInterceptor() {
-		assertThat(this.context.getInstances("foo", RequestInterceptor.class).size())
+	void addRequestInterceptor() {
+		assertThat(context.getInstances("foo", RequestInterceptor.class).size())
 				.isEqualTo(1);
-		assertThat(this.context.getInstances("bar", RequestInterceptor.class).size())
+		assertThat(context.getInstances("bar", RequestInterceptor.class).size())
 				.isEqualTo(2);
 	}
 
 	@Test
-	public void exceptionPropagationPolicy() {
-		assertThat(this.context.getInstances("foo", ExceptionPropagationPolicy.class))
-				.isNull();
-		assertThat(this.context.getInstances("bar", ExceptionPropagationPolicy.class))
+	void exceptionPropagationPolicy() {
+		assertThat(context.getInstances("foo", ExceptionPropagationPolicy.class))
+				.isEmpty();
+		assertThat(context.getInstances("bar", ExceptionPropagationPolicy.class))
 				.containsValues(ExceptionPropagationPolicy.UNWRAP);
 	}
 
@@ -186,10 +179,7 @@ public class FeignClientOverrideDefaultsTests {
 
 		@Bean
 		RequestInterceptor defaultRequestInterceptor() {
-			return new RequestInterceptor() {
-				@Override
-				public void apply(RequestTemplate template) {
-				}
+			return template -> {
 			};
 		}
 

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/FeignClientUsingConfigurerTest.java

@@ -26,10 +26,10 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.cloud.openfeign.clientconfig.FeignClientConfigurer;
-import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.test.annotation.DirtiesContext;
@@ -49,18 +49,19 @@ import static org.assertj.core.api.Assertions.assertThat;
 		"feign.client.config.default.requestInterceptors[1]=org.springframework.cloud.openfeign.FeignClientUsingPropertiesTests.BarRequestInterceptor" })
 public class FeignClientUsingConfigurerTest {
 
-	private static final String BEAN_NAME_PREFIX = "&org.springframework.cloud.openfeign.FeignClientUsingConfigurerTest$";
+	private static final String BEAN_NAME_PREFIX = "org.springframework.cloud.openfeign.FeignClientUsingConfigurerTest$";
 
 	@Autowired
-	private ApplicationContext applicationContext;
+	private ConfigurableListableBeanFactory beanFactory;
 
 	@Autowired
 	private FeignContext context;
 
 	@Test
 	public void testFeignClient() {
-		FeignClientFactoryBean factoryBean = (FeignClientFactoryBean) applicationContext
-				.getBean(BEAN_NAME_PREFIX + "TestFeignClient");
+		FeignClientFactoryBean factoryBean = (FeignClientFactoryBean) beanFactory
+				.getBeanDefinition(BEAN_NAME_PREFIX + "TestFeignClient")
+				.getAttribute("feignClientsRegistrarFactoryBean");
 		Feign.Builder builder = factoryBean.feign(context);
 
 		List<RequestInterceptor> interceptors = (List) getBuilderValue(builder,
@@ -79,8 +80,9 @@ public class FeignClientUsingConfigurerTest {
 
 	@Test
 	public void testNoInheritFeignClient() {
-		FeignClientFactoryBean factoryBean = (FeignClientFactoryBean) applicationContext
-				.getBean(BEAN_NAME_PREFIX + "NoInheritFeignClient");
+		FeignClientFactoryBean factoryBean = (FeignClientFactoryBean) beanFactory
+				.getBeanDefinition(BEAN_NAME_PREFIX + "NoInheritFeignClient")
+				.getAttribute("feignClientsRegistrarFactoryBean");
 		Feign.Builder builder = factoryBean.feign(context);
 
 		List<RequestInterceptor> interceptors = (List) getBuilderValue(builder,
@@ -93,8 +95,9 @@ public class FeignClientUsingConfigurerTest {
 
 	@Test
 	public void testNoInheritFeignClient_ignoreProperties() {
-		FeignClientFactoryBean factoryBean = (FeignClientFactoryBean) applicationContext
-				.getBean(BEAN_NAME_PREFIX + "NoInheritFeignClient");
+		FeignClientFactoryBean factoryBean = (FeignClientFactoryBean) beanFactory
+				.getBeanDefinition(BEAN_NAME_PREFIX + "NoInheritFeignClient")
+				.getAttribute("feignClientsRegistrarFactoryBean");
 		Feign.Builder builder = factoryBean.feign(context);
 
 		assertThat(getBuilderValue(builder, "logLevel")).as("log level not set")

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/FeignClientUsingPropertiesTests.java

@@ -22,9 +22,15 @@ import java.lang.reflect.Proxy;
 import java.lang.reflect.Type;
 import java.net.SocketTimeoutException;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import javax.servlet.http.HttpServletRequest;
 
@@ -55,8 +61,11 @@ import org.springframework.test.context.TestPropertySource;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.test.util.ReflectionTestUtils;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestHeader;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -66,6 +75,7 @@ import static org.springframework.boot.test.context.SpringBootTest.WebEnvironmen
 /**
  * @author Eko Kurniawan Khannedy
  * @author Olga Maciaszek-Sharma
+ * @author Ilia Ilinykh
  */
 @SuppressWarnings("FieldMayBeFinal")
 @RunWith(SpringJUnit4ClassRunner.class)
@@ -92,6 +102,10 @@ public class FeignClientUsingPropertiesTests {
 
 	private FeignClientFactoryBean formFactoryBean;
 
+	private FeignClientFactoryBean defaultHeadersAndQuerySingleParamsFeignClientFactoryBean;
+
+	private FeignClientFactoryBean defaultHeadersAndQueryMultipleParamsFeignClientFactoryBean;
+
 	public FeignClientUsingPropertiesTests() {
 		fooFactoryBean = new FeignClientFactoryBean();
 		fooFactoryBean.setContextId("foo");
@@ -108,6 +122,18 @@ public class FeignClientUsingPropertiesTests {
 		formFactoryBean = new FeignClientFactoryBean();
 		formFactoryBean.setContextId("form");
 		formFactoryBean.setType(FeignClientFactoryBean.class);
+
+		this.defaultHeadersAndQuerySingleParamsFeignClientFactoryBean = new FeignClientFactoryBean();
+		this.defaultHeadersAndQuerySingleParamsFeignClientFactoryBean
+				.setContextId("singleValue");
+		this.defaultHeadersAndQuerySingleParamsFeignClientFactoryBean
+				.setType(FeignClientFactoryBean.class);
+
+		this.defaultHeadersAndQueryMultipleParamsFeignClientFactoryBean = new FeignClientFactoryBean();
+		this.defaultHeadersAndQueryMultipleParamsFeignClientFactoryBean
+				.setContextId("multipleValue");
+		this.defaultHeadersAndQueryMultipleParamsFeignClientFactoryBean
+				.setType(FeignClientFactoryBean.class);
 	}
 
 	public FooClient fooClient() {
@@ -159,6 +185,35 @@ public class FeignClientUsingPropertiesTests {
 		assertThat(response).isEqualTo("Data");
 	}
 
+	@Test
+	public void testSingleValue() {
+		List<String> response = singleValueClient().singleValue();
+		assertThat(response).isEqualTo(Arrays.asList("header", "parameter"));
+	}
+
+	@Test
+	public void testMultipleValue() {
+		List<String> response = multipleValueClient().multipleValue();
+		assertThat(response).isEqualTo(
+				Arrays.asList("header1", "header2", "parameter1", "parameter2"));
+	}
+
+	public SingleValueClient singleValueClient() {
+		this.defaultHeadersAndQuerySingleParamsFeignClientFactoryBean
+				.setApplicationContext(this.applicationContext);
+		return this.defaultHeadersAndQuerySingleParamsFeignClientFactoryBean
+				.feign(this.context)
+				.target(SingleValueClient.class, "http://localhost:" + this.port);
+	}
+
+	public MultipleValueClient multipleValueClient() {
+		this.defaultHeadersAndQueryMultipleParamsFeignClientFactoryBean
+				.setApplicationContext(this.applicationContext);
+		return this.defaultHeadersAndQueryMultipleParamsFeignClientFactoryBean
+				.feign(this.context)
+				.target(MultipleValueClient.class, "http://localhost:" + this.port);
+	}
+
 	@Test
 	public void readTimeoutShouldWorkWhenConnectTimeoutNotSet() {
 		FeignClientFactoryBean readTimeoutFactoryBean = new FeignClientFactoryBean();
@@ -202,21 +257,21 @@ public class FeignClientUsingPropertiesTests {
 
 	protected interface FooClient {
 
-		@RequestMapping(method = RequestMethod.GET, value = "/foo")
+		@GetMapping(path = "/foo")
 		String foo();
 
 	}
 
 	protected interface BarClient {
 
-		@RequestMapping(method = RequestMethod.GET, value = "/bar")
+		@GetMapping(path = "/bar")
 		String bar();
 
 	}
 
 	protected interface UnwrapClient {
 
-		@RequestMapping(method = RequestMethod.GET, value = "/bar") // intentionally /bar
+		@GetMapping(path = "/bar") // intentionally /bar
 		String unwrap() throws IOException;
 
 	}
@@ -229,6 +284,20 @@ public class FeignClientUsingPropertiesTests {
 
 	}
 
+	protected interface SingleValueClient {
+
+		@GetMapping(path = "/singleValue")
+		List<String> singleValue();
+
+	}
+
+	protected interface MultipleValueClient {
+
+		@GetMapping(path = "/multipleValue")
+		List<String> multipleValue();
+
+	}
+
 	protected interface TimeoutClient {
 
 		@GetMapping("/timeouts")
@@ -253,18 +322,33 @@ public class FeignClientUsingPropertiesTests {
 			}
 		}
 
-		@RequestMapping(method = RequestMethod.GET, value = "/bar")
+		@GetMapping(path = "/bar")
 		public String bar() throws InterruptedException {
-			Thread.sleep(2000L);
+			TimeUnit.SECONDS.sleep(2);
 			return "OK";
 		}
 
-		@RequestMapping(value = "/form", method = RequestMethod.POST,
+		@PostMapping(path = "/form",
 				consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE)
 		public String form(HttpServletRequest request) {
 			return request.getParameter("form");
 		}
 
+		@GetMapping(path = "/singleValue")
+		public List<String> singleValue(@RequestHeader List<String> singleValueHeaders,
+				@RequestParam List<String> singleValueParameters) {
+			return Stream.of(singleValueHeaders, singleValueParameters)
+					.flatMap(Collection::stream).collect(Collectors.toList());
+		}
+
+		@GetMapping(path = "/multipleValue")
+		public List<String> multipleValue(
+				@RequestHeader List<String> multipleValueHeaders,
+				@RequestParam List<String> multipleValueParameters) {
+			return Stream.of(multipleValueHeaders, multipleValueParameters)
+					.flatMap(Collection::stream).collect(Collectors.toList());
+		}
+
 	}
 
 	public static class FooRequestInterceptor implements RequestInterceptor {

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/FeignClientsRegistrarTests.java

@@ -20,7 +20,9 @@ import java.util.Collections;
 
 import org.junit.Test;
 
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.cloud.openfeign.test.TestAutoConfiguration;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.mock.env.MockEnvironment;
@@ -28,10 +30,12 @@ import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
 
 /**
  * @author Spencer Gibb
  * @author Gang Li
+ * @author Michal Domagala
  */
 public class FeignClientsRegistrarTests {
 
@@ -89,6 +93,18 @@ public class FeignClientsRegistrarTests {
 		new AnnotationConfigApplicationContext(FallbackFactoryTestConfig.class);
 	}
 
+	@Test
+	public void shouldPassSubLevelFeignClient() {
+		AnnotationConfigApplicationContext config = new AnnotationConfigApplicationContext();
+		((DefaultListableBeanFactory) config.getBeanFactory())
+				.setAllowBeanDefinitionOverriding(false);
+		config.register(TopLevelSubLevelTestConfig.class);
+		assertThatCode(() -> config.refresh()).as(
+				"Case https://github.com/spring-cloud/spring-cloud-openfeign/issues/331 should be solved")
+				.doesNotThrowAnyException();
+
+	}
+
 	@FeignClient(name = "fallbackTestClient", url = "http://localhost:8080/",
 			fallback = FallbackClient.class)
 	protected interface FallbackClient {
@@ -122,4 +138,12 @@ public class FeignClientsRegistrarTests {
 
 	}
 
+	@EnableFeignClients(clients = {
+			org.springframework.cloud.openfeign.feignclientsregistrar.TopLevelClient.class,
+			org.springframework.cloud.openfeign.feignclientsregistrar.sub.SubLevelClient.class })
+	@EnableAutoConfiguration(exclude = TestAutoConfiguration.class)
+	protected static class TopLevelSubLevelTestConfig {
+
+	}
+
 }

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/SpringDecoderTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 the original author or authors.
+ * Copyright 2013-2021 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -32,7 +32,9 @@ import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
 import org.springframework.cloud.openfeign.test.NoSecurityConfiguration;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
+import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.test.annotation.DirtiesContext;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@@ -45,6 +47,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * @author Spencer Gibb
+ * @author Olga Maciaszek-Sharma
  */
 @RunWith(SpringJUnit4ClassRunner.class)
 @SpringBootTest(classes = SpringDecoderTests.Application.class,
@@ -152,6 +155,14 @@ public class SpringDecoderTests extends FeignClientFactoryBean {
 		assertThat(response.getBody()).as("response body was not null").isNull();
 	}
 
+	@Test
+	// Issue: https://github.com/spring-cloud/spring-cloud-openfeign/issues/456
+	public void testResponseEntityHeaders() {
+		ResponseEntity<String> response = testClient().getContentType();
+		assertThat(response.getHeaders().getContentType())
+				.isEqualTo(MediaType.APPLICATION_JSON);
+	}
+
 	protected interface TestClient {
 
 		@RequestMapping(method = RequestMethod.GET, value = "/helloresponse")
@@ -175,6 +186,9 @@ public class SpringDecoderTests extends FeignClientFactoryBean {
 		@GetMapping("/helloWildcard")
 		ResponseEntity<?> getWildcard();
 
+		@GetMapping(path = "/contentType", produces = MediaType.APPLICATION_JSON_VALUE)
+		ResponseEntity<String> getContentType();
+
 	}
 
 	public static class Hello {
@@ -262,6 +276,13 @@ public class SpringDecoderTests extends FeignClientFactoryBean {
 			return ResponseEntity.ok(new Hello("wildcard"));
 		}
 
+		@Override
+		public ResponseEntity<String> getContentType() {
+			return ResponseEntity.ok()
+					.header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
+					.body("test");
+		}
+
 	}
 
 }

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/circuitbreaker/CircuitBreakerTests.java

@@ -0,0 +1,250 @@
+/*
+ * Copyright 2013-2021 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign.circuitbreaker;
+
+import java.util.function.Function;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.boot.web.server.LocalServerPort;
+import org.springframework.cloud.client.circuitbreaker.CircuitBreaker;
+import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
+import org.springframework.cloud.client.circuitbreaker.ConfigBuilder;
+import org.springframework.cloud.client.circuitbreaker.NoFallbackAvailableException;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.cloud.openfeign.FallbackFactory;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.cloud.openfeign.test.NoSecurityConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.stereotype.Component;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.util.SocketUtils;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Spencer Gibb
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@SpringBootTest(classes = CircuitBreakerTests.Application.class,
+		webEnvironment = WebEnvironment.DEFINED_PORT,
+		value = { "spring.application.name=springcircuittest", "spring.jmx.enabled=false",
+				"feign.circuitbreaker.enabled=true" })
+@DirtiesContext
+public class CircuitBreakerTests {
+
+	@Autowired
+	MyCircuitBreaker myCircuitBreaker;
+
+	@Autowired
+	TestClient testClient;
+
+	@Autowired
+	TestClientWithFactory testClientWithFactory;
+
+	@LocalServerPort
+	private int port = 0;
+
+	@BeforeAll
+	public static void beforeClass() {
+		System.setProperty("server.port",
+				String.valueOf(SocketUtils.findAvailableTcpPort()));
+	}
+
+	@AfterAll
+	public static void afterClass() {
+		System.clearProperty("server.port");
+	}
+
+	@Before
+	public void setup() {
+		this.myCircuitBreaker.clear();
+	}
+
+	@Test
+	public void testSimpleTypeWithFallback() {
+		Hello hello = testClient.getHello();
+
+		assertThat(hello).as("hello was null").isNotNull();
+		assertThat(hello).as("first hello didn't match")
+				.isEqualTo(new Hello("hello world 1"));
+		assertThat(myCircuitBreaker.runWasCalled).as("Circuit Breaker was called")
+				.isTrue();
+	}
+
+	@Test
+	public void test404WithFallback() {
+		assertThat(testClient.getException()).isEqualTo("Fixed response");
+	}
+
+	@Test
+	public void testSimpleTypeWithFallbackFactory() {
+		Hello hello = testClientWithFactory.getHello();
+
+		assertThat(hello).as("hello was null").isNotNull();
+		assertThat(hello).as("first hello didn't match")
+				.isEqualTo(new Hello("hello world 1"));
+		assertThat(myCircuitBreaker.runWasCalled).as("Circuit Breaker was called")
+				.isTrue();
+	}
+
+	@Test
+	public void test404WithFallbackFactory() {
+		assertThat(testClientWithFactory.getException()).isEqualTo("Fixed response");
+	}
+
+	// tag::client_with_fallback[]
+	@FeignClient(name = "test", url = "http://localhost:${server.port}/",
+			fallback = Fallback.class)
+	protected interface TestClient {
+
+		@RequestMapping(method = RequestMethod.GET, value = "/hello")
+		Hello getHello();
+
+		@RequestMapping(method = RequestMethod.GET, value = "/hellonotfound")
+		String getException();
+
+	}
+
+	@Component
+	static class Fallback implements TestClient {
+
+		@Override
+		public Hello getHello() {
+			throw new NoFallbackAvailableException("Boom!", new RuntimeException());
+		}
+
+		@Override
+		public String getException() {
+			return "Fixed response";
+		}
+
+	}
+	// end::client_with_fallback[]
+
+	// tag::client_with_fallback_factory[]
+	@FeignClient(name = "testClientWithFactory", url = "http://localhost:${server.port}/",
+			fallbackFactory = TestFallbackFactory.class)
+	protected interface TestClientWithFactory {
+
+		@RequestMapping(method = RequestMethod.GET, value = "/hello")
+		Hello getHello();
+
+		@RequestMapping(method = RequestMethod.GET, value = "/hellonotfound")
+		String getException();
+
+	}
+
+	@Component
+	static class TestFallbackFactory implements FallbackFactory<FallbackWithFactory> {
+
+		@Override
+		public FallbackWithFactory create(Throwable cause) {
+			return new FallbackWithFactory();
+		}
+
+	}
+
+	static class FallbackWithFactory implements TestClientWithFactory {
+
+		@Override
+		public Hello getHello() {
+			throw new NoFallbackAvailableException("Boom!", new RuntimeException());
+		}
+
+		@Override
+		public String getException() {
+			return "Fixed response";
+		}
+
+	}
+	// end::client_with_fallback_factory[]
+
+	@Configuration(proxyBeanMethods = false)
+	@EnableAutoConfiguration
+	@RestController
+	@EnableFeignClients(clients = { TestClient.class, TestClientWithFactory.class })
+	@Import(NoSecurityConfiguration.class)
+	protected static class Application implements TestClient {
+
+		static final Log log = LogFactory.getLog(Application.class);
+
+		@Bean
+		MyCircuitBreaker myCircuitBreaker() {
+			return new MyCircuitBreaker();
+		}
+
+		@Bean
+		CircuitBreakerFactory circuitBreakerFactory(MyCircuitBreaker myCircuitBreaker) {
+			return new CircuitBreakerFactory() {
+				@Override
+				public CircuitBreaker create(String id) {
+					log.info("Creating a circuit breaker with id [" + id + "]");
+					return myCircuitBreaker;
+				}
+
+				@Override
+				protected ConfigBuilder configBuilder(String id) {
+					return Object::new;
+				}
+
+				@Override
+				public void configureDefault(Function defaultConfiguration) {
+
+				}
+			};
+		}
+
+		@Override
+		public Hello getHello() {
+			return new Hello("hello world 1");
+		}
+
+		@Override
+		public String getException() {
+			throw new IllegalStateException("BOOM!");
+		}
+
+		@Bean
+		Fallback fallback() {
+			return new Fallback();
+		}
+
+		@Bean
+		TestFallbackFactory testFallbackFactory() {
+			return new TestFallbackFactory();
+		}
+
+	}
+
+}

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/circuitbreaker/CircuitBreakerWithNoFallbackTests.java

@@ -0,0 +1,159 @@
+/*
+ * Copyright 2013-2021 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign.circuitbreaker;
+
+import java.util.function.Function;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.cloud.client.circuitbreaker.CircuitBreaker;
+import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
+import org.springframework.cloud.client.circuitbreaker.ConfigBuilder;
+import org.springframework.cloud.client.circuitbreaker.NoFallbackAvailableException;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.cloud.openfeign.test.NoSecurityConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.util.SocketUtils;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/**
+ * Tests for Feign calls with CircuitBreaker, without fallbacks.
+ *
+ * @author Olga Maciaszek-Sharma
+ */
+@SpringBootTest(classes = CircuitBreakerWithNoFallbackTests.Application.class,
+		webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT,
+		value = { "spring.application.name=springcircuittest", "spring.jmx.enabled=false",
+				"feign.circuitbreaker.enabled=true" })
+@DirtiesContext
+public class CircuitBreakerWithNoFallbackTests {
+
+	@Autowired
+	MyCircuitBreaker myCircuitBreaker;
+
+	@Autowired
+	CircuitBreakerTestClient testClient;
+
+	@BeforeAll
+	public static void beforeClass() {
+		System.setProperty("server.port",
+				String.valueOf(SocketUtils.findAvailableTcpPort()));
+	}
+
+	@AfterAll
+	public static void afterClass() {
+		System.clearProperty("server.port");
+	}
+
+	@BeforeEach
+	public void setup() {
+		this.myCircuitBreaker.clear();
+	}
+
+	@Test
+	public void testSimpleTypeWithFallback() {
+		Hello hello = testClient.getHello();
+
+		assertThat(hello).as("hello was null").isNotNull();
+		assertThat(hello).as("first hello didn't match")
+				.isEqualTo(new Hello("hello world 1"));
+		assertThat(myCircuitBreaker.runWasCalled).as("Circuit Breaker was called")
+				.isTrue();
+	}
+
+	@Test
+	public void test404WithoutFallback() {
+		assertThatThrownBy(() -> testClient.getException())
+				.isInstanceOf(NoFallbackAvailableException.class);
+	}
+
+	@FeignClient(name = "test", url = "http://localhost:${server.port}/")
+	protected interface CircuitBreakerTestClient {
+
+		@RequestMapping(method = RequestMethod.GET, value = "/hello")
+		Hello getHello();
+
+		@RequestMapping(method = RequestMethod.GET, value = "/hellonotfound")
+		String getException();
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@EnableAutoConfiguration
+	@RestController
+	@EnableFeignClients(clients = { CircuitBreakerTestClient.class })
+	@Import(NoSecurityConfiguration.class)
+	protected static class Application implements CircuitBreakerTestClient {
+
+		static final Log log = LogFactory.getLog(Application.class);
+
+		@Bean
+		MyCircuitBreaker myCircuitBreaker() {
+			return new MyCircuitBreaker();
+		}
+
+		@Bean
+		CircuitBreakerFactory circuitBreakerFactory(MyCircuitBreaker myCircuitBreaker) {
+			return new CircuitBreakerFactory() {
+				@Override
+				public CircuitBreaker create(String id) {
+					log.info("Creating a circuit breaker with id [" + id + "]");
+					return myCircuitBreaker;
+				}
+
+				@Override
+				protected ConfigBuilder configBuilder(String id) {
+					return Object::new;
+				}
+
+				@Override
+				public void configureDefault(Function defaultConfiguration) {
+
+				}
+			};
+		}
+
+		@Override
+		public Hello getHello() {
+			return new Hello("hello world 1");
+		}
+
+		@Override
+		public String getException() {
+			throw new IllegalStateException("BOOM!");
+		}
+
+	}
+
+}

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/circuitbreaker/Hello.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2013-2021 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign.circuitbreaker;
+
+import java.util.Objects;
+
+/**
+ * @author Marcin Grzejszczak
+ */
+class Hello {
+
+	private String message;
+
+	public Hello() {
+	}
+
+	public Hello(String message) {
+		this.message = message;
+	}
+
+	public String getMessage() {
+		return this.message;
+	}
+
+	public void setMessage(String message) {
+		this.message = message;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (o == null || getClass() != o.getClass()) {
+			return false;
+		}
+		Hello that = (Hello) o;
+		return Objects.equals(this.message, that.message);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(this.message);
+	}
+
+}

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/circuitbreaker/MyCircuitBreaker.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2013-2021 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign.circuitbreaker;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import org.springframework.cloud.client.circuitbreaker.CircuitBreaker;
+import org.springframework.cloud.client.circuitbreaker.NoFallbackAvailableException;
+
+/**
+ * @author Marcin Grzejszczak
+ * @author Olga Maciaszek-Sharma
+ */
+class MyCircuitBreaker implements CircuitBreaker {
+
+	AtomicBoolean runWasCalled = new AtomicBoolean();
+
+	@Override
+	public <T> T run(Supplier<T> toRun) {
+		try {
+			this.runWasCalled.set(true);
+			return toRun.get();
+		}
+		catch (Throwable throwable) {
+			throw new NoFallbackAvailableException("No fallback available.", throwable);
+		}
+	}
+
+	@Override
+	public <T> T run(Supplier<T> toRun, Function<Throwable, T> fallback) {
+		try {
+			return run(toRun);
+		}
+		catch (Throwable throwable) {
+			return fallback.apply(throwable);
+		}
+	}
+
+	public void clear() {
+		this.runWasCalled.set(false);
+	}
+
+}

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/encoding/FeignPageableEncodingTests.java

@@ -17,6 +17,7 @@
 package org.springframework.cloud.openfeign.encoding;
 
 import java.util.Collections;
+import java.util.List;
 import java.util.Optional;
 
 import com.netflix.loadbalancer.BaseLoadBalancer;
@@ -32,7 +33,6 @@ import org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoCon
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.cloud.netflix.ribbon.RibbonClient;
 import org.springframework.cloud.openfeign.EnableFeignClients;
-import org.springframework.cloud.openfeign.FeignClientsConfiguration;
 import org.springframework.cloud.openfeign.encoding.app.client.InvoiceClient;
 import org.springframework.cloud.openfeign.encoding.app.domain.Invoice;
 import org.springframework.cloud.openfeign.test.NoSecurityConfiguration;
@@ -55,10 +55,12 @@ import static org.springframework.boot.test.context.SpringBootTest.WebEnvironmen
  * Tests the pagination encoding.
  *
  * @author Charlie Mordant.
+ * @author Hyeonmin Park
  */
 @SpringBootTest(classes = FeignPageableEncodingTests.Application.class,
 		webEnvironment = RANDOM_PORT,
 		value = { "feign.compression.request.enabled=true",
+				"feign.autoconfiguration.jackson.enabled=true",
 				"hystrix.command.default.execution.isolation.strategy=SEMAPHORE",
 				"ribbon.OkToRetryOnAllOperations=false" })
 @RunWith(SpringJUnit4ClassRunner.class)
@@ -93,13 +95,73 @@ public class FeignPageableEncodingTests {
 
 	}
 
+	@Test
+	public void testPageableWithDescDirection() {
+		// given
+		Pageable pageable = PageRequest.of(0, 10, Sort.Direction.DESC, "sortProperty");
+
+		// when
+		final ResponseEntity<Page<Invoice>> response = this.invoiceClient
+				.getInvoicesPaged(pageable);
+
+		// then
+		assertThat(response).isNotNull();
+		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
+		assertThat(response.getBody()).isNotNull();
+		assertThat(pageable.getPageSize()).isEqualTo(response.getBody().getSize());
+
+		Sort sort = response.getBody().getPageable().getSort();
+		assertThat(sort).hasSize(1);
+		assertThat(sort.get()).hasSize(1);
+
+		Optional<Sort.Order> optionalOrder = sort.get().findFirst();
+		assertThat(optionalOrder.isPresent()).isTrue();
+
+		Sort.Order order = optionalOrder.get();
+		assertThat(order.getDirection()).isEqualTo(Sort.Direction.DESC);
+		assertThat(order.getProperty()).isEqualTo("sortProperty");
+
+	}
+
+	@Test
+	public void testPageableWithMultipleSort() {
+		// given
+		Pageable pageable = PageRequest.of(0, 10, Sort
+				.by(Sort.Order.desc("sortProperty1"), Sort.Order.asc("sortProperty2")));
+
+		// when
+		final ResponseEntity<Page<Invoice>> response = this.invoiceClient
+				.getInvoicesPaged(pageable);
+
+		// then
+		assertThat(response).isNotNull();
+		assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
+		assertThat(response.getBody()).isNotNull();
+		assertThat(pageable.getPageSize()).isEqualTo(response.getBody().getSize());
+
+		Sort sort = response.getBody().getPageable().getSort();
+		assertThat(sort).hasSize(2);
+
+		List<Sort.Order> orderList = sort.toList();
+		assertThat(orderList).hasSize(2);
+
+		Sort.Order firstOrder = orderList.get(0);
+		assertThat(firstOrder.getDirection()).isEqualTo(Sort.Direction.DESC);
+		assertThat(firstOrder.getProperty()).isEqualTo("sortProperty1");
+
+		Sort.Order secondOrder = orderList.get(1);
+		assertThat(secondOrder.getDirection()).isEqualTo(Sort.Direction.ASC);
+		assertThat(secondOrder.getProperty()).isEqualTo("sortProperty2");
+
+	}
+
 	@EnableFeignClients(clients = InvoiceClient.class)
 	@RibbonClient(name = "local", configuration = LocalRibbonClientConfiguration.class)
 	@SpringBootApplication(
 			scanBasePackages = "org.springframework.cloud.openfeign.encoding.app",
 			exclude = { RepositoryRestMvcAutoConfiguration.class })
 	@EnableSpringDataWebSupport
-	@Import({ NoSecurityConfiguration.class, FeignClientsConfiguration.class })
+	@Import({ NoSecurityConfiguration.class })
 	public static class Application {
 
 	}

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/feignclientsregistrar/TopLevelClient.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign.feignclientsregistrar;
+
+import org.springframework.cloud.openfeign.FeignClient;
+
+/**
+ * @author Michal Domagala
+ */
+
+@FeignClient("top-level")
+public interface TopLevelClient {
+
+}

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/feignclientsregistrar/sub/SubLevelClient.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign.feignclientsregistrar.sub;
+
+import org.springframework.cloud.openfeign.FeignClient;
+
+/**
+ * @author Michal Domagala
+ */
+
+@FeignClient("sub-level")
+public interface SubLevelClient {
+
+}

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/loadbalancer/FeignLoadBalancerAutoConfigurationTests.java

@@ -45,7 +45,8 @@ class FeignLoadBalancerAutoConfigurationTests {
 	void shouldInstantiateDefaultFeignBlockingLoadBalancerClientWhenHttpClientDisabled() {
 		ConfigurableApplicationContext context = initContext(
 				"spring.cloud.loadbalancer.ribbon.enabled=false",
-				"feign.httpclient.enabled=false");
+				"feign.httpclient.enabled=false",
+				"spring.cloud.loadbalancer.retry.enabled=false");
 		assertThatOneBeanPresent(context, BlockingLoadBalancerClient.class);
 		assertLoadBalanced(context, Client.Default.class);
 		assertThatBeanNotPresent(context, LoadBalancerFeignClient.class);
@@ -54,7 +55,8 @@ class FeignLoadBalancerAutoConfigurationTests {
 	@Test
 	void shouldInstantiateHttpFeignClientWhenEnabled() {
 		ConfigurableApplicationContext context = initContext(
-				"spring.cloud.loadbalancer.ribbon.enabled=false");
+				"spring.cloud.loadbalancer.ribbon.enabled=false",
+				"spring.cloud.loadbalancer.retry.enabled=false");
 		assertThatOneBeanPresent(context, BlockingLoadBalancerClient.class);
 		assertLoadBalanced(context, ApacheHttpClient.class);
 		assertThatBeanNotPresent(context, LoadBalancerFeignClient.class);
@@ -64,16 +66,47 @@ class FeignLoadBalancerAutoConfigurationTests {
 	void shouldInstantiateOkHttpFeignClientWhenEnabled() {
 		ConfigurableApplicationContext context = initContext(
 				"spring.cloud.loadbalancer.ribbon.enabled=false",
-				"feign.httpclient.enabled=false", "feign.okhttp.enabled=true");
+				"feign.httpclient.enabled=false", "feign.okhttp.enabled=true",
+				"spring.cloud.loadbalancer.retry.enabled=false");
 		assertThatOneBeanPresent(context, BlockingLoadBalancerClient.class);
 		assertLoadBalanced(context, OkHttpClient.class);
 		assertThatBeanNotPresent(context, LoadBalancerFeignClient.class);
 	}
 
+	@Test
+	void shouldInstantiateRetryableDefaultFeignBlockingLoadBalancerClientWhenHttpClientDisabled() {
+		ConfigurableApplicationContext context = initContext(
+				"spring.cloud.loadbalancer.ribbon.enabled=false",
+				"feign.httpclient.enabled=false");
+		assertThatOneBeanPresent(context, BlockingLoadBalancerClient.class);
+		assertLoadBalancedWithRetries(context, Client.Default.class);
+		assertThatBeanNotPresent(context, LoadBalancerFeignClient.class);
+	}
+
+	@Test
+	void shouldInstantiateRetryableHttpFeignClientWhenEnabled() {
+		ConfigurableApplicationContext context = initContext(
+				"spring.cloud.loadbalancer.ribbon.enabled=false");
+		assertThatOneBeanPresent(context, BlockingLoadBalancerClient.class);
+		assertLoadBalancedWithRetries(context, ApacheHttpClient.class);
+		assertThatBeanNotPresent(context, LoadBalancerFeignClient.class);
+	}
+
+	@Test
+	void shouldInstantiateRetryableOkHttpFeignClientWhenEnabled() {
+		ConfigurableApplicationContext context = initContext(
+				"spring.cloud.loadbalancer.ribbon.enabled=false",
+				"feign.httpclient.enabled=false", "feign.okhttp.enabled=true");
+		assertThatOneBeanPresent(context, BlockingLoadBalancerClient.class);
+		assertLoadBalancedWithRetries(context, OkHttpClient.class);
+		assertThatBeanNotPresent(context, LoadBalancerFeignClient.class);
+	}
+
 	@Test
 	void shouldNotProcessLoadBalancerConfigurationWhenRibbonEnabled() {
 		ConfigurableApplicationContext context = initContext(
-				"spring.cloud.loadbalancer.ribbon.enabled=true");
+				"spring.cloud.loadbalancer.ribbon.enabled=true",
+				"spring.cloud.loadbalancer.retry.enabled=false");
 		assertThatOneBeanPresent(context, LoadBalancerFeignClient.class);
 		assertThatBeanNotPresent(context, BlockingLoadBalancerClient.class);
 		assertThatBeanNotPresent(context, FeignBlockingLoadBalancerClient.class);
@@ -104,6 +137,18 @@ class FeignLoadBalancerAutoConfigurationTests {
 		assertThat(beans.get("feignClient").getDelegate()).isInstanceOf(delegateClass);
 	}
 
+	private void assertLoadBalancedWithRetries(ConfigurableApplicationContext context,
+			Class delegateClass) {
+		Map<String, RetryableFeignBlockingLoadBalancerClient> retryableBeans = context
+				.getBeansOfType(RetryableFeignBlockingLoadBalancerClient.class);
+		assertThat(retryableBeans).hasSize(1);
+		Map<String, FeignBlockingLoadBalancerClient> beans = context
+				.getBeansOfType(FeignBlockingLoadBalancerClient.class);
+		assertThat(beans).isEmpty();
+		assertThat(retryableBeans.get("feignRetryClient").getDelegate())
+				.isInstanceOf(delegateClass);
+	}
+
 	private void assertThatBeanNotPresent(ConfigurableApplicationContext context,
 			Class<?> beanClass) {
 		Map<String, ?> beans = context.getBeansOfType(beanClass);

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/loadbalancer/RetryableFeignBlockingLoadBalancerClientTests.java

@@ -0,0 +1,197 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign.loadbalancer;
+
+import java.io.IOException;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import feign.Client;
+import feign.Request;
+import feign.Response;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import org.springframework.cloud.client.DefaultServiceInstance;
+import org.springframework.cloud.client.ServiceInstance;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerRetryProperties;
+import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient;
+import org.springframework.cloud.loadbalancer.blocking.retry.BlockingLoadBalancedRetryPolicy;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * Tests for {@link RetryableFeignBlockingLoadBalancerClient}. Note: the underlying
+ * {@link BlockingLoadBalancerClient} is already extensively tested in the Spring Cloud
+ * Commons project, so here we are only testing the interactions between
+ * {@link RetryableFeignBlockingLoadBalancerClient} and its delegates.
+ *
+ * @see <a href=
+ * "https://github.com/spring-cloud/spring-cloud-commons/blob/master/spring-cloud-loadbalancer/src/test/java/org/springframework/cloud/loadbalancer/blocking/client/BlockingLoadBalancerClientTests.java">BlockingLoadBalancerClientTests</a>
+ * @author Olga Maciaszek-Sharma
+ */
+@ExtendWith(MockitoExtension.class)
+class RetryableFeignBlockingLoadBalancerClientTests {
+
+	private Client delegate = mock(Client.class);
+
+	private LoadBalancedRetryFactory retryFactory = mock(LoadBalancedRetryFactory.class);
+
+	private BlockingLoadBalancerClient loadBalancerClient = mock(
+			BlockingLoadBalancerClient.class);
+
+	private LoadBalancerRetryProperties properties = new LoadBalancerRetryProperties();
+
+	private RetryableFeignBlockingLoadBalancerClient feignBlockingLoadBalancerClient = new RetryableFeignBlockingLoadBalancerClient(
+			delegate, loadBalancerClient, retryFactory);
+
+	private ServiceInstance serviceInstance = new DefaultServiceInstance("test-a", "test",
+			"testhost", 80, false);
+
+	@BeforeEach
+	void setUp() {
+		when(retryFactory.createRetryPolicy(any(), eq(loadBalancerClient)))
+				.thenReturn(new BlockingLoadBalancedRetryPolicy("test",
+						loadBalancerClient, properties));
+		when(loadBalancerClient.choose("test")).thenReturn(serviceInstance);
+	}
+
+	@Test
+	void shouldExtractServiceIdFromRequestUrl() throws IOException {
+		Request request = testRequest();
+		Response response = testResponse(200);
+		when(delegate.execute(any(), any())).thenReturn(response);
+		when(retryFactory.createRetryPolicy(any(), eq(loadBalancerClient)))
+				.thenReturn(new BlockingLoadBalancedRetryPolicy("test",
+						loadBalancerClient, properties));
+		when(loadBalancerClient.reconstructURI(serviceInstance,
+				URI.create("http://test/path")))
+						.thenReturn(URI.create("http://testhost:80/path"));
+
+		feignBlockingLoadBalancerClient.execute(request, new Request.Options());
+
+		verify(loadBalancerClient).choose("test");
+		verify(loadBalancerClient).reconstructURI(serviceInstance,
+				URI.create("http://test/path"));
+
+		verify(delegate).execute(argThat((Request actualRequest) -> actualRequest.url()
+				.equals("http://testhost:80/path")), any());
+	}
+
+	private Response testResponse(int status) {
+		return Response.builder().request(testRequest()).status(status).build();
+	}
+
+	@Test
+	void shouldExecuteOriginalRequestIfInstanceNotFound() throws IOException {
+		Request request = testRequest();
+		Response response = testResponse(503);
+		when(loadBalancerClient.choose("test")).thenReturn(null);
+		when(delegate.execute(any(), any())).thenReturn(response);
+		when(retryFactory.createRetryPolicy(any(), eq(loadBalancerClient)))
+				.thenReturn(new BlockingLoadBalancedRetryPolicy("test",
+						loadBalancerClient, properties));
+
+		feignBlockingLoadBalancerClient.execute(request, new Request.Options());
+
+		verify(delegate).execute(eq(request), any());
+	}
+
+	@Test
+	void shouldRetryOnRepeatableStatusCode() throws IOException {
+		properties.getRetryableStatusCodes().add(503);
+		Request request = testRequest();
+		Response response = testResponse(503);
+		when(delegate.execute(any(), any())).thenReturn(response);
+		when(retryFactory.createRetryPolicy(any(), eq(loadBalancerClient)))
+				.thenReturn(new BlockingLoadBalancedRetryPolicy("test",
+						loadBalancerClient, properties));
+		when(loadBalancerClient.reconstructURI(serviceInstance,
+				URI.create("http://test/path")))
+						.thenReturn(URI.create("http://testhost:80/path"));
+
+		feignBlockingLoadBalancerClient.execute(request, new Request.Options());
+
+		verify(loadBalancerClient, times(2)).reconstructURI(serviceInstance,
+				URI.create("http://test/path"));
+		verify(delegate, times(2)).execute(any(), any());
+	}
+
+	@Test
+	void shouldPassCorrectRequestToDelegate() throws IOException {
+		Request request = testRequest();
+		Request.Options options = new Request.Options();
+		String url = "http://127.0.0.1/path";
+		ServiceInstance serviceInstance = new DefaultServiceInstance("test-1", "test",
+				"test-host", 8888, false);
+		when(loadBalancerClient.choose("test")).thenReturn(serviceInstance);
+		when(loadBalancerClient.reconstructURI(serviceInstance,
+				URI.create("http://test/path"))).thenReturn(URI.create(url));
+		Response response = testResponse(200);
+		when(delegate.execute(any(), any())).thenReturn(response);
+		when(retryFactory.createRetryPolicy(any(), eq(loadBalancerClient)))
+				.thenReturn(new BlockingLoadBalancedRetryPolicy("test",
+						loadBalancerClient, properties));
+
+		feignBlockingLoadBalancerClient.execute(request, options);
+
+		ArgumentCaptor<Request> captor = ArgumentCaptor.forClass(Request.class);
+		verify(delegate, times(1)).execute(captor.capture(), eq(options));
+		Request actualRequest = captor.getValue();
+		assertThat(actualRequest.httpMethod()).isEqualTo(Request.HttpMethod.GET);
+		assertThat(actualRequest.url()).isEqualTo(url);
+		assertThat(actualRequest.headers()).hasSize(1);
+		assertThat(actualRequest.headers()).containsEntry(HttpHeaders.CONTENT_TYPE,
+				Collections.singletonList(MediaType.APPLICATION_JSON_VALUE));
+		assertThat(new String(actualRequest.body())).isEqualTo("hello");
+	}
+
+	private Request testRequest() {
+		return testRequest("test");
+	}
+
+	private Request testRequest(String host) {
+		return Request.create(Request.HttpMethod.GET, "http://" + host + "/path",
+				testHeaders(), "hello".getBytes(), StandardCharsets.UTF_8, null);
+	}
+
+	private Map<String, Collection<String>> testHeaders() {
+		Map<String, Collection<String>> feignHeaders = new HashMap<>();
+		feignHeaders.put(HttpHeaders.CONTENT_TYPE,
+				Collections.singletonList(MediaType.APPLICATION_JSON_VALUE));
+		return feignHeaders;
+
+	}
+
+}

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/support/AbstractSpringMvcContractIntegrationTests.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign.support;
+
+import java.nio.charset.Charset;
+
+import feign.Response;
+import feign.codec.Decoder;
+import feign.codec.Encoder;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.cloud.openfeign.test.NoSecurityConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.http.HttpHeaders;
+import org.springframework.util.SocketUtils;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * Abstract class for the integration tests for {@link SpringMvcContract}.
+ *
+ * @author Ram Anaswara
+ */
+public class AbstractSpringMvcContractIntegrationTests {
+
+	@BeforeAll
+	public static void beforeClass() {
+		System.setProperty("server.port",
+				String.valueOf(SocketUtils.findAvailableTcpPort()));
+	}
+
+	@AfterAll
+	public static void afterClass() {
+		System.clearProperty("server.port");
+	}
+
+	protected String getUrlQueryParam(Response response) {
+		return response.request().requestTemplate().queries().get("url").stream()
+				.findFirst().orElseThrow(IllegalStateException::new);
+	}
+
+	@FeignClient(name = "test", url = "http://localhost:${server.port}/",
+			configuration = NoCodecsFeignConfiguration.class)
+	interface TestClient {
+
+		@PostMapping("/test")
+		Object sendMessage(@RequestBody String message,
+				@RequestHeader(HttpHeaders.CONTENT_TYPE) String acceptHeader);
+
+		@GetMapping("/get")
+		Object getMessage(@RequestParam String url);
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@EnableFeignClients(clients = TestClient.class)
+	@EnableAutoConfiguration
+	@RestController
+	@Import(NoSecurityConfiguration.class)
+	protected static class Config {
+
+		@PostMapping("/test")
+		Object sendMessage(@RequestBody String message,
+				@RequestHeader(HttpHeaders.CONTENT_TYPE) String acceptHeader) {
+			return message;
+		}
+
+		@GetMapping("/get")
+		Object getMessage(@RequestParam String url) {
+			return url;
+		}
+
+	}
+
+	// Avoid feign.codec.EncodeException - this feature works for users that override
+	// Encoder
+	protected static class NoCodecsFeignConfiguration {
+
+		@Bean
+		public Decoder decoder() {
+			return (response, type) -> response;
+		}
+
+		@Bean
+		public Encoder encoder() {
+			return (object, bodyType, request) -> request
+					.body(object.toString().getBytes(), Charset.defaultCharset());
+		}
+
+	}
+
+}

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/support/PageJacksonModuleTests.java

@@ -19,14 +19,18 @@ package org.springframework.cloud.openfeign.support;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import org.springframework.data.domain.Page;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
+ * Test for {@link PageJacksonModule}.
+ *
  * @author Ruben Vervaeke
+ * @author Olga Maciaszek-Sharma
  */
 public class PageJacksonModuleTests {
 
@@ -38,10 +42,13 @@ public class PageJacksonModuleTests {
 		objectMapper.registerModule(new PageJacksonModule());
 	}
 
-	@Test
-	public void deserializePage() throws JsonProcessingException {
+	@ParameterizedTest
+	@ValueSource(strings = { "totalElements", "total-elements", "total_elements",
+			"totalelements", "TotalElements" })
+	public void deserializePage(String totalElements) throws JsonProcessingException {
 		// Given
-		String pageJson = "{\"content\":[\"A name\"], \"number\":1, \"size\":2, \"totalElements\": 3}";
+		String pageJson = "{\"content\":[\"A name\"], \"number\":1, \"size\":2, \""
+				+ totalElements + "\": 3}";
 		// When
 		Page<?> result = objectMapper.readValue(pageJson, Page.class);
 		// Then

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/support/PageableSupportTest.java

@@ -16,6 +16,7 @@
 
 package org.springframework.cloud.openfeign.support;
 
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 
@@ -53,6 +54,11 @@ public class PageableSupportTest {
 				String.valueOf(SocketUtils.findAvailableTcpPort()));
 	}
 
+	@AfterAll
+	public static void afterClass() {
+		System.clearProperty("server.port");
+	}
+
 	@Test
 	void shouldProperlyFormatPageable() {
 		String direction = feignClient.performRequest(

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/support/SpringMvcContractIntegrationTests.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign.support;
+
+import feign.Response;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+
+/**
+ * Integration tests for {@link SpringMvcContract}.
+ *
+ * @author Olga Maciaszek-Sharma
+ * @author Ram Anaswara
+ */
+@SpringBootTest(classes = AbstractSpringMvcContractIntegrationTests.Config.class,
+		webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
+public class SpringMvcContractIntegrationTests
+		extends AbstractSpringMvcContractIntegrationTests {
+
+	@Autowired
+	private TestClient client;
+
+	@Test
+	public void shouldNotThrowInvalidMediaTypeExceptionWhenContentTypeTemplateUsed() {
+		assertThatCode(() -> client.sendMessage("test", "text/markdown"))
+				.doesNotThrowAnyException();
+	}
+
+	@Test
+	public void feignClientShouldPreserveSlash() {
+		Response response = (Response) client.getMessage("https://www.google.com");
+
+		String urlQueryParam = getUrlQueryParam(response);
+		assertThat(urlQueryParam).isEqualTo("https%3A//www.google.com");
+	}
+
+}

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/support/SpringMvcContractSlashEncodingIntegrationTests.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2013-2020 the original author or 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
+ *
+ *      https://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 org.springframework.cloud.openfeign.support;
+
+import feign.Response;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for {@link SpringMvcContract}.
+ *
+ * @author Ram Anaswara
+ */
+@SpringBootTest(classes = SpringMvcContractSlashEncodingIntegrationTests.Config.class,
+		webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT,
+		properties = { "feign.client.decodeSlash=false" })
+public class SpringMvcContractSlashEncodingIntegrationTests
+		extends AbstractSpringMvcContractIntegrationTests {
+
+	@Autowired
+	private TestClient client;
+
+	@Test
+	public void feignClientShouldNotDecodeEncodedSlash() {
+		Response response = (Response) client.getMessage("https://www.google.com");
+
+		String urlQueryParam = getUrlQueryParam(response);
+		assertThat(urlQueryParam).isEqualTo("https%3A%2F%2Fwww.google.com");
+	}
+
+}

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/support/SpringMvcContractTests.java

@@ -31,11 +31,8 @@ import java.util.Map;
 import com.fasterxml.jackson.annotation.JsonAutoDetect;
 import feign.MethodMetadata;
 import feign.Param;
-import junitparams.JUnitParamsRunner;
-import junitparams.Parameters;
 import org.junit.Before;
 import org.junit.Test;
-import org.junit.runner.RunWith;
 
 import org.springframework.cloud.openfeign.CollectionFormat;
 import org.springframework.cloud.openfeign.SpringQueryMap;
@@ -75,7 +72,6 @@ import static org.junit.Assume.assumeTrue;
  * @author Artyom Romanenko
  * @author Olga Maciaszek-Sharma
  */
-@RunWith(JUnitParamsRunner.class)
 public class SpringMvcContractTests {
 
 	private static final Class<?> EXECUTABLE_TYPE;
@@ -122,11 +118,7 @@ public class SpringMvcContractTests {
 
 	@Before
 	public void setup() {
-		FormattingConversionServiceFactoryBean conversionServiceFactoryBean = new FormattingConversionServiceFactoryBean();
-		conversionServiceFactoryBean.afterPropertiesSet();
-		ConversionService conversionService = conversionServiceFactoryBean.getObject();
-
-		contract = new SpringMvcContract(Collections.emptyList(), conversionService);
+		contract = new SpringMvcContract(Collections.emptyList(), getConversionService());
 	}
 
 	@Test
@@ -140,6 +132,23 @@ public class SpringMvcContractTests {
 		assertThat(data.template().method()).isEqualTo("GET");
 		assertThat(data.template().headers().get("Accept").iterator().next())
 				.isEqualTo(MediaType.APPLICATION_JSON_VALUE);
+
+		assertThat(data.template().decodeSlash()).isTrue();
+	}
+
+	@Test
+	public void testProcessAnnotationOnMethod_Simple_SlashEncoded() throws Exception {
+		contract = new SpringMvcContract(Collections.emptyList(), getConversionService(),
+				false);
+
+		Method method = TestTemplate_Simple.class.getDeclaredMethod("getTest",
+				String.class);
+		MethodMetadata data = contract
+				.parseAndValidateMetadata(method.getDeclaringClass(), method);
+
+		assertThat(data.template().url()).isEqualTo("/test/{id}");
+
+		assertThat(data.template().decodeSlash()).isFalse();
 	}
 
 	@Test
@@ -198,6 +207,24 @@ public class SpringMvcContractTests {
 		assertThat(data.template().method()).isEqualTo("GET");
 
 		assertThat(data.indexToName().get(0).iterator().next()).isEqualTo("classId");
+
+		assertThat(data.template().decodeSlash()).isTrue();
+	}
+
+	@Test
+	public void testProcessAnnotations_Class_AnnotationsGetAllTests_EncodeSlash()
+			throws Exception {
+		contract = new SpringMvcContract(Collections.emptyList(), getConversionService(),
+				false);
+
+		Method method = TestTemplate_Class_Annotations.class
+				.getDeclaredMethod("getAllTests", String.class);
+		MethodMetadata data = contract
+				.parseAndValidateMetadata(method.getDeclaringClass(), method);
+
+		assertThat(data.template().url()).isEqualTo("/prepend/{classId}");
+
+		assertThat(data.template().decodeSlash()).isFalse();
 	}
 
 	@Test
@@ -217,6 +244,30 @@ public class SpringMvcContractTests {
 
 		assertThat(data.indexToName().get(0).iterator().next())
 				.isEqualTo(data.indexToName().get(0).iterator().next());
+		assertThat(data.indexToName().get(0).iterator().next())
+				.isEqualTo(data.indexToName().get(0).iterator().next());
+		assertThat(data.template().decodeSlash()).isTrue();
+	}
+
+	@Test
+	public void testProcessAnnotations_ExtendedInterface_EncodeSlash() throws Exception {
+		contract = new SpringMvcContract(Collections.emptyList(), getConversionService(),
+				false);
+
+		Method extendedMethod = TestTemplate_Extended.class.getMethod("getAllTests",
+				String.class);
+		MethodMetadata extendedData = contract.parseAndValidateMetadata(
+				extendedMethod.getDeclaringClass(), extendedMethod);
+
+		Method method = TestTemplate_Class_Annotations.class
+				.getDeclaredMethod("getAllTests", String.class);
+		MethodMetadata data = contract
+				.parseAndValidateMetadata(method.getDeclaringClass(), method);
+
+		assertThat(data.template().url()).isEqualTo(extendedData.template().url());
+		assertThat(data.template().method()).isEqualTo(extendedData.template().method());
+
+		assertThat(data.template().decodeSlash()).isFalse();
 	}
 
 	@Test
@@ -394,6 +445,22 @@ public class SpringMvcContractTests {
 		assertThat(data.template().method()).isEqualTo("GET");
 		assertThat(data.template().headers().get("Accept").iterator().next())
 				.isEqualTo(MediaType.APPLICATION_JSON_VALUE);
+		assertThat(data.template().decodeSlash()).isTrue();
+	}
+
+	@Test
+	public void testProcessAnnotations_Advanced3_DecodeSlashFlagNotModified()
+			throws Exception {
+		contract = new SpringMvcContract(Collections.emptyList(), getConversionService(),
+				false);
+
+		Method method = TestTemplate_Simple.class.getDeclaredMethod("getTest");
+		MethodMetadata data = contract
+				.parseAndValidateMetadata(method.getDeclaringClass(), method);
+
+		assertThat(data.template().url()).isEqualTo("/");
+
+		assertThat(data.template().decodeSlash()).isTrue();
 	}
 
 	@Test
@@ -602,53 +669,6 @@ public class SpringMvcContractTests {
 				"{Accept}");
 	}
 
-	private Class[] doubleMappingClassesProvider() {
-		return new Class[] { TestTemplate_RequestMapping_Empty_Class.class,
-				TestTemplate_RequestMapping_Empty_Method.class };
-	}
-
-	@Test
-	@Parameters(method = "doubleMappingClassesProvider")
-	public void testDoubleRequestMapping_root(Class clazz) throws NoSuchMethodException {
-		Method method = clazz.getDeclaredMethod("root");
-		MethodMetadata data = contract
-				.parseAndValidateMetadata(method.getDeclaringClass(), method);
-
-		assertThat(data.template().url()).isEqualTo("/");
-	}
-
-	@Test
-	@Parameters(method = "doubleMappingClassesProvider")
-	public void testDoubleRequestMapping_rootReverse(Class clazz)
-			throws NoSuchMethodException {
-		Method method = clazz.getDeclaredMethod("rootReverse");
-		MethodMetadata data = contract
-				.parseAndValidateMetadata(method.getDeclaringClass(), method);
-
-		assertThat(data.template().url()).isEqualTo("/");
-	}
-
-	@Test
-	@Parameters(method = "doubleMappingClassesProvider")
-	public void testDoubleRequestMapping_sub(Class clazz) throws NoSuchMethodException {
-		Method method = clazz.getDeclaredMethod("sub");
-		MethodMetadata data = contract
-				.parseAndValidateMetadata(method.getDeclaringClass(), method);
-
-		assertThat(data.template().url()).isEqualTo("/sub");
-	}
-
-	@Test
-	@Parameters(method = "doubleMappingClassesProvider")
-	public void testDoubleRequestMapping_subEmpty(Class clazz)
-			throws NoSuchMethodException {
-		Method method = clazz.getDeclaredMethod("subEmpty");
-		MethodMetadata data = contract
-				.parseAndValidateMetadata(method.getDeclaringClass(), method);
-
-		assertThat(data.template().url()).isEqualTo("/subEmpty");
-	}
-
 	@Test
 	public void testMultipleRequestPartAnnotations() throws NoSuchMethodException {
 		Method method = TestTemplate_RequestPart.class.getDeclaredMethod(
@@ -659,6 +679,12 @@ public class SpringMvcContractTests {
 		assertThat(data.formParams()).contains("file", "id");
 	}
 
+	private ConversionService getConversionService() {
+		FormattingConversionServiceFactoryBean conversionServiceFactoryBean = new FormattingConversionServiceFactoryBean();
+		conversionServiceFactoryBean.afterPropertiesSet();
+		return conversionServiceFactoryBean.getObject();
+	}
+
 	public interface TestTemplate_Simple {
 
 		@RequestMapping(value = "/test/{id}", method = RequestMethod.GET,
@@ -841,40 +867,6 @@ public class SpringMvcContractTests {
 
 	}
 
-	@RequestMapping("")
-	public interface TestTemplate_RequestMapping_Empty_Class {
-
-		@RequestMapping("/")
-		String root();
-
-		@RequestMapping("")
-		String rootReverse();
-
-		@RequestMapping("/sub")
-		String sub();
-
-		@RequestMapping("subEmpty")
-		String subEmpty();
-
-	}
-
-	@RequestMapping("/")
-	public interface TestTemplate_RequestMapping_Empty_Method {
-
-		@RequestMapping("")
-		String root();
-
-		@RequestMapping("/")
-		String rootReverse();
-
-		@RequestMapping("/sub")
-		String sub();
-
-		@RequestMapping("subEmpty")
-		String subEmpty();
-
-	}
-
 	@JsonAutoDetect(fieldVisibility = ANY, getterVisibility = NONE,
 			setterVisibility = NONE)
 	public class TestObject {

spring-cloud-openfeign-core/src/test/resources/feign-properties.properties

@@ -10,6 +10,10 @@ feign.client.config.default.retryer=org.springframework.cloud.openfeign.FeignCli
 feign.client.config.default.decode404=true
 feign.client.config.foo.requestInterceptors[0]=org.springframework.cloud.openfeign.FeignClientUsingPropertiesTests.FooRequestInterceptor
 feign.client.config.foo.requestInterceptors[1]=org.springframework.cloud.openfeign.FeignClientUsingPropertiesTests.BarRequestInterceptor
+feign.client.config.singleValue.defaultRequestHeaders[singleValueHeaders]=header
+feign.client.config.singleValue.defaultQueryParameters[singleValueParameters]=parameter
+feign.client.config.multipleValue.defaultRequestHeaders[multipleValueHeaders]=header1,header2
+feign.client.config.multipleValue.defaultQueryParameters[multipleValueParameters]=parameter1,parameter2
 feign.client.config.bar.connectTimeout=1000
 feign.client.config.bar.readTimeout=1000
 feign.client.config.form.encoder=org.springframework.cloud.openfeign.FeignClientUsingPropertiesTests.FormEncoder

spring-cloud-openfeign-dependencies/pom.xml

@@ -6,11 +6,11 @@
 	<parent>
 		<artifactId>spring-cloud-dependencies-parent</artifactId>
 		<groupId>org.springframework.cloud</groupId>
-		<version>2.3.1.BUILD-SNAPSHOT</version>
+		<version>2.3.2.RELEASE</version>
 		<relativePath/>
 	</parent>
 	<artifactId>spring-cloud-openfeign-dependencies</artifactId>
-	<version>2.2.4.BUILD-SNAPSHOT</version>
+	<version>2.2.7.RELEASE</version>
 	<packaging>pom</packaging>
 	<name>spring-cloud-openfeign-dependencies</name>
 	<description>Spring Cloud OpenFeign Dependencies</description>
@@ -32,74 +32,16 @@
 			</dependency>
 			<dependency>
 				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-core</artifactId>
+				<artifactId>feign-bom</artifactId>
 				<version>${feign.version}</version>
+				<type>pom</type>
+				<scope>import</scope>
 			</dependency>
 			<dependency>
 				<groupId>io.github.openfeign.form</groupId>
 				<artifactId>feign-form-spring</artifactId>
 				<version>${feign-form.version}</version>
 			</dependency>
-			<dependency>
-				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-slf4j</artifactId>
-				<version>${feign.version}</version>
-			</dependency>
-			<dependency>
-				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-httpclient</artifactId>
-				<version>${feign.version}</version>
-			</dependency>
-			<dependency>
-				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-hystrix</artifactId>
-				<version>${feign.version}</version>
-			</dependency>
-			<dependency>
-				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-okhttp</artifactId>
-				<version>${feign.version}</version>
-			</dependency>
-			<dependency>
-				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-gson</artifactId>
-				<version>${feign.version}</version>
-			</dependency>
-			<dependency>
-				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-jackson-jaxb</artifactId>
-				<version>${feign.version}</version>
-			</dependency>
-			<dependency>
-				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-jackson</artifactId>
-				<version>${feign.version}</version>
-			</dependency>
-			<dependency>
-				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-jaxb</artifactId>
-				<version>${feign.version}</version>
-			</dependency>
-			<dependency>
-				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-jaxrs</artifactId>
-				<version>${feign.version}</version>
-			</dependency>
-			<dependency>
-				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-ribbon</artifactId>
-				<version>${feign.version}</version>
-			</dependency>
-			<dependency>
-				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-sax</artifactId>
-				<version>${feign.version}</version>
-			</dependency>
-			<dependency>
-				<groupId>io.github.openfeign</groupId>
-				<artifactId>feign-mock</artifactId>
-				<version>${feign.version}</version>
-			</dependency>
 		</dependencies>
 	</dependencyManagement>
 	<profiles>

spring-cloud-starter-openfeign/pom.xml

@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-openfeign</artifactId>
-		<version>2.2.4.BUILD-SNAPSHOT</version>
+		<version>2.2.7.RELEASE</version>
 		<relativePath>..</relativePath>
 	</parent>
 	<artifactId>spring-cloud-starter-openfeign</artifactId>

src/checkstyle/checkstyle-suppressions.xml

@@ -3,16 +3,19 @@
 		"-//Puppy Crawl//DTD Suppressions 1.1//EN"
 		"https://www.puppycrawl.com/dtds/suppressions_1_1.dtd">
 <suppressions>
-	<suppress files=".*FeignClientTests.*" checks="LineLengthCheck" />
-	<suppress files=".*FeignClientsRegistrarTests.*" checks="LineLengthCheck" />
-	<suppress files=".*FeignRibbonHttpClientConfigurationTests.*" checks="LineLengthCheck" />
-	<suppress files=".*FeignRibbonOkHttpClientConfigurationTests.*" checks="LineLengthCheck" />
-	<suppress files=".*InvoiceClient.*" checks="LineLengthCheck" />
-	<suppress files=".*InvoiceResource.*" checks="LineLengthCheck" />
-	<suppress files=".*IterableParameterTests.*" checks="LineLengthCheck" />
-	<suppress files=".*LoadBalancerFeignClientOverrideTests.*" checks="LineLengthCheck" />
-	<suppress files=".*ProtobufSpringEncoderTest.*" checks="LineLengthCheck" />
-	<suppress files=".*ProtobufTest.*" checks="LineLengthCheck" />
+	<suppress files=".*FeignClientTests.*" checks="LineLengthCheck"/>
+	<suppress files=".*FeignClientsRegistrarTests.*" checks="LineLengthCheck"/>
+	<suppress files=".*FeignRibbonHttpClientConfigurationTests.*"
+			  checks="LineLengthCheck"/>
+	<suppress files=".*FeignRibbonOkHttpClientConfigurationTests.*"
+			  checks="LineLengthCheck"/>
+	<suppress files=".*InvoiceClient.*" checks="LineLengthCheck"/>
+	<suppress files=".*InvoiceResource.*" checks="LineLengthCheck"/>
+	<suppress files=".*IterableParameterTests.*" checks="LineLengthCheck"/>
+	<suppress files=".*LoadBalancerFeignClientOverrideTests.*" checks="LineLengthCheck"/>
+	<suppress files=".*ProtobufSpringEncoderTest.*" checks="LineLengthCheck"/>
+	<suppress files=".*ProtobufTest.*" checks="LineLengthCheck"/>
+	<suppress files=".*Hello.*" checks="RedundantModifier"/>
 	<!-- Important -->
-	<suppress files=".*HttpEncoding.*" checks="InterfaceIsTypeCheck" />
+	<suppress files=".*HttpEncoding.*" checks="InterfaceIsTypeCheck"/>
 </suppressions>