Update SNAPSHOT to 2.2.6.RELEASE

* Test to verify sub level client error

Error is described in https://github.com/spring-cloud/spring-cloud-openfeign/issues/331

Application fails when one Feign client is `org.TopClient` and second is in subpackage:  `org.sub.SubClient`

The error reason is that `SubClient` is registered twice

* Fix for @EnableFeignClients(clients) scans classes in nested packages twice

https://github.com/spring-cloud/spring-cloud-openfeign/issues/331
(cherry picked from commit fe62b0db90)

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

* delete unused code

(cherry picked from commit 4df865d1d6)

* add file header

* Apply review

Co-authored-by: michal <michal@michal-desktop>

docs/pom.xml

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-openfeign</artifactId>
-		<version>2.2.5.RELEASE</version>
+		<version>2.2.6.RELEASE</version>
 	</parent>
 	<artifactId>spring-cloud-openfeign-docs</artifactId>
 	<packaging>pom</packaging>

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

@@ -175,6 +175,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 +192,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 +274,42 @@ public FeignClientConfigurer feignClientConfigurer() {
 }
 ----
 
+[[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
@@ -565,7 +607,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:
 

pom.xml

@@ -4,7 +4,7 @@
 		 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.5.RELEASE</version>
+	<version>2.2.6.RELEASE</version>
 	<packaging>pom</packaging>
 	<name>Spring Cloud OpenFeign</name>
 	<description>Spring Cloud OpenFeign</description>
@@ -25,12 +25,11 @@
 	</scm>
 	<properties>
 		<main.basedir>${basedir}</main.basedir>
-		<jackson.version>2.7.3</jackson.version>
-		<spring-cloud-commons.version>2.2.5.RELEASE</spring-cloud-commons.version>
-		<spring-cloud-netflix.version>2.2.5.RELEASE</spring-cloud-netflix.version>
+		<jackson.version>2.11.3</jackson.version>
+		<spring-cloud-commons.version>2.2.6.RELEASE</spring-cloud-commons.version>
+		<spring-cloud-netflix.version>2.2.6.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.5.RELEASE</version>
+		<version>2.2.6.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.13.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>

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;
@@ -44,6 +46,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,6 +57,7 @@ import org.springframework.util.StringUtils;
  * @author Gregor Zurowski
  * @author Matt King
  * @author Olga Maciaszek-Sharma
+ * @author Ilia Ilinykh
  */
 class FeignClientFactoryBean
 		implements FactoryBean<Object>, InitializingBean, ApplicationContextAware {
@@ -173,7 +177,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 +245,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()));
 		}

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,7 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
 
 /**
  * @author Eko Kurniawan Khannedy
+ * @author Ilia Ilinykh
  */
 @ConfigurationProperties("feign.client")
 public class FeignClientProperties {
@@ -104,6 +106,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;
@@ -163,6 +169,24 @@ 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;
 		}
@@ -224,7 +248,11 @@ public class FeignClientProperties {
 					&& Objects.equals(this.decoder, that.decoder)
 					&& Objects.equals(this.contract, that.contract)
 					&& Objects.equals(this.exceptionPropagationPolicy,
-							that.exceptionPropagationPolicy);
+							that.exceptionPropagationPolicy)
+					&& Objects.equals(this.defaultRequestHeaders,
+							that.defaultRequestHeaders)
+					&& Objects.equals(this.defaultQueryParameters,
+							that.defaultQueryParameters);
 		}
 
 		@Override
@@ -232,7 +260,8 @@ public class FeignClientProperties {
 			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);
+					this.exceptionPropagationPolicy, this.defaultQueryParameters,
+					this.defaultRequestHeaders);
 		}
 
 	}

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

@@ -16,19 +16,18 @@
 
 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.support.AbstractBeanDefinition;
@@ -43,12 +42,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 +52,7 @@ import org.springframework.util.StringUtils;
  * @author Jakub Narloch
  * @author Venil Noronha
  * @author Gang Li
+ * @author Michal Domagala
  */
 class FeignClientsRegistrar
 		implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
@@ -165,11 +160,8 @@ 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(
@@ -177,48 +169,36 @@ class FeignClientsRegistrar
 		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);
 			}
 		}
 	}
@@ -398,38 +378,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/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/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,185 @@
+/*
+ * 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 = Request.create(request.httpMethod(), reconstructedUrl,
+							request.headers(), request.body(), request.charset(),
+							request.requestTemplate());
+				}
+			}
+			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;
+			}
+		});
+	}
+
+	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/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/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/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/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

@@ -10,7 +10,7 @@
 		<relativePath/>
 	</parent>
 	<artifactId>spring-cloud-openfeign-dependencies</artifactId>
-	<version>2.2.5.RELEASE</version>
+	<version>2.2.6.RELEASE</version>
 	<packaging>pom</packaging>
 	<name>spring-cloud-openfeign-dependencies</name>
 	<description>Spring Cloud OpenFeign Dependencies</description>

spring-cloud-starter-openfeign/pom.xml

@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-openfeign</artifactId>
-		<version>2.2.5.RELEASE</version>
+		<version>2.2.6.RELEASE</version>
 		<relativePath>..</relativePath>
 	</parent>
 	<artifactId>spring-cloud-starter-openfeign</artifactId>