Merge branch 'master' of github.com:spring-cloud/spring-cloud-netflix

2026-10-06 03:39:01 +00:00 · 2018-03-13 09:07:21 -04:00
parent eeb89e6e14 6dec4afef8
commit a533bc0649
13 changed files with 185 additions and 286 deletions
@@ -34,9 +34,7 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.client.actuator.HasFeatures;
 import org.springframework.cloud.client.loadbalancer.AsyncLoadBalancerAutoConfiguration;
-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.client.loadbalancer.LoadBalancerAutoConfiguration;
 import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
 import org.springframework.cloud.client.loadbalancer.RestTemplateCustomizer;
@@ -91,29 +89,8 @@ public class RibbonAutoConfiguration {
 	@Bean
 	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
 	@ConditionalOnMissingBean
-	public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory(SpringClientFactory clientFactory) {
-		return new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
-	}
-
-	@Bean
-	@ConditionalOnMissingClass(value = "org.springframework.retry.support.RetryTemplate")
-	@ConditionalOnMissingBean
-	public LoadBalancedRetryPolicyFactory neverRetryPolicyFactory() {
-		return new LoadBalancedRetryPolicyFactory.NeverRetryFactory();
-	}
-
-	@Bean
-	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
-	@ConditionalOnMissingBean
-	public LoadBalancedBackOffPolicyFactory loadBalancedBackoffPolicyFactory() {
-		return new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory();
-	}
-
-	@Bean
-	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
-	@ConditionalOnMissingBean
-	public LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory() {
-		return new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory();
+	public LoadBalancedRetryFactory loadBalancedRetryPolicyFactory(final SpringClientFactory clientFactory) {
+		return new RibbonLoadBalancedRetryFactory(clientFactory);
 	}

 	@Bean
@@ -15,26 +15,38 @@
 */
 package org.springframework.cloud.netflix.ribbon;

+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.retry.RetryListener;
+import org.springframework.retry.backoff.BackOffPolicy;

 /**
 * @author Ryan Baxter
 */
-public class RibbonLoadBalancedRetryPolicyFactory implements LoadBalancedRetryPolicyFactory {
+public class RibbonLoadBalancedRetryFactory implements LoadBalancedRetryFactory {

 	private SpringClientFactory clientFactory;

-	public RibbonLoadBalancedRetryPolicyFactory(SpringClientFactory clientFactory) {
+	public RibbonLoadBalancedRetryFactory(SpringClientFactory clientFactory) {
 		this.clientFactory = clientFactory;
 	}

 	@Override
-	public LoadBalancedRetryPolicy create(String serviceId, ServiceInstanceChooser loadBalanceChooser) {
+	public LoadBalancedRetryPolicy createRetryPolicy(String service, ServiceInstanceChooser serviceInstanceChooser) {
 		RibbonLoadBalancerContext lbContext = this.clientFactory
-				.getLoadBalancerContext(serviceId);
-		return new RibbonLoadBalancedRetryPolicy(serviceId, lbContext, loadBalanceChooser, clientFactory.getClientConfig(serviceId));
+				.getLoadBalancerContext(service);
+		return new RibbonLoadBalancedRetryPolicy(service, lbContext, serviceInstanceChooser, clientFactory.getClientConfig(service));
+	}
+
+	@Override
+	public RetryListener[] createRetryListeners(String service) {
+		return new RetryListener[0];
+	}
+
+	@Override
+	public BackOffPolicy createBackOffPolicy(String service) {
+		return null;
 	}
 }

@@ -32,9 +32,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.autoconfigure.condition.ConditionalOnProperty;
-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.commons.httpclient.ApacheHttpClientConnectionManagerFactory;
 import org.springframework.cloud.commons.httpclient.ApacheHttpClientFactory;
 import org.springframework.cloud.netflix.ribbon.RibbonClientName;
@@ -133,14 +131,11 @@ public class HttpClientRibbonConfiguration {
 	@ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class)
 	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
 	public RetryableRibbonLoadBalancingHttpClient retryableRibbonLoadBalancingHttpClient(
-		IClientConfig config, ServerIntrospector serverIntrospector,
-		ILoadBalancer loadBalancer, RetryHandler retryHandler,
-		LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory, CloseableHttpClient httpClient,
-		LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
-		LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
+			IClientConfig config, ServerIntrospector serverIntrospector,
+			ILoadBalancer loadBalancer, RetryHandler retryHandler,
+			LoadBalancedRetryFactory loadBalancedRetryFactory, CloseableHttpClient httpClient) {
 		RetryableRibbonLoadBalancingHttpClient client = new RetryableRibbonLoadBalancingHttpClient(
-			httpClient, config, serverIntrospector, loadBalancedRetryPolicyFactory,
-			loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
+			httpClient, config, serverIntrospector, loadBalancedRetryFactory);
 		client.setLoadBalancer(loadBalancer);
 		client.setRetryHandler(retryHandler);
 		Monitors.registerObject("Client_" + this.name, client);
@@ -15,7 +15,6 @@
 */
 package org.springframework.cloud.netflix.ribbon.apache;

-import java.io.IOException;
 import java.net.URI;
 import org.apache.commons.lang.BooleanUtils;
 import org.apache.http.HttpResponse;
@@ -23,15 +22,12 @@ import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.methods.HttpUriRequest;
 import org.apache.http.impl.client.CloseableHttpClient;
 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.client.loadbalancer.InterceptorRetryPolicy;
-import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
 import org.springframework.cloud.netflix.ribbon.RibbonProperties;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
 import org.springframework.cloud.netflix.ribbon.support.ContextAwareRequest;
@@ -45,11 +41,9 @@ import org.springframework.retry.policy.NeverRetryPolicy;
 import org.springframework.retry.support.RetryTemplate;
 import org.springframework.web.util.UriComponentsBuilder;

-import com.netflix.client.ClientException;
 import com.netflix.client.RequestSpecificRetryHandler;
 import com.netflix.client.RetryHandler;
 import com.netflix.client.config.IClientConfig;
-import com.netflix.loadbalancer.Server;

 /**
 * An Apache HTTP client which leverages Spring Retry to retry failed requests.
@@ -57,50 +51,13 @@ import com.netflix.loadbalancer.Server;
 * @author Gang Li
 */
 public class RetryableRibbonLoadBalancingHttpClient extends RibbonLoadBalancingHttpClient {
-	private LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory = new LoadBalancedRetryPolicyFactory.NeverRetryFactory();
-	private LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory =
-		new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory();
-	private LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory =
-		new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory();
-
-	@Deprecated
-	//TODO remove in 2.0.x
-	public RetryableRibbonLoadBalancingHttpClient(IClientConfig config,
-			ServerIntrospector serverIntrospector,
-			LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory) {
-		super(config, serverIntrospector);
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-	}
-
-	@Deprecated
-	//TODO remove in 2.0.x
-	public RetryableRibbonLoadBalancingHttpClient(CloseableHttpClient delegate,
-			IClientConfig config, ServerIntrospector serverIntrospector,
-			LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory) {
-		super(delegate, config, serverIntrospector);
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-	}
-
-	@Deprecated
-	//TODO remove in 2.0.x
-	public RetryableRibbonLoadBalancingHttpClient(CloseableHttpClient delegate,
-												  IClientConfig config, ServerIntrospector serverIntrospector,
-												  LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory,
-												  LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory) {
-		super(delegate, config, serverIntrospector);
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-		this.loadBalancedBackOffPolicyFactory = loadBalancedBackOffPolicyFactory;
-	}
+	private LoadBalancedRetryFactory loadBalancedRetryFactory;

 	public RetryableRibbonLoadBalancingHttpClient(CloseableHttpClient delegate,
 												  IClientConfig config, ServerIntrospector serverIntrospector,
-												  LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory,
-												  LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
-												  LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
+												  LoadBalancedRetryFactory loadBalancedRetryFactory) {
 		super(delegate, config, serverIntrospector);
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-		this.loadBalancedBackOffPolicyFactory = loadBalancedBackOffPolicyFactory;
-		this.loadBalancedRetryListenerFactory = loadBalancedRetryListenerFactory;
+		this.loadBalancedRetryFactory = loadBalancedRetryFactory;
 	}

 	@Override
@@ -113,14 +70,15 @@ public class RetryableRibbonLoadBalancingHttpClient extends RibbonLoadBalancingH
 		builder.setRedirectsEnabled(ribbon.isFollowRedirects(this.followRedirects));

 		final RequestConfig requestConfig = builder.build();
-		final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryPolicyFactory.create(this.getClientName(), this);
+		final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryFactory.createRetryPolicy(this.getClientName(), this);

-		RetryCallback<RibbonApacheHttpResponse, IOException> retryCallback = context -> {
+		RetryCallback<RibbonApacheHttpResponse, Exception> retryCallback = context -> {
 			//on retries the policy will choose the server and set it in the context
 			//extract the server and update the request being made
 			RibbonApacheHttpRequest newRequest = request;
 			if (context instanceof LoadBalancedRetryContext) {
 				ServiceInstance service = ((LoadBalancedRetryContext) context).getServiceInstance();
+				validateServiceInstance(service);
 				if (service != null) {
 					//Reconstruct the request URI using the host and port set in the retry context
 					newRequest = newRequest.withNewUri(UriComponentsBuilder.newInstance().host(service.getHost())
@@ -139,7 +97,7 @@ public class RetryableRibbonLoadBalancingHttpClient extends RibbonLoadBalancingH
 			}
 			return new RibbonApacheHttpResponse(httpResponse, httpUriRequest.getURI());
 		};
-		RibbonRecoveryCallback<RibbonApacheHttpResponse, HttpResponse> recoveryCallback = new RibbonRecoveryCallback<RibbonApacheHttpResponse, HttpResponse>() {
+		LoadBalancedRecoveryCallback<RibbonApacheHttpResponse, HttpResponse> recoveryCallback = new LoadBalancedRecoveryCallback<RibbonApacheHttpResponse, HttpResponse>() {
 			@Override
 			protected RibbonApacheHttpResponse createResponse(HttpResponse response, URI uri) {
 				return new RibbonApacheHttpResponse(response, uri);
@@ -165,9 +123,9 @@ public class RetryableRibbonLoadBalancingHttpClient extends RibbonLoadBalancingH
 		boolean retryable = isRequestRetryable(request);
 		retryTemplate.setRetryPolicy(retryPolicy == null || !retryable ? new NeverRetryPolicy()
 				: new RetryPolicy(request, retryPolicy, this, this.getClientName()));
-		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);
 		}
@@ -25,9 +25,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.autoconfigure.condition.ConditionalOnProperty;
-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.commons.httpclient.OkHttpClientConnectionPoolFactory;
 import org.springframework.cloud.commons.httpclient.OkHttpClientFactory;
 import org.springframework.cloud.netflix.ribbon.RibbonClientName;
@@ -101,12 +99,10 @@ public class OkHttpRibbonConfiguration {
 		ServerIntrospector serverIntrospector,
 		ILoadBalancer loadBalancer,
 		RetryHandler retryHandler,
-		LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory,
-		OkHttpClient delegate,
-		LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
-		LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
+		LoadBalancedRetryFactory loadBalancedRetryFactory,
+		OkHttpClient delegate) {
 		RetryableOkHttpLoadBalancingClient client = new RetryableOkHttpLoadBalancingClient(delegate, config,
-				serverIntrospector, loadBalancedRetryPolicyFactory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
+				serverIntrospector, loadBalancedRetryFactory);
 		client.setLoadBalancer(loadBalancer);
 		client.setRetryHandler(retryHandler);
 		Monitors.registerObject("Client_" + this.name, client);
@@ -24,12 +24,10 @@ import java.net.URI;
 import org.apache.commons.lang.BooleanUtils;
 import org.springframework.cloud.client.ServiceInstance;
 import org.springframework.cloud.client.loadbalancer.InterceptorRetryPolicy;
-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.support.ContextAwareRequest;
 import org.springframework.http.HttpRequest;
@@ -55,38 +53,12 @@ import com.netflix.client.config.IClientConfig;
 */
 public class RetryableOkHttpLoadBalancingClient extends OkHttpLoadBalancingClient {

-	private LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory;
-	private LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory =
-		new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory();
-	private LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory =
-		new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory();
-
-	@Deprecated
-	//TODO remove in 2.0.x
-	public RetryableOkHttpLoadBalancingClient(OkHttpClient delegate, IClientConfig config, ServerIntrospector serverIntrospector,
-									 LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory) {
-		super(delegate, config, serverIntrospector);
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-	}
-
-	@Deprecated
-	//TODO remove in 2.0.x
-	public RetryableOkHttpLoadBalancingClient(OkHttpClient delegate, IClientConfig config, ServerIntrospector serverIntrospector,
-											  LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory,
-											  LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory) {
-		super(delegate, config, serverIntrospector);
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-		this.loadBalancedBackOffPolicyFactory = loadBalancedBackOffPolicyFactory;
-	}
+	private LoadBalancedRetryFactory loadBalancedRetryFactory;

 	public RetryableOkHttpLoadBalancingClient(OkHttpClient delegate, IClientConfig config, ServerIntrospector serverIntrospector,
-											  LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory,
-											  LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
-											  LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
+											  LoadBalancedRetryFactory loadBalancedRetryPolicyFactory) {
 		super(delegate, config, serverIntrospector);
-		this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory;
-		this.loadBalancedBackOffPolicyFactory = loadBalancedBackOffPolicyFactory;
-		this.loadBalancedRetryListenerFactory = loadBalancedRetryListenerFactory;
+		this.loadBalancedRetryFactory = loadBalancedRetryPolicyFactory;
 	}

 	@Override
@@ -103,9 +75,9 @@ public class RetryableOkHttpLoadBalancingClient extends OkHttpLoadBalancingClien
 												  RetryCallback<OkHttpRibbonResponse, Exception> callback,
 												  RecoveryCallback<OkHttpRibbonResponse> recoveryCallback) throws Exception {
 		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);
 		}
@@ -118,7 +90,7 @@ public class RetryableOkHttpLoadBalancingClient extends OkHttpLoadBalancingClien
 	@Override
 	public OkHttpRibbonResponse execute(final OkHttpRibbonRequest ribbonRequest,
 										final IClientConfig configOverride) throws Exception {
-		final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryPolicyFactory.create(this.getClientName(), this);
+		final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryFactory.createRetryPolicy(this.getClientName(), this);
 		RetryCallback<OkHttpRibbonResponse, Exception> retryCallback  = new RetryCallback<OkHttpRibbonResponse, Exception>() {
 			@Override
 			public OkHttpRibbonResponse doWithRetry(RetryContext context) throws Exception {
@@ -152,7 +124,7 @@ public class RetryableOkHttpLoadBalancingClient extends OkHttpLoadBalancingClien
 				return new OkHttpRibbonResponse(response, newRequest.getUri());
 			}
 		};
-		return this.executeWithRetry(ribbonRequest, retryPolicy, retryCallback, new RibbonRecoveryCallback<OkHttpRibbonResponse, Response>(){
+		return this.executeWithRetry(ribbonRequest, retryPolicy, retryCallback, new LoadBalancedRecoveryCallback<OkHttpRibbonResponse, Response>(){

 			@Override
 			protected OkHttpRibbonResponse createResponse(Response response, URI uri) {
@@ -57,7 +57,7 @@ import static org.mockito.Mockito.verify;
 /**
 * @author Ryan Baxter
 */
-public class RibbonLoadBalancedRetryPolicyFactoryTests {
+public class RibbonLoadBalancedRetryFactoryTests {

 	@Mock
 	private SpringClientFactory clientFactory;
@@ -107,8 +107,8 @@ public class RibbonLoadBalancedRetryPolicyFactoryTests {
 		doReturn(config).when(clientFactory).getClientConfig(eq(server.getServiceId()));
 		clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config));
 		RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server);
-		RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
-		LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client);
+		RibbonLoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory);
+		LoadBalancedRetryPolicy policy = factory.createRetryPolicy(server.getServiceId(), client);
 		HttpRequest request = mock(HttpRequest.class);
 		doReturn(HttpMethod.GET).when(request).getMethod();
 		LoadBalancedRetryContext context = new LoadBalancedRetryContext(null, request);
@@ -135,8 +135,8 @@ public class RibbonLoadBalancedRetryPolicyFactoryTests {
 		doReturn(config).when(clientFactory).getClientConfig(eq(server.getServiceId()));
 		clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config));
 		RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server);
-		RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
-		LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client);
+		RibbonLoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory);
+		LoadBalancedRetryPolicy policy = factory.createRetryPolicy(server.getServiceId(), client);
 		HttpRequest request = mock(HttpRequest.class);
 		doReturn(HttpMethod.POST).when(request).getMethod();
 		LoadBalancedRetryContext context = new LoadBalancedRetryContext(null, request);
@@ -163,8 +163,8 @@ public class RibbonLoadBalancedRetryPolicyFactoryTests {
 		doReturn(config).when(clientFactory).getClientConfig(eq(server.getServiceId()));
 		clientFactory.getLoadBalancerContext(server.getServiceId()).initWithNiwsConfig(config);
 		RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server);
-		RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
-		LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client);
+		RibbonLoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory);
+		LoadBalancedRetryPolicy policy = factory.createRetryPolicy(server.getServiceId(), client);
 		HttpRequest request = mock(HttpRequest.class);
 		doReturn(HttpMethod.POST).when(request).getMethod();
 		LoadBalancedRetryContext context = new LoadBalancedRetryContext(null, request);
@@ -186,8 +186,8 @@ public class RibbonLoadBalancedRetryPolicyFactoryTests {
 		doReturn("").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq(""));
 		clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config));
 		RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server);
-		RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
-		LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client);
+		RibbonLoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory);
+		LoadBalancedRetryPolicy policy = factory.createRetryPolicy(server.getServiceId(), client);
 		HttpRequest request = mock(HttpRequest.class);
 		doReturn(HttpMethod.GET).when(request).getMethod();
 		LoadBalancedRetryContext context = spy(new LoadBalancedRetryContext(null, request));
@@ -232,8 +232,8 @@ public class RibbonLoadBalancedRetryPolicyFactoryTests {
 		clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config));
 		RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server);
 		
-		RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
-		LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client);
+		RibbonLoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory);
+		LoadBalancedRetryPolicy policy = factory.createRetryPolicy(server.getServiceId(), client);
 		HttpRequest request = mock(HttpRequest.class);
 		
 		LoadBalancedRetryContext context = spy(new LoadBalancedRetryContext(null, request));
@@ -260,8 +260,8 @@ public class RibbonLoadBalancedRetryPolicyFactoryTests {
 		doReturn("404, 418,502,foo, ,").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq(""));
 		clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config));
 		RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server);
-		RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
-		LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client);
+		RibbonLoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory);
+		LoadBalancedRetryPolicy policy = factory.createRetryPolicy(server.getServiceId(), client);
 		HttpRequest request = mock(HttpRequest.class);
 		doReturn(HttpMethod.GET).when(request).getMethod();
 		assertThat(policy.retryableStatusCode(400), is(false));
@@ -23,7 +23,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration;
 import org.springframework.cloud.netflix.ribbon.apache.RibbonLoadBalancingHttpClient;
 import org.springframework.cloud.test.ClassPathExclusions;
@@ -48,9 +48,8 @@ public class SpringRetryDisabledTests {
 				LoadBalancerAutoConfiguration.class,
 				RibbonClientConfiguration.class))
 			.run(context -> {
-				Map<String, LoadBalancedRetryPolicyFactory> factories = context.getBeansOfType(LoadBalancedRetryPolicyFactory.class);
-				assertThat(factories.values(), hasSize(1));
-				assertThat(factories.values().toArray()[0], instanceOf(LoadBalancedRetryPolicyFactory.NeverRetryFactory.class));
+				Map<String, LoadBalancedRetryFactory> factories = context.getBeansOfType(LoadBalancedRetryFactory.class);
+				assertThat(factories.values(), hasSize(0));
 				Map<String, RibbonLoadBalancingHttpClient> clients = context.getBeansOfType(RibbonLoadBalancingHttpClient.class);
 				assertThat(clients.values(), hasSize(1));
 				assertThat(clients.values().toArray()[0], instanceOf(RibbonLoadBalancingHttpClient.class));
@@ -22,7 +22,8 @@ import java.util.Map;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.BeansException;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy;
 import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration;
 import org.springframework.cloud.commons.httpclient.HttpClientConfiguration;
 import org.springframework.cloud.netflix.ribbon.apache.RetryableRibbonLoadBalancingHttpClient;
@@ -48,9 +49,9 @@ public class SpringRetryEnabledTests implements ApplicationContextAware {

 	@Test
 	public void testLoadBalancedRetryFactoryBean() throws Exception {
-		Map<String, LoadBalancedRetryPolicyFactory> factories =  context.getBeansOfType(LoadBalancedRetryPolicyFactory.class);
+		Map<String, LoadBalancedRetryFactory> factories =  context.getBeansOfType(LoadBalancedRetryFactory.class);
 		assertThat(factories.values(), hasSize(1));
-		assertThat(factories.values().toArray()[0], instanceOf(RibbonLoadBalancedRetryPolicyFactory.class));
+		assertThat(factories.values().toArray()[0], instanceOf(RibbonLoadBalancedRetryFactory.class));
 		Map<String, RibbonLoadBalancingHttpClient> clients =  context.getBeansOfType(RibbonLoadBalancingHttpClient.class);
 		assertThat(clients.values(), hasSize(1));
 		assertThat(clients.values().toArray()[0], instanceOf(RetryableRibbonLoadBalancingHttpClient.class));
@@ -39,13 +39,11 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.ArgumentMatcher;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
-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.commons.httpclient.HttpClientConfiguration;
 import org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration;
 import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicy;
-import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicyFactory;
+import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryFactory;
 import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerContext;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
 import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
@@ -100,8 +98,6 @@ import static org.mockito.Mockito.when;
 public class RibbonLoadBalancingHttpClientTests {

 	private ILoadBalancer loadBalancer;
-	private LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory = new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory();
-	private LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory = new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory();

 	@Before
 	public void setup() {
@@ -253,9 +249,9 @@ public class RibbonLoadBalancingHttpClientTests {
 		doReturn(locale).when(fourOFourResponse).getLocale();
 		doReturn(fourOFourResponse).when(delegate).execute(any(HttpUriRequest.class));
 		ILoadBalancer lb = mock(ILoadBalancer.class);
-		MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory();
+		MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy();
 		RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps,
-				serviceName, host, port, delegate, lb, "404", myBackOffPolicyFactory);
+				serviceName, host, port, delegate, lb, "404", myBackOffPolicy);
 		RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class);
 		doReturn(uri).when(request).getURI();
 		doReturn(method).when(request).getMethod();
@@ -275,16 +271,16 @@ public class RibbonLoadBalancingHttpClientTests {
 																	   boolean retryable, boolean retryOnAllOps,
 																	   String serviceName, String host, int port,
 																	   CloseableHttpClient delegate, ILoadBalancer lb, String statusCodes,
-																	   LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory) throws Exception {
+																	   BackOffPolicy backOffPolicy) throws Exception {
 		return setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, serviceName, host, port,
-				delegate, lb, statusCodes, loadBalancedBackOffPolicyFactory, false);
+				delegate, lb, statusCodes, backOffPolicy, false);
 	}

 	private RetryableRibbonLoadBalancingHttpClient setupClientForRetry(int retriesNextServer, int retriesSameServer,
 																	   boolean retryable, boolean retryOnAllOps,
 																	   String serviceName, String host, int port,
 																	   CloseableHttpClient delegate, ILoadBalancer lb, String statusCodes,
-																	   LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
+																	   BackOffPolicy backOffPolicy,
 																	   boolean isSecure) throws Exception {
 		ServerIntrospector introspector = mock(ServerIntrospector.class);
 		RetryHandler retryHandler = new DefaultLoadBalancerRetryHandler(retriesSameServer, retriesNextServer, retryable);
@@ -300,9 +296,14 @@ public class RibbonLoadBalancingHttpClientTests {
 		SpringClientFactory clientFactory = mock(SpringClientFactory.class);
 		doReturn(context).when(clientFactory).getLoadBalancerContext(eq(serviceName));
 		doReturn(clientConfig).when(clientFactory).getClientConfig(eq(serviceName));
-		LoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		LoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory) {
+			@Override
+			public BackOffPolicy createBackOffPolicy(String service) {
+				return backOffPolicy;
+			}
+		};
 		RetryableRibbonLoadBalancingHttpClient client = new RetryableRibbonLoadBalancingHttpClient(delegate, clientConfig,
-				introspector, factory, loadBalancedBackOffPolicyFactory, new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory());
+				introspector, factory);
 		client.setLoadBalancer(lb);
 		ReflectionTestUtils.setField(client, "delegate", delegate);
 		return client;
@@ -312,8 +313,8 @@ public class RibbonLoadBalancingHttpClientTests {
 																	   boolean retryable, boolean retryOnAllOps,
 																	   String serviceName, String host, int port,
 																	   CloseableHttpClient delegate, ILoadBalancer lb, String statusCodes,
-																	   LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
-																	   boolean isSecure, LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) throws Exception {
+																	   BackOffPolicy backOffPolicy,
+																	   boolean isSecure, RetryListener[] retryListeners) throws Exception {
 		ServerIntrospector introspector = mock(ServerIntrospector.class);
 		RetryHandler retryHandler = new DefaultLoadBalancerRetryHandler(retriesSameServer, retriesNextServer, retryable);
 		doReturn(new Server(host, port)).when(lb).chooseServer(eq(serviceName));
@@ -328,9 +329,19 @@ public class RibbonLoadBalancingHttpClientTests {
 		SpringClientFactory clientFactory = mock(SpringClientFactory.class);
 		doReturn(context).when(clientFactory).getLoadBalancerContext(eq(serviceName));
 		doReturn(clientConfig).when(clientFactory).getClientConfig(eq(serviceName));
-		LoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		LoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory) {
+			@Override
+			public RetryListener[] createRetryListeners(String service) {
+				return retryListeners;
+			}
+
+			@Override
+			public BackOffPolicy createBackOffPolicy(String service) {
+				return backOffPolicy;
+			}
+		};
 		RetryableRibbonLoadBalancingHttpClient client = new RetryableRibbonLoadBalancingHttpClient(delegate, clientConfig,
-			introspector, factory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
+			introspector, factory);
 		client.setLoadBalancer(lb);
 		ReflectionTestUtils.setField(client, "delegate", delegate);
 		return client;
@@ -355,7 +366,7 @@ public class RibbonLoadBalancingHttpClientTests {
 		doThrow(new IOException("boom")).doReturn(response).when(delegate).execute(any(HttpUriRequest.class));
 		ILoadBalancer lb = mock(ILoadBalancer.class);
 		RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps,
-				serviceName, host, port, delegate, lb, "", loadBalancedBackOffPolicyFactory);
+				serviceName, host, port, delegate, lb, "", null);
 		RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class);
 		doReturn(uri).when(request).getURI();
 		doReturn(method).when(request).getMethod();
@@ -387,9 +398,9 @@ public class RibbonLoadBalancingHttpClientTests {
 		doThrow(new IOException("boom")).doThrow(new IOException("boom again")).doReturn(response).
 				when(delegate).execute(any(HttpUriRequest.class));
 		ILoadBalancer lb = mock(ILoadBalancer.class);
-		MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory();
+		MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy();
 		RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps,
-				serviceName, host, port, delegate, lb, "", myBackOffPolicyFactory);
+				serviceName, host, port, delegate, lb, "", myBackOffPolicy);
 		RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class);
 		doReturn(uri).when(request).getURI();
 		doReturn(method).when(request).getMethod();
@@ -400,7 +411,7 @@ public class RibbonLoadBalancingHttpClientTests {
 		client.execute(request, null);
 		verify(delegate, times(3)).execute(any(HttpUriRequest.class));
 		verify(lb, times(2)).chooseServer(eq(serviceName));
-		assertEquals(2, myBackOffPolicyFactory.getCount());
+		assertEquals(2, myBackOffPolicy.getCount());
 	}

 	@Test
@@ -422,9 +433,9 @@ public class RibbonLoadBalancingHttpClientTests {
 		doThrow(new IOException("boom")).doThrow(new IOException("boom again")).doReturn(response).
 				when(delegate).execute(any(HttpUriRequest.class));
 		ILoadBalancer lb = mock(ILoadBalancer.class);
-		MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory();
+		MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy();
 		RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps,
-				serviceName, host, port, delegate, lb, "", myBackOffPolicyFactory);
+				serviceName, host, port, delegate, lb, "", myBackOffPolicy);
 		RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class);
 		doReturn(method).when(request).getMethod();
 		doReturn(uri).when(request).getURI();
@@ -435,7 +446,7 @@ public class RibbonLoadBalancingHttpClientTests {
 		verify(response, times(0)).close();
 		verify(delegate, times(3)).execute(any(HttpUriRequest.class));
 		verify(lb, times(2)).chooseServer(eq(serviceName));
-		assertEquals(2, myBackOffPolicyFactory.getCount());
+		assertEquals(2, myBackOffPolicy.getCount());
 	}

 	@Test
@@ -500,7 +511,7 @@ public class RibbonLoadBalancingHttpClientTests {
 				when(delegate).execute(any(HttpUriRequest.class));
 		ILoadBalancer lb = mock(ILoadBalancer.class);
 		RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps,
-				serviceName, host, port, delegate, lb, "", loadBalancedBackOffPolicyFactory,true);
+				serviceName, host, port, delegate, lb, "", null,true);
 		client.execute(request, null);
 		verify(response, times(0)).close();
 		verify(delegate, times(1)).execute(argThat(new ArgumentMatcher<HttpUriRequest>() {
@@ -532,7 +543,7 @@ public class RibbonLoadBalancingHttpClientTests {
 				when(delegate).execute(any(HttpUriRequest.class));
 		ILoadBalancer lb = mock(ILoadBalancer.class);
 		RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps,
-				serviceName, host, port, delegate, lb, "", loadBalancedBackOffPolicyFactory);
+				serviceName, host, port, delegate, lb, "", null);
 		RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class);
 		doReturn(method).when(request).getMethod();
 		doReturn(uri).when(request).getURI();
@@ -579,9 +590,9 @@ public class RibbonLoadBalancingHttpClientTests {
 		doReturn(fourOFourStatusLine).when(fourOFourResponse).getStatusLine();
 		doReturn(fourOFourResponse).doReturn(response).when(delegate).execute(any(HttpUriRequest.class));
 		ILoadBalancer lb = mock(ILoadBalancer.class);
-		MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory();
+		MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy();
 		RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps,
-				serviceName, host, port, delegate, lb, "404", myBackOffPolicyFactory);
+				serviceName, host, port, delegate, lb, "404", myBackOffPolicy);
 		RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class);
 		doReturn(uri).when(request).getURI();
 		doReturn(method).when(request).getMethod();
@@ -593,7 +604,7 @@ public class RibbonLoadBalancingHttpClientTests {
 		verify(fourOFourResponse, times(1)).close();
 		verify(delegate, times(2)).execute(any(HttpUriRequest.class));
 		verify(lb, times(1)).chooseServer(eq(serviceName));
-		assertEquals(1, myBackOffPolicyFactory.getCount());
+		assertEquals(1, myBackOffPolicy.getCount());
 	}

 	@Test
@@ -615,10 +626,10 @@ public class RibbonLoadBalancingHttpClientTests {
 		doThrow(new IOException("boom")).doThrow(new IOException("boom again")).doReturn(response).
 			when(delegate).execute(any(HttpUriRequest.class));
 		ILoadBalancer lb = mock(ILoadBalancer.class);
-		MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory();
-		MyRetryListeners myRetryListeners = new MyRetryListeners();
+		MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy();
+		MyRetryListener myRetryListener = new MyRetryListener();
 		RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps,
-			serviceName, host, port, delegate, lb, "", myBackOffPolicyFactory, false, myRetryListeners);
+			serviceName, host, port, delegate, lb, "", myBackOffPolicy, false, new RetryListener[]{myRetryListener});
 		RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class);
 		doReturn(method).when(request).getMethod();
 		doReturn(uri).when(request).getURI();
@@ -629,8 +640,8 @@ public class RibbonLoadBalancingHttpClientTests {
 		verify(response, times(0)).close();
 		verify(delegate, times(3)).execute(any(HttpUriRequest.class));
 		verify(lb, times(2)).chooseServer(eq(serviceName));
-		assertEquals(2, myBackOffPolicyFactory.getCount());
-		assertEquals(2, myRetryListeners.getOnError());
+		assertEquals(2, myBackOffPolicy.getCount());
+		assertEquals(2, myRetryListener.getOnError());
 	}

 	@Test
@@ -652,10 +663,10 @@ public class RibbonLoadBalancingHttpClientTests {
 		doThrow(new IOException("boom")).doThrow(new IOException("boom again")).doReturn(response).
 			when(delegate).execute(any(HttpUriRequest.class));
 		ILoadBalancer lb = mock(ILoadBalancer.class);
-		MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory();
-		MyRetryListeners myRetryListeners = new MyRetryListeners();
+		MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy();
+		MyRetryListener myRetryListener = new MyRetryListener();
 		RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps,
-			serviceName, host, port, delegate, lb, "", myBackOffPolicyFactory, false, loadBalancedRetryListenerFactory);
+			serviceName, host, port, delegate, lb, "", myBackOffPolicy, false, new RetryListener[]{});
 		RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class);
 		doReturn(method).when(request).getMethod();
 		doReturn(uri).when(request).getURI();
@@ -666,8 +677,8 @@ public class RibbonLoadBalancingHttpClientTests {
 		verify(response, times(0)).close();
 		verify(delegate, times(3)).execute(any(HttpUriRequest.class));
 		verify(lb, times(2)).chooseServer(eq(serviceName));
-		assertEquals(2, myBackOffPolicyFactory.getCount());
-		assertEquals(0, myRetryListeners.getOnError());
+		assertEquals(2, myBackOffPolicy.getCount());
+		assertEquals(0, myRetryListener.getOnError());
 	}

 	@Test(expected = TerminatedRetryException.class)
@@ -689,10 +700,10 @@ public class RibbonLoadBalancingHttpClientTests {
 		doThrow(new IOException("boom")).doThrow(new IOException("boom again")).doReturn(response).
 			when(delegate).execute(any(HttpUriRequest.class));
 		ILoadBalancer lb = mock(ILoadBalancer.class);
-		MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory();
-		MyRetryListenersNotRetry myRetryListenersNotRetry = new MyRetryListenersNotRetry();
+		MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy();
+		MyRetryListenerNotRetry myRetryListenerNotRetry = new MyRetryListenerNotRetry();
 		RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps,
-			serviceName, host, port, delegate, lb, "", myBackOffPolicyFactory, false, myRetryListenersNotRetry);
+			serviceName, host, port, delegate, lb, "", myBackOffPolicy, false, new RetryListener[]{myRetryListenerNotRetry});
 		RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class);
 		doReturn(method).when(request).getMethod();
 		doReturn(uri).when(request).getURI();
@@ -722,9 +733,9 @@ public class RibbonLoadBalancingHttpClientTests {
 		doThrow(new IOException("boom")).doThrow(new IOException("boom again")).doReturn(response).
 			when(delegate).execute(any(HttpUriRequest.class));
 		ILoadBalancer lb = mock(ILoadBalancer.class);
-		MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory();
+		MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy();
 		RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps,
-			serviceName, host, port, delegate, lb, "", myBackOffPolicyFactory, false);
+			serviceName, host, port, delegate, lb, "", myBackOffPolicy, false);
 		RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class);
 		doReturn(method).when(request).getMethod();
 		doReturn(uri).when(request).getURI();
@@ -735,7 +746,7 @@ public class RibbonLoadBalancingHttpClientTests {
 		verify(response, times(0)).close();
 		verify(delegate, times(3)).execute(any(HttpUriRequest.class));
 		verify(lb, times(2)).chooseServer(eq(serviceName));
-		assertEquals(2, myBackOffPolicyFactory.getCount());
+		assertEquals(2, myBackOffPolicy.getCount());
 	}
 	
 	private RetryableRibbonLoadBalancingHttpClient setupClientForServerValidation(String serviceName, String host, int port,
@@ -753,9 +764,9 @@ public class RibbonLoadBalancingHttpClientTests {
 		SpringClientFactory clientFactory = mock(SpringClientFactory.class);
 		doReturn(context).when(clientFactory).getLoadBalancerContext(eq(serviceName));
 		doReturn(clientConfig).when(clientFactory).getClientConfig(eq(serviceName));
-		LoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		LoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory);
 		RetryableRibbonLoadBalancingHttpClient client = new RetryableRibbonLoadBalancingHttpClient(delegate,
-				clientConfig, introspector, factory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
+				clientConfig, introspector, factory);
 		client.setLoadBalancer(lb);
 		ReflectionTestUtils.setField(client, "delegate", delegate);
 		return client;
@@ -902,7 +913,7 @@ public class RibbonLoadBalancingHttpClientTests {
 		return requestConfigCaptor.getValue();
 	}

-	class MyBackOffPolicyFactory implements LoadBalancedBackOffPolicyFactory, BackOffPolicy {
+	class MyBackOffPolicy implements BackOffPolicy {

 		private int count = 0;

@@ -919,62 +930,47 @@ public class RibbonLoadBalancingHttpClientTests {
 		int getCount() {
 			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;
-				}
-
-				@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++;
-				}
-			}};
-		}
-
 		int getOnError() {
 			return onError;
 		}
-	}
-
-	class MyRetryListenersNotRetry implements LoadBalancedRetryListenerFactory {

 		@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;
-				}
+		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) {
+		@Override
+		public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
+			onError++;
+		}
+	}
+
+	class MyRetryListenerNotRetry implements 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) {

-				}
-			}};
 		}
 	}

@@ -22,7 +22,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration;
 import org.springframework.cloud.commons.httpclient.HttpClientConfiguration;
 import org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration;
@@ -52,9 +52,8 @@ public class SpringRetryDisableOkHttpClientTests {
 			.withUserConfiguration(
 				OkHttpLoadBalancingClientTests.OkHttpClientConfiguration.class)
 			.run(context -> {
-				Map<String, LoadBalancedRetryPolicyFactory> factories = context.getBeansOfType(LoadBalancedRetryPolicyFactory.class);
-				assertThat(factories.values(), hasSize(1));
-				assertThat(factories.values().toArray()[0], instanceOf(LoadBalancedRetryPolicyFactory.NeverRetryFactory.class));
+				Map<String, LoadBalancedRetryFactory> factories = context.getBeansOfType(LoadBalancedRetryFactory.class);
+				assertThat(factories.values(), hasSize(0));
 				Map<String, OkHttpLoadBalancingClient> clients = context.getBeansOfType(OkHttpLoadBalancingClient.class);
 				assertThat(clients.values(), hasSize(1));
 				assertThat(clients.values().toArray()[0], instanceOf(OkHttpLoadBalancingClient.class));
@@ -15,32 +15,22 @@
 */
 package org.springframework.cloud.netflix.ribbon.okhttp;

-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;

 import java.net.URI;
 import java.util.Map;
-
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.BeansException;
 import org.springframework.boot.test.context.SpringBootTest;
-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.client.loadbalancer.LoadBalancerAutoConfiguration;
 import org.springframework.cloud.commons.httpclient.HttpClientConfiguration;
 import org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration;
 import org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration;
+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;
@@ -50,7 +40,6 @@ import org.springframework.http.HttpMethod;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.test.util.ReflectionTestUtils;
-
 import com.netflix.client.ClientException;
 import com.netflix.client.DefaultLoadBalancerRetryHandler;
 import com.netflix.client.RetryHandler;
@@ -59,8 +48,15 @@ import com.netflix.client.config.DefaultClientConfigImpl;
 import com.netflix.loadbalancer.ILoadBalancer;
 import com.netflix.loadbalancer.Server;

-import okhttp3.OkHttpClient;
-import okhttp3.Request;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;

 /**
 * @author Ryan Baxter
@@ -74,16 +70,14 @@ public class SpringRetryEnabledOkHttpClientTests implements ApplicationContextAw

 	private ApplicationContext context;
 	private ILoadBalancer loadBalancer;
-	private LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory = new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory();
-	private LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory = new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory();
 	
 	@Test
 	public void testLoadBalancedRetryFactoryBean() throws Exception {
-		Map<String, LoadBalancedRetryPolicyFactory> factories = context
-				.getBeansOfType(LoadBalancedRetryPolicyFactory.class);
+		Map<String, LoadBalancedRetryFactory> factories = context
+				.getBeansOfType(LoadBalancedRetryFactory.class);
 		assertThat(factories.values(), hasSize(1));
 		assertThat(factories.values().toArray()[0],
-				instanceOf(RibbonLoadBalancedRetryPolicyFactory.class));
+				instanceOf(RibbonLoadBalancedRetryFactory.class));
 		Map<String, OkHttpLoadBalancingClient> clients = context
 				.getBeansOfType(OkHttpLoadBalancingClient.class);
 		assertThat(clients.values(), hasSize(1));
@@ -111,9 +105,9 @@ public class SpringRetryEnabledOkHttpClientTests implements ApplicationContextAw
 		SpringClientFactory clientFactory = mock(SpringClientFactory.class);
 		doReturn(context).when(clientFactory).getLoadBalancerContext(eq(serviceName));
 		doReturn(clientConfig).when(clientFactory).getClientConfig(eq(serviceName));
-		LoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
+		LoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory);
 		RetryableOkHttpLoadBalancingClient client = new RetryableOkHttpLoadBalancingClient(delegate, clientConfig, introspector,
-				factory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
+				factory);
 		client.setLoadBalancer(lb);
 		ReflectionTestUtils.setField(client, "delegate", delegate);
 		return client;
@@ -30,13 +30,13 @@ import org.junit.Test;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.test.web.client.TestRestTemplate;
+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.RibbonClient;
 import org.springframework.cloud.netflix.ribbon.RibbonClients;
 import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicy;
-import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicyFactory;
+import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryFactory;
 import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerContext;
 import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
 import org.springframework.cloud.netflix.ribbon.StaticServerList;
@@ -210,23 +210,23 @@ public abstract class RibbonRetryIntegrationTestBase {
 			extends RibbonClientConfiguration {

 		@Bean
-		public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory(
+		public LoadBalancedRetryFactory loadBalancedRetryPolicyFactory(
 				SpringClientFactory factory) {
-			return new MyRibbonRetryPolicyFactory(factory);
+			return new MyRibbonRetryFactory(factory);
 		}

-		public static class MyRibbonRetryPolicyFactory
-				extends RibbonLoadBalancedRetryPolicyFactory {
+		public static class MyRibbonRetryFactory
+				extends RibbonLoadBalancedRetryFactory {

 			private SpringClientFactory factory;

-			public MyRibbonRetryPolicyFactory(SpringClientFactory clientFactory) {
+			public MyRibbonRetryFactory(SpringClientFactory clientFactory) {
 				super(clientFactory);
 				this.factory = clientFactory;
 			}

 			@Override
-			public LoadBalancedRetryPolicy create(String serviceId,
+			public LoadBalancedRetryPolicy createRetryPolicy(String serviceId,
 					ServiceInstanceChooser loadBalanceChooser) {
 				RibbonLoadBalancerContext lbContext = this.factory
 						.getLoadBalancerContext(serviceId);