Update SNAPSHOT to 2.0.0.M2

Fixes gh-5

.github/CONTRIBUTING.md

@@ -9,15 +9,15 @@ follow the guidelines below.
 
 ## Sign the Contributor License Agreement
 Before we accept a non-trivial patch or pull request we will need you to sign the
-https://cla.pivotal.io/sign/spring[Contributor License Agreement].
+[Contributor License Agreement](https://cla.pivotal.io/sign/spring).
 Signing the contributor's agreement does not grant anyone commit rights to the main
 repository, but it does mean that we can accept your contributions, and you will get an
 author credit if we do.  Active contributors might be asked to join the core team, and
 given the ability to merge pull requests.
 
 ## Code of Conduct
-This project adheres to the Contributor Covenant https://github.com/spring-cloud/spring-cloud-build/blob/master/docs/src/main/asciidoc/code-of-conduct.adoc[code of
-conduct]. By participating, you  are expected to uphold this code. Please report
+This project adheres to the Contributor Covenant [code of
+conduct](https://github.com/spring-cloud/spring-cloud-build/blob/master/docs/src/main/asciidoc/code-of-conduct.adoc). By participating, you  are expected to uphold this code. Please report
 unacceptable behavior to spring-code-of-conduct@pivotal.io.
 
 ## Code Conventions and Housekeeping
@@ -27,10 +27,8 @@ added after the original pull request but before a merge.
 * Use the Spring Framework code format conventions. If you use Eclipse
   you can import formatter settings using the
   `eclipse-code-formatter.xml` file from the
-  https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-dependencies-parent/eclipse-code-formatter.xml[Spring
-  Cloud Build] project. If using IntelliJ, you can use the
-  http://plugins.jetbrains.com/plugin/6546[Eclipse Code Formatter
-  Plugin] to import the same file.
+  [Spring Cloud Build](https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-dependencies-parent/eclipse-code-formatter.xml) project. If using IntelliJ, you can use the
+  [Eclipse Code Formatter Plugin](http://plugins.jetbrains.com/plugin/6546) to import the same file.
 * Make sure all new `.java` files to have a simple Javadoc class comment with at least an
   `@author` tag identifying you, and preferably at least a paragraph on what the class is
   for.
@@ -42,6 +40,6 @@ added after the original pull request but before a merge.
 * A few unit tests would help a lot as well -- someone has to do it.
 * If no-one else is using your branch, please rebase it against the current master (or
   other target branch in the main project).
-* When writing a commit message please follow http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html[these conventions],
+* When writing a commit message please follow [these conventions](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html),
   if you are fixing an existing issue please add `Fixes gh-XXXX` at the end of the commit
-  message (where XXXX is the issue number).
+  message (where XXXX is the issue number).

README.adoc

@@ -2,6 +2,10 @@
 
 image:https://circleci.com/gh/spring-cloud/spring-cloud-openfeign.svg?style=svg["CircleCI", link="https://circleci.com/gh/spring-cloud/spring-cloud-openfeign"]
 
+image:https://codecov.io/gh/spring-cloud/spring-cloud-openfeign/branch/master/graph/badge.svg["Codecov", link="https://codecov.io/gh/spring-cloud/spring-cloud-openfeign"]
+
+image:https://api.codacy.com/project/badge/Grade/97b04c4e609c4b4f86b415e4437a6484["Codacy code quality", link="https://www.codacy.com/app/Spring-Cloud/spring-cloud-openfeign?utm_source=github.com&utm_medium=referral&utm_content=spring-cloud/spring-cloud-openfeign&utm_campaign=Badge_Grade"]
+
 This project provides OpenFeign integrations for Spring Boot apps through autoconfiguration
 and binding to the Spring Environment and other Spring programming model idioms.
 

codecov.yml

@@ -0,0 +1,7 @@
+comment:
+  layout: "reach, diff, flags, files"
+  behavior: default
+  require_changes: false  # if true: only post the comment if coverage changes
+  require_base: no        # [yes :: must have a base report to post]
+  require_head: yes       # [yes :: must have a head report to post]
+  branches: null

docs/pom.xml

@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-openfeign</artifactId>
-		<version>2.0.0.M1</version>
+		<version>2.0.0.M2</version>
 	</parent>
 	<artifactId>spring-cloud-openfeign-docs</artifactId>
 	<packaging>pom</packaging>

docs/src/main/asciidoc/README.adoc

@@ -1,5 +1,9 @@
 image:https://circleci.com/gh/spring-cloud/spring-cloud-openfeign.svg?style=svg["CircleCI", link="https://circleci.com/gh/spring-cloud/spring-cloud-openfeign"]
 
+image:https://codecov.io/gh/spring-cloud/spring-cloud-openfeign/branch/master/graph/badge.svg["Codecov", link="https://codecov.io/gh/spring-cloud/spring-cloud-openfeign"]
+
+image:https://api.codacy.com/project/badge/Grade/97b04c4e609c4b4f86b415e4437a6484["Codacy code quality", link="https://www.codacy.com/app/Spring-Cloud/spring-cloud-openfeign?utm_source=github.com&utm_medium=referral&utm_content=spring-cloud/spring-cloud-openfeign&utm_campaign=Badge_Grade"]
+
 include::intro.adoc[]
 
 == Features

pom.xml

@@ -3,14 +3,14 @@
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>spring-cloud-openfeign</artifactId>
-	<version>2.0.0.M1</version>
+	<version>2.0.0.M2</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.0.0.RC1</version>
+		<version>2.0.0.RC2</version>
 		<relativePath />
 	</parent>
 	<scm>
@@ -22,8 +22,8 @@
 	<properties>
 		<main.basedir>${basedir}</main.basedir>
 		<jackson.version>2.7.3</jackson.version>
-		<spring-cloud-commons.version>2.0.0.M7</spring-cloud-commons.version>
-		<spring-cloud-netflix.version>2.0.0.M7</spring-cloud-netflix.version>
+		<spring-cloud-commons.version>2.0.0.M9</spring-cloud-commons.version>
+		<spring-cloud-netflix.version>2.0.0.M8</spring-cloud-netflix.version>
 
 		<!-- Plugin versions -->
 		<maven-compiler-plugin.version>3.6.1</maven-compiler-plugin.version>

spring-cloud-openfeign-core/pom.xml

@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-openfeign</artifactId>
-		<version>2.0.0.M1</version>
+		<version>2.0.0.M2</version>
 		<relativePath>..</relativePath> <!-- lookup parent from repository -->
 	</parent>
 	<artifactId>spring-cloud-openfeign-core</artifactId>

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

@@ -18,10 +18,7 @@ package org.springframework.cloud.openfeign.ribbon;
 
 import java.util.Map;
 
-import org.springframework.cloud.client.loadbalancer.LoadBalancedBackOffPolicyFactory;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryListenerFactory;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory;
-import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicyFactory;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
 import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
 import org.springframework.util.ConcurrentReferenceHashMap;
@@ -40,72 +37,29 @@ import com.netflix.loadbalancer.ILoadBalancer;
 public class CachingSpringLoadBalancerFactory {
 
 	private final SpringClientFactory factory;
-	private final LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory;
-	private final LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory;
-	private final LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory;
-	private boolean enableRetry = false;
+	private LoadBalancedRetryFactory loadBalancedRetryFactory = null;
 
 	private volatile Map<String, FeignLoadBalancer> cache = new ConcurrentReferenceHashMap<>();
 
 	public CachingSpringLoadBalancerFactory(SpringClientFactory factory) {
 		this.factory = factory;
-		this.loadBalancedRetryPolicyFactory = new RibbonLoadBalancedRetryPolicyFactory(factory);
-		this.loadBalancedBackOffPolicyFactory = null;
-		this.loadBalancedRetryListenerFactory = null;
 	}
 
-	@Deprecated
-	//TODO remove in 2.0.x
-	public CachingSpringLoadBalancerFactory(SpringClientFactory factory,
-											LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory) {
+	public CachingSpringLoadBalancerFactory(SpringClientFactory factory, LoadBalancedRetryFactory loadBalancedRetryPolicyFactory) {
 		this.factory = factory;
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-		this.loadBalancedBackOffPolicyFactory = null;
-		this.loadBalancedRetryListenerFactory = null;
-	}
-
-	@Deprecated
-	//TODO remove in 2.0.0x
-	public CachingSpringLoadBalancerFactory(SpringClientFactory factory,
-											LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory, boolean enableRetry) {
-		this.factory = factory;
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-		this.enableRetry = enableRetry;
-		this.loadBalancedBackOffPolicyFactory = null;
-		this.loadBalancedRetryListenerFactory = null;
-	}
-
-	@Deprecated
-	//TODO remove in 2.0.0x
-	public CachingSpringLoadBalancerFactory(SpringClientFactory factory,
-											LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory,
-											LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory) {
-		this.factory = factory;
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-		this.loadBalancedBackOffPolicyFactory = loadBalancedBackOffPolicyFactory;
-		this.loadBalancedRetryListenerFactory = null;
-		this.enableRetry = true;
-	}
-
-	public CachingSpringLoadBalancerFactory(SpringClientFactory factory, LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory,
-											LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
-											LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
-		this.factory = factory;
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-		this.loadBalancedBackOffPolicyFactory = loadBalancedBackOffPolicyFactory;
-		this.loadBalancedRetryListenerFactory = loadBalancedRetryListenerFactory;
-		this.enableRetry = true;
+		this.loadBalancedRetryFactory = loadBalancedRetryPolicyFactory;
 	}
 
 	public FeignLoadBalancer create(String clientName) {
-		if (this.cache.containsKey(clientName)) {
-			return this.cache.get(clientName);
+		FeignLoadBalancer client = this.cache.get(clientName);
+		if(client != null) {
+			return client;
 		}
 		IClientConfig config = this.factory.getClientConfig(clientName);
 		ILoadBalancer lb = this.factory.getLoadBalancer(clientName);
 		ServerIntrospector serverIntrospector = this.factory.getInstance(clientName, ServerIntrospector.class);
-		FeignLoadBalancer client = enableRetry ? new RetryableFeignLoadBalancer(lb, config, serverIntrospector,
-			loadBalancedRetryPolicyFactory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory) : new FeignLoadBalancer(lb, config, serverIntrospector);
+		client = loadBalancedRetryFactory != null ? new RetryableFeignLoadBalancer(lb, config, serverIntrospector,
+			loadBalancedRetryFactory) : new FeignLoadBalancer(lb, config, serverIntrospector);
 		this.cache.put(clientName, client);
 		return client;
 	}

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

@@ -21,9 +21,7 @@ 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.context.properties.EnableConfigurationProperties;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedBackOffPolicyFactory;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryListenerFactory;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.openfeign.FeignAutoConfiguration;
 import org.springframework.cloud.openfeign.support.FeignHttpClientProperties;
 import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
@@ -67,10 +65,8 @@ public class FeignRibbonClientAutoConfiguration {
 	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
 	public CachingSpringLoadBalancerFactory retryabeCachingLBClientFactory(
 		SpringClientFactory factory,
-		LoadBalancedRetryPolicyFactory retryPolicyFactory,
-		LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
-		LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
-		return new CachingSpringLoadBalancerFactory(factory, retryPolicyFactory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
+		LoadBalancedRetryFactory retryFactory) {
+		return new CachingSpringLoadBalancerFactory(factory, retryFactory);
 	}
 
 	@Bean

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

@@ -24,12 +24,10 @@ import feign.Response;
 import java.io.IOException;
 import java.net.URI;
 import org.springframework.cloud.client.ServiceInstance;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedBackOffPolicyFactory;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRecoveryCallback;
 import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryListenerFactory;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory;
-import org.springframework.cloud.client.loadbalancer.RibbonRecoveryCallback;
 import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser;
 import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
 import org.springframework.cloud.netflix.ribbon.RibbonProperties;
@@ -55,45 +53,13 @@ import com.netflix.loadbalancer.Server;
  */
 public class RetryableFeignLoadBalancer extends FeignLoadBalancer implements ServiceInstanceChooser {
 
-	private final LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory;
-	private final LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory;
-	private final LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory;
-
-	@Deprecated
-	//TODO remove in 2.0.x
-	public RetryableFeignLoadBalancer(ILoadBalancer lb, IClientConfig clientConfig,
-							 ServerIntrospector serverIntrospector, LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory) {
-		super(lb, clientConfig, serverIntrospector);
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-		this.setRetryHandler(new DefaultLoadBalancerRetryHandler(clientConfig));
-		this.loadBalancedBackOffPolicyFactory = new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory();
-		this.loadBalancedRetryListenerFactory = new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory();
-	}
-
-	@Deprecated
-	//TODO remove in 2.0.x
-	public RetryableFeignLoadBalancer(ILoadBalancer lb, IClientConfig clientConfig,
-									  ServerIntrospector serverIntrospector, LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory,
-									  LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory) {
-		super(lb, clientConfig, serverIntrospector);
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-		this.setRetryHandler(new DefaultLoadBalancerRetryHandler(clientConfig));
-		this.loadBalancedBackOffPolicyFactory = loadBalancedBackOffPolicyFactory == null ?
-			new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory() : loadBalancedBackOffPolicyFactory;
-		this.loadBalancedRetryListenerFactory = new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory();
-	}
+	private final LoadBalancedRetryFactory loadBalancedRetryFactory;
 
 	public RetryableFeignLoadBalancer(ILoadBalancer lb, IClientConfig clientConfig, ServerIntrospector serverIntrospector,
-									  LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory,
-									  LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
-									  LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
+									  LoadBalancedRetryFactory loadBalancedRetryFactory) {
 		super(lb, clientConfig, serverIntrospector);
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
+		this.loadBalancedRetryFactory = loadBalancedRetryFactory;
 		this.setRetryHandler(new DefaultLoadBalancerRetryHandler(clientConfig));
-		this.loadBalancedBackOffPolicyFactory = loadBalancedBackOffPolicyFactory == null ?
-			new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory() : loadBalancedBackOffPolicyFactory;
-		this.loadBalancedRetryListenerFactory = loadBalancedRetryListenerFactory == null ?
-			new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory() : loadBalancedRetryListenerFactory;
 	}
 
 	@Override
@@ -109,11 +75,11 @@ public class RetryableFeignLoadBalancer extends FeignLoadBalancer implements Ser
 		else {
 			options = new Request.Options(this.connectTimeout, this.readTimeout);
 		}
-		final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryPolicyFactory.create(this.getClientName(), this);
+		final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryFactory.createRetryPolicy(this.getClientName(), this);
 		RetryTemplate retryTemplate = new RetryTemplate();
-		BackOffPolicy backOffPolicy = loadBalancedBackOffPolicyFactory.createBackOffPolicy(this.getClientName());
+		BackOffPolicy backOffPolicy = loadBalancedRetryFactory.createBackOffPolicy(this.getClientName());
 		retryTemplate.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy);
-		RetryListener[] retryListeners = this.loadBalancedRetryListenerFactory.createRetryListeners(this.getClientName());
+		RetryListener[] retryListeners = this.loadBalancedRetryFactory.createRetryListeners(this.getClientName());
 		if (retryListeners != null && retryListeners.length != 0) {
 			retryTemplate.setListeners(retryListeners);
 		}
@@ -136,14 +102,14 @@ public class RetryableFeignLoadBalancer extends FeignLoadBalancer implements Ser
 				}
 				Response response = request.client().execute(feignRequest, options);
 				if (retryPolicy.retryableStatusCode(response.status())) {
-					byte[] byteArray = StreamUtils.copyToByteArray(response.body().asInputStream());
+					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 RibbonRecoveryCallback<RibbonResponse, Response>() {
+		}, new LoadBalancedRecoveryCallback<RibbonResponse, Response>() {
 			@Override
 			protected RibbonResponse createResponse(Response response, URI uri) {
 				return new RibbonResponse(uri, response);

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

@@ -23,9 +23,7 @@ import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedBackOffPolicyFactory;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryListenerFactory;
-import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicyFactory;
+import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryFactory;
 import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
 
 import static org.junit.Assert.assertNotNull;
@@ -42,13 +40,7 @@ public class CachingSpringLoadBalancerFactoryTests {
 	private SpringClientFactory delegate;
 
 	@Mock
-	private RibbonLoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory;
-
-	@Mock
-	private LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory;
-
-	@Mock
-	private LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory;
+	private RibbonLoadBalancedRetryFactory loadBalancedRetryFactory;
 
 	private CachingSpringLoadBalancerFactory factory;
 
@@ -64,7 +56,7 @@ public class CachingSpringLoadBalancerFactoryTests {
 		when(this.delegate.getClientConfig("client2")).thenReturn(config);
 
 		this.factory = new CachingSpringLoadBalancerFactory(this.delegate,
-				loadBalancedRetryPolicyFactory);
+				loadBalancedRetryFactory);
 	}
 
 	@Test
@@ -103,34 +95,8 @@ public class CachingSpringLoadBalancerFactoryTests {
 		config.set(CommonClientConfigKey.ConnectTimeout, 1000);
 		config.set(CommonClientConfigKey.ReadTimeout, 500);
 		when(this.delegate.getClientConfig("retry")).thenReturn(config);
-		CachingSpringLoadBalancerFactory factory = new CachingSpringLoadBalancerFactory(
-			this.delegate, loadBalancedRetryPolicyFactory, false);
+		CachingSpringLoadBalancerFactory factory = new CachingSpringLoadBalancerFactory(this.delegate, loadBalancedRetryFactory);
 		FeignLoadBalancer client = this.factory.create("retry");
 		assertNotNull("client was null", client);
 	}
-
-	@Test
-	public void delegateCreatesWithBackOff() {
-		IClientConfig config = new DefaultClientConfigImpl();
-		config.set(CommonClientConfigKey.ConnectTimeout, 1000);
-		config.set(CommonClientConfigKey.ReadTimeout, 500);
-		when(this.delegate.getClientConfig("retry")).thenReturn(config);
-		CachingSpringLoadBalancerFactory factory = new CachingSpringLoadBalancerFactory(
-			this.delegate, loadBalancedRetryPolicyFactory, loadBalancedBackOffPolicyFactory);
-		FeignLoadBalancer client = this.factory.create("retry");
-		assertNotNull("client was null", client);
-	}
-
-	@Test
-	public void delegateCreatesWithRetryListener() {
-		IClientConfig config = new DefaultClientConfigImpl();
-		config.set(CommonClientConfigKey.ConnectTimeout, 1000);
-		config.set(CommonClientConfigKey.ReadTimeout, 500);
-		when(this.delegate.getClientConfig("retry")).thenReturn(config);
-		CachingSpringLoadBalancerFactory factory = new CachingSpringLoadBalancerFactory(
-			this.delegate, loadBalancedRetryPolicyFactory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
-		FeignLoadBalancer client = this.factory.create("retry");
-		assertNotNull("client was null", client);
-	}
-
 }

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

@@ -32,7 +32,6 @@ import org.hamcrest.CustomMatcher;
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.cloud.netflix.ribbon.DefaultServerIntrospector;
-import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicyFactory;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
 import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
 
@@ -48,7 +47,6 @@ public class FeignRibbonClientTests {
 
 	private AbstractLoadBalancer loadBalancer = mock(AbstractLoadBalancer.class);
 	private Client delegate = mock(Client.class);
-	private RibbonLoadBalancedRetryPolicyFactory retryPolicyFactory = mock(RibbonLoadBalancedRetryPolicyFactory.class);
 
 	private SpringClientFactory factory = new SpringClientFactory() {
 		@Override
@@ -77,8 +75,7 @@ public class FeignRibbonClientTests {
 
 	// Even though we don't maintain FeignRibbonClient, keep these tests
 	// around to make sure the expected behaviour doesn't break
-	private Client client = new LoadBalancerFeignClient(this.delegate, new CachingSpringLoadBalancerFactory(this.factory,
-			retryPolicyFactory), this.factory);
+	private Client client = new LoadBalancerFeignClient(this.delegate, new CachingSpringLoadBalancerFactory(this.factory), this.factory);
 
 	@Before
 	public void init() {

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

@@ -37,14 +37,12 @@ import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.springframework.cloud.client.ServiceInstance;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedBackOffPolicyFactory;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryListenerFactory;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory;
 import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser;
 import org.springframework.cloud.netflix.ribbon.DefaultServerIntrospector;
+import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryFactory;
 import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicy;
-import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicyFactory;
 import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerContext;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
 import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
@@ -78,6 +76,7 @@ import static org.junit.Assert.assertEquals;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyBoolean;
 import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyObject;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
@@ -96,8 +95,6 @@ public class RetryableFeignLoadBalancerTests {
 	@Mock
 	private IClientConfig config;
 	private ServerIntrospector inspector = new DefaultServerIntrospector();
-	private LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory =
-			new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory();
 
 	private Integer defaultConnectTimeout = 10000;
 	private Integer defaultReadTimeout = 10000;
@@ -128,7 +125,7 @@ public class RetryableFeignLoadBalancerTests {
 		doReturn(defaultReadTimeout).when(config).get(eq(CommonClientConfigKey.ReadTimeout));
 		doReturn("404,502,foo, ,").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq(""));
 		doReturn(config).when(clientFactory).getClientConfig(eq("default"));
-		RibbonLoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		RibbonLoadBalancedRetryFactory loadBalancedRetryFactory = new RibbonLoadBalancedRetryFactory(clientFactory);
 		HttpRequest springRequest = mock(HttpRequest.class);
 		Request feignRequest = Request.create("GET", "http://foo", new HashMap<String, Collection<String>>(),
 				new byte[]{}, StandardCharsets.UTF_8);
@@ -136,8 +133,7 @@ public class RetryableFeignLoadBalancerTests {
 		FeignLoadBalancer.RibbonRequest request = new FeignLoadBalancer.RibbonRequest(client, feignRequest, new URI("http://foo"));
 		Response response = Response.builder().status(200).headers(new HashMap<String, Collection<String>>()).build();
 		doReturn(response).when(client).execute(any(Request.class), any(Request.Options.class));
-		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryPolicyFactory,
-				loadBalancedBackOffPolicyFactory);
+		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryFactory);
 		FeignLoadBalancer.RibbonResponse ribbonResponse = feignLb.execute(request, null);
 		assertEquals(200, ribbonResponse.toResponse().status());
 		verify(client, times(1)).execute(any(Request.class), any(Request.Options.class));
@@ -151,12 +147,22 @@ public class RetryableFeignLoadBalancerTests {
 		Client client = mock(Client.class);
 		FeignLoadBalancer.RibbonRequest request = new FeignLoadBalancer.RibbonRequest(client, feignRequest, new URI("http://foo"));
 		doThrow(new IOException("boom")).when(client).execute(any(Request.class), any(Request.Options.class));
-		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, new LoadBalancedRetryPolicyFactory() {
+		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, new LoadBalancedRetryFactory() {
 			@Override
-			public LoadBalancedRetryPolicy create(String s, ServiceInstanceChooser serviceInstanceChooser) {
+			public LoadBalancedRetryPolicy createRetryPolicy(String s, ServiceInstanceChooser serviceInstanceChooser) {
 				return null;
 			}
-		}, loadBalancedBackOffPolicyFactory);
+
+			@Override
+			public RetryListener[] createRetryListeners(String service) {
+				return new RetryListener[0];
+			}
+
+			@Override
+			public BackOffPolicy createBackOffPolicy(String service) {
+				return null;
+			}
+		});
 		try {
 			feignLb.execute(request, null);
 		} catch(Exception e) {
@@ -179,7 +185,13 @@ public class RetryableFeignLoadBalancerTests {
 		doReturn("").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq(""));
 		doReturn(config).when(clientFactory).getClientConfig(eq("default"));
 		doReturn(lbContext).when(clientFactory).getLoadBalancerContext(any(String.class));
-		RibbonLoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		MyBackOffPolicy backOffPolicy = new MyBackOffPolicy();
+		RibbonLoadBalancedRetryFactory loadBalancedRetryFactory = new RibbonLoadBalancedRetryFactory(clientFactory){
+			@Override
+			public BackOffPolicy createBackOffPolicy(String service) {
+				return backOffPolicy;
+			}
+		};
 		HttpRequest springRequest = mock(HttpRequest.class);
 		Request feignRequest = Request.create("GET", "http://foo", new HashMap<String, Collection<String>>(),
 				new byte[]{}, StandardCharsets.UTF_8);
@@ -187,13 +199,12 @@ public class RetryableFeignLoadBalancerTests {
 		FeignLoadBalancer.RibbonRequest request = new FeignLoadBalancer.RibbonRequest(client, feignRequest, new URI("http://foo"));
 		Response response = Response.builder().status(200).headers(new HashMap<String, Collection<String>>()).build();
 		doThrow(new IOException("boom")).doReturn(response).when(client).execute(any(Request.class), any(Request.Options.class));
-		MyBackOffPolicyFactory backOffPolicyFactory = new MyBackOffPolicyFactory();
-		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryPolicyFactory,
-				backOffPolicyFactory);
+
+		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryFactory);
 		FeignLoadBalancer.RibbonResponse ribbonResponse = feignLb.execute(request, null);
 		assertEquals(200, ribbonResponse.toResponse().status());
 		verify(client, times(2)).execute(any(Request.class), any(Request.Options.class));
-		assertEquals(1, backOffPolicyFactory.getCount());
+		assertEquals(1, backOffPolicy.getCount());
 	}
 
 	@Test
@@ -209,7 +220,13 @@ public class RetryableFeignLoadBalancerTests {
 		doReturn("404").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq(""));
 		doReturn(config).when(clientFactory).getClientConfig(eq("default"));
 		doReturn(lbContext).when(clientFactory).getLoadBalancerContext(any(String.class));
-		RibbonLoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		MyBackOffPolicy backOffPolicy = new MyBackOffPolicy();
+		RibbonLoadBalancedRetryFactory loadBalancedRetryFactory = new RibbonLoadBalancedRetryFactory(clientFactory){
+			@Override
+			public BackOffPolicy createBackOffPolicy(String service) {
+				return backOffPolicy;
+			}
+		};
 		HttpRequest springRequest = mock(HttpRequest.class);
 		Request feignRequest = Request.create("GET", "http://foo", new HashMap<String, Collection<String>>(),
 				new byte[]{}, StandardCharsets.UTF_8);
@@ -218,13 +235,51 @@ public class RetryableFeignLoadBalancerTests {
 		Response response = Response.builder().status(200).headers(new HashMap<String, Collection<String>>()).build();
 		Response fourOFourResponse = Response.builder().status(404).headers(new HashMap<String, Collection<String>>()).build();
 		doReturn(fourOFourResponse).doReturn(response).when(client).execute(any(Request.class), any(Request.Options.class));
-		MyBackOffPolicyFactory backOffPolicyFactory = new MyBackOffPolicyFactory();
-		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryPolicyFactory,
-				backOffPolicyFactory);
+		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryFactory);
 		FeignLoadBalancer.RibbonResponse ribbonResponse = feignLb.execute(request, null);
 		assertEquals(200, ribbonResponse.toResponse().status());
 		verify(client, times(2)).execute(any(Request.class), any(Request.Options.class));
-		assertEquals(1, backOffPolicyFactory.getCount());
+		assertEquals(1, backOffPolicy.getCount());
+	}
+
+		@Test
+	public void executeRetryOnStatusCodeWithEmptyBody() throws Exception {
+			int retriesNextServer = 0;
+			when(this.config.get(MaxAutoRetriesNextServer,
+							DEFAULT_MAX_AUTO_RETRIES_NEXT_SERVER)).thenReturn(retriesNextServer);
+			doReturn(new Server("foo", 80)).when(lb).chooseServer(anyObject());
+			RibbonLoadBalancerContext lbContext = new RibbonLoadBalancerContext(lb, config);
+			SpringClientFactory clientFactory = mock(SpringClientFactory.class);
+			IClientConfig config = mock(IClientConfig.class);
+			doReturn(1).when(config).get(eq(CommonClientConfigKey.MaxAutoRetries), anyInt());
+			doReturn(retriesNextServer).when(config).get(eq(CommonClientConfigKey.MaxAutoRetriesNextServer), anyInt());
+			doReturn(true).when(config).get(eq(CommonClientConfigKey.OkToRetryOnAllOperations), eq(false));
+			doReturn(defaultConnectTimeout).when(config).get(eq(CommonClientConfigKey.ConnectTimeout));
+			doReturn(defaultReadTimeout).when(config).get(eq(CommonClientConfigKey.ReadTimeout));
+			doReturn("404").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq(""));
+			doReturn(config).when(clientFactory).getClientConfig(eq("default"));
+			doReturn(lbContext).when(clientFactory).getLoadBalancerContext(any(String.class));
+			MyBackOffPolicy backOffPolicy = new MyBackOffPolicy();
+			RibbonLoadBalancedRetryFactory loadBalancedRetryFactory = new RibbonLoadBalancedRetryFactory(clientFactory){
+				@Override
+				public BackOffPolicy createBackOffPolicy(String service) {
+					return backOffPolicy;
+				}
+			};
+			HttpRequest springRequest = mock(HttpRequest.class);
+			Request feignRequest = Request.create("GET", "http://foo", new HashMap<String, Collection<String>>(),
+							new byte[]{}, StandardCharsets.UTF_8);
+			Client client = mock(Client.class);
+			FeignLoadBalancer.RibbonRequest request = new FeignLoadBalancer.RibbonRequest(client, feignRequest, new URI("http://foo"));
+			Response response = Response.builder().status(404).headers(new HashMap<String, Collection<String>>()).build();
+			Response fourOFourResponse = Response.builder().status(404).headers(new HashMap<String, Collection<String>>()).build();
+			doReturn(fourOFourResponse).doReturn(response).when(client).execute(any(Request.class), any(Request.Options.class));
+			RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryFactory);
+			FeignLoadBalancer.RibbonResponse ribbonResponse = feignLb.execute(request, null);
+			assertEquals(404, ribbonResponse.toResponse().status());
+			assertEquals(new Integer(0), ribbonResponse.toResponse().body().length());
+			verify(client, times(2)).execute(any(Request.class), any(Request.Options.class));
+			assertEquals(1, backOffPolicy.getCount());
 	}
 
 	@Test
@@ -232,7 +287,7 @@ public class RetryableFeignLoadBalancerTests {
 		RibbonLoadBalancerContext lbContext = new RibbonLoadBalancerContext(lb, config);
 		SpringClientFactory clientFactory = mock(SpringClientFactory.class);
 		doReturn(lbContext).when(clientFactory).getLoadBalancerContext(any(String.class));
-		RibbonLoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		RibbonLoadBalancedRetryFactory loadBalancedRetryFactory = new RibbonLoadBalancedRetryFactory(clientFactory);
 		HttpRequest springRequest = mock(HttpRequest.class);
 		Request feignRequest = Request.create("GET", "http://foo", new HashMap<String, Collection<String>>(),
 				new byte[]{}, StandardCharsets.UTF_8);
@@ -240,8 +295,7 @@ public class RetryableFeignLoadBalancerTests {
 		FeignLoadBalancer.RibbonRequest request = new FeignLoadBalancer.RibbonRequest(client, feignRequest, new URI("http://foo"));
 		Response response = Response.builder().status(200).headers(new HashMap<String, Collection<String>>()).build();
 		doReturn(response).when(client).execute(any(Request.class), any(Request.Options.class));
-		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryPolicyFactory,
-				loadBalancedBackOffPolicyFactory);
+		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryFactory);
 		RequestSpecificRetryHandler retryHandler = feignLb.getRequestSpecificRetryHandler(request, config);
 		assertEquals(1, retryHandler.getMaxRetriesOnNextServer());
 		assertEquals(1, retryHandler.getMaxRetriesOnSameServer());
@@ -253,7 +307,7 @@ public class RetryableFeignLoadBalancerTests {
 		RibbonLoadBalancerContext lbContext = new RibbonLoadBalancerContext(lb, config);
 		SpringClientFactory clientFactory = mock(SpringClientFactory.class);
 		doReturn(lbContext).when(clientFactory).getLoadBalancerContext(any(String.class));
-		RibbonLoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		RibbonLoadBalancedRetryFactory loadBalancedRetryFactory = new RibbonLoadBalancedRetryFactory(clientFactory);
 		HttpRequest springRequest = mock(HttpRequest.class);
 		Request feignRequest = Request.create("GET", "http://foo", new HashMap<String, Collection<String>>(),
 				new byte[]{}, StandardCharsets.UTF_8);
@@ -292,7 +346,7 @@ public class RetryableFeignLoadBalancerTests {
 			public List<Server> getAllServers() {
 				return null;
 			}
-		}, config, inspector, loadBalancedRetryPolicyFactory, loadBalancedBackOffPolicyFactory);
+		}, config, inspector, loadBalancedRetryFactory);
 		ServiceInstance serviceInstance = feignLb.choose("foo");
 		assertEquals("foo", serviceInstance.getHost());
 		assertEquals(80, serviceInstance.getPort());
@@ -312,7 +366,19 @@ public class RetryableFeignLoadBalancerTests {
 		doReturn("").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq(""));
 		doReturn(config).when(clientFactory).getClientConfig(eq("default"));
 		doReturn(lbContext).when(clientFactory).getLoadBalancerContext(any(String.class));
-		RibbonLoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		MyBackOffPolicy backOffPolicy = new MyBackOffPolicy();
+		MyRetryListener myRetryListener = new MyRetryListener();
+		RibbonLoadBalancedRetryFactory loadBalancedRetryFactory = new RibbonLoadBalancedRetryFactory(clientFactory) {
+			@Override
+			public RetryListener[] createRetryListeners(String service) {
+				return new RetryListener[]{myRetryListener};
+			}
+
+			@Override
+			public BackOffPolicy createBackOffPolicy(String service) {
+				return backOffPolicy;
+			}
+		};
 		HttpRequest springRequest = mock(HttpRequest.class);
 		Request feignRequest = Request.create("GET", "http://listener", new HashMap<String, Collection<String>>(),
 			new byte[]{}, StandardCharsets.UTF_8);
@@ -320,15 +386,13 @@ public class RetryableFeignLoadBalancerTests {
 		FeignLoadBalancer.RibbonRequest request = new FeignLoadBalancer.RibbonRequest(client, feignRequest, new URI("http://listener"));
 		Response response = Response.builder().status(200).headers(new HashMap<String, Collection<String>>()).build();
 		doThrow(new IOException("boom")).doReturn(response).when(client).execute(any(Request.class), any(Request.Options.class));
-		MyBackOffPolicyFactory backOffPolicyFactory = new MyBackOffPolicyFactory();
-		MyRetryListeners myRetryListeners = new MyRetryListeners();
-		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryPolicyFactory,
-			backOffPolicyFactory, myRetryListeners);
+
+		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryFactory);
 		FeignLoadBalancer.RibbonResponse ribbonResponse = feignLb.execute(request, null);
 		assertEquals(200, ribbonResponse.toResponse().status());
 		verify(client, times(2)).execute(any(Request.class), any(Request.Options.class));
-		assertEquals(1, backOffPolicyFactory.getCount());
-		assertEquals(1, myRetryListeners.getOnError());
+		assertEquals(1, backOffPolicy.getCount());
+		assertEquals(1, myRetryListener.getOnError());
 	}
 
 	@Test(expected = TerminatedRetryException.class)
@@ -344,17 +408,26 @@ public class RetryableFeignLoadBalancerTests {
 		doReturn("").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq(""));
 		doReturn(config).when(clientFactory).getClientConfig(eq("default"));
 		doReturn(lbContext).when(clientFactory).getLoadBalancerContext(any(String.class));
-		RibbonLoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		Response response = Response.builder().status(200).headers(new HashMap<String, Collection<String>>()).build();
+		MyBackOffPolicy backOffPolicy = new MyBackOffPolicy();
+		MyRetryListenerNotRetry myRetryListenerNotRetry = new MyRetryListenerNotRetry();
+		RibbonLoadBalancedRetryFactory loadBalancedRetryFactory = new RibbonLoadBalancedRetryFactory(clientFactory){
+			@Override
+			public RetryListener[] createRetryListeners(String service) {
+				return new RetryListener[]{myRetryListenerNotRetry};
+			}
+
+			@Override
+			public BackOffPolicy createBackOffPolicy(String service) {
+				return backOffPolicy;
+			}
+		};
 		HttpRequest springRequest = mock(HttpRequest.class);
 		Request feignRequest = Request.create("GET", "http://listener", new HashMap<String, Collection<String>>(),
 			new byte[]{}, StandardCharsets.UTF_8);
 		Client client = mock(Client.class);
 		FeignLoadBalancer.RibbonRequest request = new FeignLoadBalancer.RibbonRequest(client, feignRequest, new URI("http://listener"));
-		Response response = Response.builder().status(200).headers(new HashMap<String, Collection<String>>()).build();
-		MyBackOffPolicyFactory backOffPolicyFactory = new MyBackOffPolicyFactory();
-		MyRetryListenersNotRetry myRetryListenersNotRetry = new MyRetryListenersNotRetry();
-		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryPolicyFactory,
-			backOffPolicyFactory, myRetryListenersNotRetry);
+		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryFactory);
 		FeignLoadBalancer.RibbonResponse ribbonResponse = feignLb.execute(request, null);
 	}
 
@@ -371,7 +444,13 @@ public class RetryableFeignLoadBalancerTests {
 		doReturn("").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq(""));
 		doReturn(config).when(clientFactory).getClientConfig(eq("default"));
 		doReturn(lbContext).when(clientFactory).getLoadBalancerContext(any(String.class));
-		RibbonLoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		MyBackOffPolicy backOffPolicy = new MyBackOffPolicy();
+		RibbonLoadBalancedRetryFactory loadBalancedRetryPolicyFactory = new RibbonLoadBalancedRetryFactory(clientFactory){
+			@Override
+			public BackOffPolicy createBackOffPolicy(String service) {
+				return backOffPolicy;
+			}
+		};
 		HttpRequest springRequest = mock(HttpRequest.class);
 		Request feignRequest = Request.create("GET", "http://listener", new HashMap<String, Collection<String>>(),
 			new byte[]{}, StandardCharsets.UTF_8);
@@ -379,13 +458,11 @@ public class RetryableFeignLoadBalancerTests {
 		FeignLoadBalancer.RibbonRequest request = new FeignLoadBalancer.RibbonRequest(client, feignRequest, new URI("http://listener"));
 		Response response = Response.builder().status(200).headers(new HashMap<String, Collection<String>>()).build();
 		doThrow(new IOException("boom")).doReturn(response).when(client).execute(any(Request.class), any(Request.Options.class));
-		MyBackOffPolicyFactory backOffPolicyFactory = new MyBackOffPolicyFactory();
-		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryPolicyFactory,
-			backOffPolicyFactory);
+		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryPolicyFactory);
 		FeignLoadBalancer.RibbonResponse ribbonResponse = feignLb.execute(request, null);
 		assertEquals(200, ribbonResponse.toResponse().status());
 		verify(client, times(2)).execute(any(Request.class), any(Request.Options.class));
-		assertEquals(1, backOffPolicyFactory.getCount());
+		assertEquals(1, backOffPolicy.getCount());
 	}
 
 	@Test
@@ -402,7 +479,13 @@ public class RetryableFeignLoadBalancerTests {
 		doReturn("404").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES), eq(""));
 		doReturn(config).when(clientFactory).getClientConfig(eq("default"));
 		doReturn(lbContext).when(clientFactory).getLoadBalancerContext(any(String.class));
-		RibbonLoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		MyBackOffPolicy backOffPolicy = new MyBackOffPolicy();
+		RibbonLoadBalancedRetryFactory loadBalancedRetryFactory = new RibbonLoadBalancedRetryFactory(clientFactory){
+			@Override
+			public BackOffPolicy createBackOffPolicy(String service) {
+				return backOffPolicy;
+			}
+		};
 		HttpRequest springRequest = mock(HttpRequest.class);
 		Request feignRequest = Request.create("GET", "http://foo", new HashMap<String, Collection<String>>(),
 				new byte[]{}, StandardCharsets.UTF_8);
@@ -435,18 +518,17 @@ public class RetryableFeignLoadBalancerTests {
 					}
 				}).build();
 		doReturn(fourOFourResponse).when(client).execute(any(Request.class), any(Request.Options.class));
-		MyBackOffPolicyFactory backOffPolicyFactory = new MyBackOffPolicyFactory();
-		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryPolicyFactory, backOffPolicyFactory);
+		RetryableFeignLoadBalancer feignLb = new RetryableFeignLoadBalancer(lb, config, inspector, loadBalancedRetryFactory);
 		FeignLoadBalancer.RibbonResponse ribbonResponse = feignLb.execute(request, null);
 		verify(client, times(2)).execute(any(Request.class), any(Request.Options.class));
-		assertEquals(1, backOffPolicyFactory.getCount());
+		assertEquals(1, backOffPolicy.getCount());
 		InputStream inputStream = ribbonResponse.toResponse().body().asInputStream();
 		byte[] buf = new byte[100];
 		int read = inputStream.read(buf);
 		Assert.assertThat(new String(buf, 0, read), is("test"));
 	}
 
-	class MyBackOffPolicyFactory implements LoadBalancedBackOffPolicyFactory, BackOffPolicy {
+	class MyBackOffPolicy implements BackOffPolicy {
 
 		private int count = 0;
 
@@ -464,34 +546,25 @@ public class RetryableFeignLoadBalancerTests {
 			return count;
 		}
 
-		@Override
-		public BackOffPolicy createBackOffPolicy(String service) {
-			return this;
-		}
 	}
 
-	class MyRetryListeners implements LoadBalancedRetryListenerFactory {
+	class MyRetryListener implements RetryListener {
 
 		private int onError = 0;
 
 		@Override
-		public RetryListener[] createRetryListeners(String service) {
-			return new RetryListener[] {new RetryListener() {
-				@Override
-				public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
-					return true;
-				}
+		public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
+			return true;
+		}
 
-				@Override
-				public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
+		@Override
+		public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
 
-				}
+		}
 
-				@Override
-				public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
-					onError++;
-				}
-			}};
+		@Override
+		public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
+			onError++;
 		}
 
 		public int getOnError() {
@@ -499,27 +572,20 @@ public class RetryableFeignLoadBalancerTests {
 		}
 	}
 
-	class MyRetryListenersNotRetry implements LoadBalancedRetryListenerFactory {
+	class MyRetryListenerNotRetry implements RetryListener {
 
 		@Override
-		public RetryListener[] createRetryListeners(String service) {
-			return new RetryListener[] {new RetryListener() {
-				@Override
-				public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
-					return false;
-				}
-
-				@Override
-				public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
-
-				}
-
-				@Override
-				public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
-
-				}
-			}};
+		public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
+			return false;
 		}
+
+		@Override
+		public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
+
+		}
+
+		@Override
+		public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {}
 	}
 
 }

spring-cloud-openfeign-dependencies/pom.xml

@@ -5,11 +5,11 @@
 	<parent>
 		<artifactId>spring-cloud-dependencies-parent</artifactId>
 		<groupId>org.springframework.cloud</groupId>
-		<version>2.0.0.RC1</version>
+		<version>2.0.0.RC2</version>
 		<relativePath/>
 	</parent>
 	<artifactId>spring-cloud-openfeign-dependencies</artifactId>
-	<version>2.0.0.M1</version>
+	<version>2.0.0.M2</version>
 	<packaging>pom</packaging>
 	<name>spring-cloud-openfeign-dependencies</name>
 	<description>Spring Cloud OpenFeign Dependencies</description>

spring-cloud-starter-openfeign/pom.xml

@@ -4,7 +4,7 @@
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-openfeign</artifactId>
-		<version>2.0.0.M1</version>
+		<version>2.0.0.M2</version>
 		<relativePath>..</relativePath>
 	</parent>
 	<artifactId>spring-cloud-starter-openfeign</artifactId>