From 529739d3b67691021b7672f78db292ff74809a3e Mon Sep 17 00:00:00 2001 From: Ryan Baxter Date: Mon, 12 Mar 2018 13:50:51 -0400 Subject: [PATCH] Refactor spring retry (#331) * Initial refactoring effort * Remove bean that is not needed * Using default methods in LoadBalancedRetryFactory * Clarifying LoadBalancedRecveryCallback implementation * Moved retry template creation to its own method. --- .../LoadBalancedBackOffPolicyFactory.java | 21 -- ...java => LoadBalancedRecoveryCallback.java} | 2 +- .../LoadBalancedRetryFactory.java | 55 +++++ .../LoadBalancedRetryListenerFactory.java | 37 ---- .../LoadBalancedRetryPolicyFactory.java | 39 ---- .../LoadBalancerAutoConfiguration.java | 30 +-- .../RetryLoadBalancerInterceptor.java | 121 ++++------- .../RetryableStatusCodeException.java | 6 - ...actLoadBalancerAutoConfigurationTests.java | 7 - ...yncLoadBalancerAutoConfigurationTests.java | 2 +- ...tryLoadBalancerAutoConfigurationTests.java | 6 +- .../RetryLoadBalancerInterceptorTest.java | 190 ++++++++---------- ...iveLoadBalancerAutoConfigurationTests.java | 4 +- 13 files changed, 193 insertions(+), 327 deletions(-) delete mode 100644 spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedBackOffPolicyFactory.java rename spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/{RibbonRecoveryCallback.java => LoadBalancedRecoveryCallback.java} (95%) create mode 100644 spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryFactory.java delete mode 100644 spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryListenerFactory.java delete mode 100644 spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryPolicyFactory.java diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedBackOffPolicyFactory.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedBackOffPolicyFactory.java deleted file mode 100644 index 9e83cfab..00000000 --- a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedBackOffPolicyFactory.java +++ /dev/null @@ -1,21 +0,0 @@ -package org.springframework.cloud.client.loadbalancer; - -import org.springframework.retry.backoff.BackOffPolicy; -import org.springframework.retry.backoff.NoBackOffPolicy; - -/** - * Factory class to return the backoff policy. - * @author Ryan Baxter - */ -public interface LoadBalancedBackOffPolicyFactory { - - public BackOffPolicy createBackOffPolicy(String service); - - static class NoBackOffPolicyFactory implements LoadBalancedBackOffPolicyFactory { - - @Override - public BackOffPolicy createBackOffPolicy(String service) { - return new NoBackOffPolicy(); - } - } -} diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/RibbonRecoveryCallback.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRecoveryCallback.java similarity index 95% rename from spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/RibbonRecoveryCallback.java rename to spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRecoveryCallback.java index 0382bdc9..a42a7dde 100644 --- a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/RibbonRecoveryCallback.java +++ b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRecoveryCallback.java @@ -27,7 +27,7 @@ import java.net.URI; * the request * @author LiYuan Lee */ -public abstract class RibbonRecoveryCallback implements RecoveryCallback { +public abstract class LoadBalancedRecoveryCallback implements RecoveryCallback { /** * Create the response returned in the {@link RecoveryCallback} diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryFactory.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryFactory.java new file mode 100644 index 00000000..a5da2b3c --- /dev/null +++ b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryFactory.java @@ -0,0 +1,55 @@ +/* + * Copyright 2013-2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.cloud.client.loadbalancer; + +import org.springframework.retry.RetryListener; +import org.springframework.retry.backoff.BackOffPolicy; +import org.springframework.retry.backoff.NoBackOffPolicy; + +/** + * Factory class used to customize the retry functionality throughout Spring Cloud + * @author Ryan Baxter + */ +public interface LoadBalancedRetryFactory { + + /** + * Creates a {@link LoadBalancedRetryPolicy}. + * @param service The ID of the service to create the retry policy for. + * @param serviceInstanceChooser Used to get the next server from a load balancer + * @return A retry policy for the service. + */ + default LoadBalancedRetryPolicy createRetryPolicy(String service, ServiceInstanceChooser serviceInstanceChooser) { + return null; + } + + /** + * Creates an array of {@link RetryListener}s for a given service + * @param service The service to create the {@link RetryListener}s for + * @return An array of {@link RetryListener}s + */ + default RetryListener[] createRetryListeners(String service) { + return new RetryListener[0]; + } + + /** + * Creates a {@link BackOffPolicy} for a given service + * @param service The service to create the {@link BackOffPolicy} for + * @return The {@link BackOffPolicy} + */ + default BackOffPolicy createBackOffPolicy(String service) { + return new NoBackOffPolicy(); + } +} diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryListenerFactory.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryListenerFactory.java deleted file mode 100644 index f16a99c7..00000000 --- a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryListenerFactory.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright 2013-2015 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.springframework.cloud.client.loadbalancer; - -import org.springframework.retry.RetryListener; - -/** - * Factory class to return the retry listeners. - * @author Gang Li - */ -public interface LoadBalancedRetryListenerFactory { - - RetryListener[] createRetryListeners(String service); - - class DefaultRetryListenerFactory implements LoadBalancedRetryListenerFactory { - - @Override - public RetryListener[] createRetryListeners(String service) { - return new RetryListener[0]; - } - } - -} diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryPolicyFactory.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryPolicyFactory.java deleted file mode 100644 index f823792b..00000000 --- a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryPolicyFactory.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright 2013-2016 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.springframework.cloud.client.loadbalancer; - -/** - * Responsible for creating the {@link LoadBalancedRetryPolicy}. - * @author Ryan Baxter - */ -public interface LoadBalancedRetryPolicyFactory { - - /** - * Creates a {@link LoadBalancedRetryPolicy}. - * @param serviceId The ID of the service to create the retry policy for. - * @param serviceInstanceChooser Used to get the next server from a load balancer - * @return A retry policy for the service. - */ - public LoadBalancedRetryPolicy create(String serviceId, ServiceInstanceChooser serviceInstanceChooser); - - static class NeverRetryFactory implements LoadBalancedRetryPolicyFactory { - - @Override - public LoadBalancedRetryPolicy create(String serviceId, ServiceInstanceChooser serviceInstanceChooser) { - return null; - } - } -} diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancerAutoConfiguration.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancerAutoConfiguration.java index e7f82947..7bbd0c53 100644 --- a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancerAutoConfiguration.java +++ b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancerAutoConfiguration.java @@ -27,6 +27,7 @@ import org.springframework.boot.context.properties.EnableConfigurationProperties import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.http.client.ClientHttpRequestInterceptor; +import org.springframework.retry.backoff.BackOffPolicy; import org.springframework.retry.support.RetryTemplate; import org.springframework.web.client.RestTemplate; @@ -100,30 +101,11 @@ public class LoadBalancerAutoConfiguration { @Configuration @ConditionalOnClass(RetryTemplate.class) public static class RetryAutoConfiguration { - @Bean - @ConditionalOnMissingBean - public RetryTemplate retryTemplate() { - RetryTemplate template = new RetryTemplate(); - template.setThrowLastExceptionOnExhausted(true); - return template; - } @Bean @ConditionalOnMissingBean - public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory() { - return new LoadBalancedRetryPolicyFactory.NeverRetryFactory(); - } - - @Bean - @ConditionalOnMissingBean - public LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory() { - return new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory(); - } - - @Bean - @ConditionalOnMissingBean - public LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory() { - return new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory(); + public LoadBalancedRetryFactory loadBalancedRetryFactory() { + return new LoadBalancedRetryFactory() {}; } } @@ -134,12 +116,10 @@ public class LoadBalancerAutoConfiguration { @ConditionalOnMissingBean public RetryLoadBalancerInterceptor ribbonInterceptor( LoadBalancerClient loadBalancerClient, LoadBalancerRetryProperties properties, - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory, LoadBalancerRequestFactory requestFactory, - LoadBalancedBackOffPolicyFactory backOffPolicyFactory, - LoadBalancedRetryListenerFactory retryListenerFactory) { + LoadBalancedRetryFactory loadBalancedRetryFactory) { return new RetryLoadBalancerInterceptor(loadBalancerClient, properties, - lbRetryPolicyFactory, requestFactory, backOffPolicyFactory, retryListenerFactory); + requestFactory, loadBalancedRetryFactory); } @Bean diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerInterceptor.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerInterceptor.java index 409e94a6..30b96bd1 100644 --- a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerInterceptor.java +++ b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerInterceptor.java @@ -24,8 +24,6 @@ import org.springframework.http.HttpRequest; import org.springframework.http.client.ClientHttpRequestExecution; import org.springframework.http.client.ClientHttpRequestInterceptor; import org.springframework.http.client.ClientHttpResponse; -import org.springframework.retry.RetryCallback; -import org.springframework.retry.RetryContext; import org.springframework.retry.RetryListener; import org.springframework.retry.backoff.BackOffPolicy; import org.springframework.retry.backoff.NoBackOffPolicy; @@ -41,56 +39,19 @@ import org.springframework.util.StreamUtils; */ public class RetryLoadBalancerInterceptor implements ClientHttpRequestInterceptor { - private LoadBalancedRetryPolicyFactory lbRetryPolicyFactory; - private RetryTemplate retryTemplate; private LoadBalancerClient loadBalancer; private LoadBalancerRetryProperties lbProperties; private LoadBalancerRequestFactory requestFactory; - private LoadBalancedBackOffPolicyFactory backOffPolicyFactory; - private LoadBalancedRetryListenerFactory retryListenerFactory; - - - @Deprecated - //TODO remove in 2.0.x - public RetryLoadBalancerInterceptor(LoadBalancerClient loadBalancer, - LoadBalancerRetryProperties lbProperties, - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory, - LoadBalancerRequestFactory requestFactory) { - this.loadBalancer = loadBalancer; - this.lbRetryPolicyFactory = lbRetryPolicyFactory; - this.lbProperties = lbProperties; - this.requestFactory = requestFactory; - this.backOffPolicyFactory = new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory(); - this.retryListenerFactory = new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory(); - } - - @Deprecated - //TODO remove in 2.0.x - public RetryLoadBalancerInterceptor(LoadBalancerClient loadBalancer, - LoadBalancerRetryProperties lbProperties, - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory, - LoadBalancerRequestFactory requestFactory, - LoadBalancedBackOffPolicyFactory backOffPolicyFactory) { - this.loadBalancer = loadBalancer; - this.lbRetryPolicyFactory = lbRetryPolicyFactory; - this.lbProperties = lbProperties; - this.requestFactory = requestFactory; - this.backOffPolicyFactory = backOffPolicyFactory; - this.retryListenerFactory = new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory();; - } + private LoadBalancedRetryFactory lbRetryFactory; public RetryLoadBalancerInterceptor(LoadBalancerClient loadBalancer, LoadBalancerRetryProperties lbProperties, - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory, LoadBalancerRequestFactory requestFactory, - LoadBalancedBackOffPolicyFactory backOffPolicyFactory, - LoadBalancedRetryListenerFactory retryListenerFactory) { + LoadBalancedRetryFactory lbRetryFactory) { this.loadBalancer = loadBalancer; - this.lbRetryPolicyFactory = lbRetryPolicyFactory; this.lbProperties = lbProperties; this.requestFactory = requestFactory; - this.backOffPolicyFactory = backOffPolicyFactory; - this.retryListenerFactory = retryListenerFactory; + this.lbRetryFactory = lbRetryFactory; } @@ -100,49 +61,51 @@ public class RetryLoadBalancerInterceptor implements ClientHttpRequestIntercepto final URI originalUri = request.getURI(); final String serviceName = originalUri.getHost(); Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri); - final LoadBalancedRetryPolicy retryPolicy = lbRetryPolicyFactory.create(serviceName, + final LoadBalancedRetryPolicy retryPolicy = lbRetryFactory.createRetryPolicy(serviceName, loadBalancer); - RetryTemplate template = this.retryTemplate == null ? new RetryTemplate() : this.retryTemplate; - BackOffPolicy backOffPolicy = backOffPolicyFactory.createBackOffPolicy(serviceName); + RetryTemplate template = createRetryTemplate(serviceName, request, retryPolicy); + return template.execute(context -> { + ServiceInstance serviceInstance = null; + if (context instanceof LoadBalancedRetryContext) { + LoadBalancedRetryContext lbContext = (LoadBalancedRetryContext) context; + serviceInstance = lbContext.getServiceInstance(); + } + if (serviceInstance == null) { + serviceInstance = loadBalancer.choose(serviceName); + } + ClientHttpResponse response = RetryLoadBalancerInterceptor.this.loadBalancer.execute( + serviceName, serviceInstance, + requestFactory.createRequest(request, body, execution)); + int statusCode = response.getRawStatusCode(); + if (retryPolicy != null && retryPolicy.retryableStatusCode(statusCode)) { + byte[] bodyCopy = StreamUtils.copyToByteArray(response.getBody()); + response.close(); + throw new ClientHttpResponseStatusCodeException(serviceName, response, bodyCopy); + } + return response; + }, new LoadBalancedRecoveryCallback() { + //This is a special case, where both parameters to LoadBalancedRecoveryCallback are + //the same. In most cases they would be different. + @Override + protected ClientHttpResponse createResponse(ClientHttpResponse response, URI uri) { + return response; + } + }); + } + + private RetryTemplate createRetryTemplate(String serviceName, HttpRequest request, LoadBalancedRetryPolicy retryPolicy) { + RetryTemplate template = new RetryTemplate(); + BackOffPolicy backOffPolicy = lbRetryFactory.createBackOffPolicy(serviceName); template.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy); template.setThrowLastExceptionOnExhausted(true); - RetryListener[] retryListeners = this.retryListenerFactory.createRetryListeners(serviceName); - if (retryListeners != null && retryListeners.length != 0) { - template.setListeners(retryListeners); - } + RetryListener[] retryListeners = lbRetryFactory.createRetryListeners(serviceName); + if (retryListeners != null && retryListeners.length != 0) { + template.setListeners(retryListeners); + } template.setRetryPolicy( !lbProperties.isEnabled() || retryPolicy == null ? new NeverRetryPolicy() : new InterceptorRetryPolicy(request, retryPolicy, loadBalancer, serviceName)); - return template - .execute(new RetryCallback() { - @Override - public ClientHttpResponse doWithRetry(RetryContext context) - throws IOException { - ServiceInstance serviceInstance = null; - if (context instanceof LoadBalancedRetryContext) { - LoadBalancedRetryContext lbContext = (LoadBalancedRetryContext) context; - serviceInstance = lbContext.getServiceInstance(); - } - if (serviceInstance == null) { - serviceInstance = loadBalancer.choose(serviceName); - } - ClientHttpResponse response = RetryLoadBalancerInterceptor.this.loadBalancer.execute( - serviceName, serviceInstance, - requestFactory.createRequest(request, body, execution)); - int statusCode = response.getRawStatusCode(); - if (retryPolicy != null && retryPolicy.retryableStatusCode(statusCode)) { - byte[] body = StreamUtils.copyToByteArray(response.getBody()); - response.close(); - throw new ClientHttpResponseStatusCodeException(serviceName, response, body); - } - return response; - } - }, new RibbonRecoveryCallback() { - @Override - protected ClientHttpResponse createResponse(ClientHttpResponse response, URI uri) { - return response; - } - }); + return template; } } diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/RetryableStatusCodeException.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/RetryableStatusCodeException.java index 876df791..a2798c65 100644 --- a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/RetryableStatusCodeException.java +++ b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/RetryableStatusCodeException.java @@ -30,12 +30,6 @@ public class RetryableStatusCodeException extends IOException { private URI uri; - @Deprecated - //TODO Remove in 2.0.x - public RetryableStatusCodeException(String serviceId, int statusCode) { - super(String.format(MESSAGE, serviceId, statusCode)); - } - public RetryableStatusCodeException(String serviceId, int statusCode, Object response, URI uri) { super(String.format(MESSAGE, serviceId, statusCode)); this.response = response; diff --git a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/AbstractLoadBalancerAutoConfigurationTests.java b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/AbstractLoadBalancerAutoConfigurationTests.java index 9e8184a9..dad62f0b 100644 --- a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/AbstractLoadBalancerAutoConfigurationTests.java +++ b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/AbstractLoadBalancerAutoConfigurationTests.java @@ -99,10 +99,6 @@ public abstract class AbstractLoadBalancerAutoConfigurationTests { LoadBalancerClient loadBalancerClient() { return new NoopLoadBalancerClient(); } - - @Bean - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory() { return new LoadBalancedRetryPolicyFactory.NeverRetryFactory();} - } @Configuration @@ -125,9 +121,6 @@ public abstract class AbstractLoadBalancerAutoConfigurationTests { return new NoopLoadBalancerClient(); } - @Bean - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory() { return new LoadBalancedRetryPolicyFactory.NeverRetryFactory();} - @Configuration protected static class Two { @Autowired diff --git a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/AsyncLoadBalancerAutoConfigurationTests.java b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/AsyncLoadBalancerAutoConfigurationTests.java index e270f5ee..84d0903e 100644 --- a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/AsyncLoadBalancerAutoConfigurationTests.java +++ b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/AsyncLoadBalancerAutoConfigurationTests.java @@ -109,7 +109,7 @@ public class AsyncLoadBalancerAutoConfigurationTests { } @Bean - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory() { return new LoadBalancedRetryPolicyFactory.NeverRetryFactory();} + LoadBalancedRetryFactory loadBalancedRetryFactory() {return new LoadBalancedRetryFactory(){};} } diff --git a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerAutoConfigurationTests.java b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerAutoConfigurationTests.java index a3072ee1..cb395f4a 100644 --- a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerAutoConfigurationTests.java +++ b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerAutoConfigurationTests.java @@ -28,9 +28,9 @@ public class RetryLoadBalancerAutoConfigurationTests extends AbstractLoadBalance @Test public void testDefaultBackOffPolicy() throws Exception { ConfigurableApplicationContext context = init(OneRestTemplate.class); - LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory = context.getBean(LoadBalancedBackOffPolicyFactory.class); - assertThat(loadBalancedBackOffPolicyFactory, is(instanceOf(LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory.class))); - assertThat(loadBalancedBackOffPolicyFactory.createBackOffPolicy("foo"), is(instanceOf(NoBackOffPolicy.class))); + LoadBalancedRetryFactory loadBalancedRetryFactory = context.getBean(LoadBalancedRetryFactory.class); + assertThat(loadBalancedRetryFactory, is(instanceOf(LoadBalancedRetryFactory.class))); + assertThat(loadBalancedRetryFactory.createBackOffPolicy("foo"), is(instanceOf(NoBackOffPolicy.class))); } } diff --git a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerInterceptorTest.java b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerInterceptorTest.java index 46fd8f6a..7563daea 100644 --- a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerInterceptorTest.java +++ b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerInterceptorTest.java @@ -25,6 +25,8 @@ import org.springframework.retry.TerminatedRetryException; import org.springframework.retry.backoff.BackOffContext; import org.springframework.retry.backoff.BackOffInterruptedException; import org.springframework.retry.backoff.BackOffPolicy; +import org.springframework.retry.backoff.NoBackOffPolicy; +import org.springframework.retry.listener.RetryListenerSupport; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.is; @@ -46,8 +48,7 @@ public class RetryLoadBalancerInterceptorTest { private LoadBalancerClient client; private LoadBalancerRetryProperties lbProperties; private LoadBalancerRequestFactory lbRequestFactory; - private LoadBalancedBackOffPolicyFactory backOffPolicyFactory = new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory(); - private LoadBalancedRetryListenerFactory retryListenerFactory = new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory(); + private LoadBalancedRetryFactory loadBalancedRetryFactory = new LoadBalancedRetryFactory(){}; @Before public void setUp() throws Exception { @@ -67,14 +68,12 @@ public class RetryLoadBalancerInterceptorTest { public void interceptDisableRetry() throws Throwable { HttpRequest request = mock(HttpRequest.class); when(request.getURI()).thenReturn(new URI("http://foo")); - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class); - when(lbRetryPolicyFactory.create(eq("foo"), any(ServiceInstanceChooser.class))).thenReturn(null); ServiceInstance serviceInstance = mock(ServiceInstance.class); when(client.choose(eq("foo"))).thenReturn(serviceInstance); when(client.execute(eq("foo"), eq(serviceInstance), any(LoadBalancerRequest.class))).thenThrow(new IOException()); lbProperties.setEnabled(false); - RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRetryPolicyFactory, - lbRequestFactory, backOffPolicyFactory, retryListenerFactory); + RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, + lbRequestFactory, loadBalancedRetryFactory); byte[] body = new byte[]{}; ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.class); @@ -88,10 +87,9 @@ public class RetryLoadBalancerInterceptorTest { public void interceptInvalidHost() throws Throwable { HttpRequest request = mock(HttpRequest.class); when(request.getURI()).thenReturn(new URI("http://foo_underscore")); - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class); lbProperties.setEnabled(true); - RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRetryPolicyFactory, lbRequestFactory, - backOffPolicyFactory, retryListenerFactory); + RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRequestFactory, + loadBalancedRetryFactory); byte[] body = new byte[]{}; ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.class); interceptor.intercept(request, body, execution); @@ -102,15 +100,13 @@ public class RetryLoadBalancerInterceptorTest { HttpRequest request = mock(HttpRequest.class); when(request.getURI()).thenReturn(new URI("http://foo")); ClientHttpResponse clientHttpResponse = new MockClientHttpResponse(new byte[]{}, HttpStatus.OK); - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class); - when(lbRetryPolicyFactory.create(eq("foo"), any(ServiceInstanceChooser.class))).thenReturn(null); ServiceInstance serviceInstance = mock(ServiceInstance.class); when(client.choose(eq("foo"))).thenReturn(serviceInstance); when(client.execute(eq("foo"), eq(serviceInstance), any(LoadBalancerRequest.class))).thenReturn(clientHttpResponse); when(this.lbRequestFactory.createRequest(any(), any(), any())).thenReturn(mock(LoadBalancerRequest.class)); lbProperties.setEnabled(true); - RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRetryPolicyFactory, - lbRequestFactory, backOffPolicyFactory, retryListenerFactory); + RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, + lbRequestFactory, loadBalancedRetryFactory); byte[] body = new byte[]{}; ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.class); interceptor.intercept(request, body, execution); @@ -123,15 +119,13 @@ public class RetryLoadBalancerInterceptorTest { when(request.getURI()).thenReturn(new URI("http://foo")); ClientHttpResponse clientHttpResponse = new MockClientHttpResponse(new byte[]{}, HttpStatus.OK); LoadBalancedRetryPolicy policy = mock(LoadBalancedRetryPolicy.class); - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class); - when(lbRetryPolicyFactory.create(eq("foo"), any(ServiceInstanceChooser.class))).thenReturn(policy); ServiceInstance serviceInstance = mock(ServiceInstance.class); when(client.choose(eq("foo"))).thenReturn(serviceInstance); when(client.execute(eq("foo"), eq(serviceInstance), any(LoadBalancerRequest.class))).thenReturn(clientHttpResponse); when(this.lbRequestFactory.createRequest(any(), any(), any())).thenReturn(mock(LoadBalancerRequest.class)); lbProperties.setEnabled(true); - RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRetryPolicyFactory, - lbRequestFactory, backOffPolicyFactory, retryListenerFactory); + RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, + lbRequestFactory, new MyLoadBalancedRetryFactory(policy)); byte[] body = new byte[]{}; ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.class); ClientHttpResponse rsp = interceptor.intercept(request, body, execution); @@ -150,15 +144,13 @@ public class RetryLoadBalancerInterceptorTest { LoadBalancedRetryPolicy policy = mock(LoadBalancedRetryPolicy.class); when(policy.retryableStatusCode(eq(HttpStatus.NOT_FOUND.value()))).thenReturn(true); when(policy.canRetryNextServer(any(LoadBalancedRetryContext.class))).thenReturn(true); - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class); - when(lbRetryPolicyFactory.create(eq("foo"), any(ServiceInstanceChooser.class))).thenReturn(policy); ServiceInstance serviceInstance = mock(ServiceInstance.class); when(client.choose(eq("foo"))).thenReturn(serviceInstance); when(client.execute(eq("foo"), eq(serviceInstance), nullable(LoadBalancerRequest.class))). thenReturn(clientHttpResponseNotFound).thenReturn(clientHttpResponseOk); lbProperties.setEnabled(true); - RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRetryPolicyFactory, - lbRequestFactory, backOffPolicyFactory, retryListenerFactory); + RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, + lbRequestFactory, new MyLoadBalancedRetryFactory(policy)); byte[] body = new byte[]{}; ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.class); ClientHttpResponse rsp = interceptor.intercept(request, body, execution); @@ -180,20 +172,16 @@ public class RetryLoadBalancerInterceptorTest { when(policy.retryableStatusCode(eq(HttpStatus.NOT_FOUND.value()))).thenReturn(true); when(policy.canRetryNextServer(any(LoadBalancedRetryContext.class))).thenReturn(false); - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class); - when(lbRetryPolicyFactory.create(eq("foo"), any(ServiceInstanceChooser.class))).thenReturn(policy); - ServiceInstance serviceInstance = mock(ServiceInstance.class); when(client.choose(eq("foo"))).thenReturn(serviceInstance); when(client.execute(eq("foo"), eq(serviceInstance), ArgumentMatchers.>any())) .thenReturn(clientHttpResponseNotFound); lbProperties.setEnabled(true); - RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRetryPolicyFactory, lbRequestFactory, - new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory(), new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory()); byte[] body = new byte[]{}; ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.class); - + RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, + lbRequestFactory, new MyLoadBalancedRetryFactory(policy)); ClientHttpResponse rsp = interceptor.intercept(request, body, execution); verify(client, times(1)).execute(eq("foo"), eq(serviceInstance), @@ -215,18 +203,14 @@ public class RetryLoadBalancerInterceptorTest { ClientHttpResponse clientHttpResponse = new MockClientHttpResponse(new byte[]{}, HttpStatus.OK); LoadBalancedRetryPolicy policy = mock(LoadBalancedRetryPolicy.class); when(policy.canRetryNextServer(any(LoadBalancedRetryContext.class))).thenReturn(true); - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class); - when(lbRetryPolicyFactory.create(eq("foo"), any(ServiceInstanceChooser.class))).thenReturn(policy); - LoadBalancedBackOffPolicyFactory backOffPolicyFactory = mock(LoadBalancedBackOffPolicyFactory.class); MyBackOffPolicy backOffPolicy = new MyBackOffPolicy(); - when(backOffPolicyFactory.createBackOffPolicy(eq("foo"))).thenReturn(backOffPolicy); ServiceInstance serviceInstance = mock(ServiceInstance.class); when(client.choose(eq("foo"))).thenReturn(serviceInstance); when(client.execute(eq("foo"), eq(serviceInstance), any(LoadBalancerRequest.class))).thenThrow(new IOException()).thenReturn(clientHttpResponse); when(this.lbRequestFactory.createRequest(any(), any(), any())).thenReturn(mock(LoadBalancerRequest.class)); lbProperties.setEnabled(true); - RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRetryPolicyFactory, lbRequestFactory, - backOffPolicyFactory, retryListenerFactory); + RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRequestFactory, + new MyLoadBalancedRetryFactory(policy, backOffPolicy)); byte[] body = new byte[]{}; ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.class); ClientHttpResponse rsp = interceptor.intercept(request, body, execution); @@ -243,15 +227,13 @@ public class RetryLoadBalancerInterceptorTest { ClientHttpResponse clientHttpResponse = new MockClientHttpResponse(new byte[]{}, HttpStatus.OK); LoadBalancedRetryPolicy policy = mock(LoadBalancedRetryPolicy.class); when(policy.canRetryNextServer(any(LoadBalancedRetryContext.class))).thenReturn(false); - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class); - when(lbRetryPolicyFactory.create(eq("foo"), any(ServiceInstanceChooser.class))).thenReturn(policy); ServiceInstance serviceInstance = mock(ServiceInstance.class); when(client.choose(eq("foo"))).thenReturn(serviceInstance); when(client.execute(eq("foo"), eq(serviceInstance), any(LoadBalancerRequest.class))).thenThrow(new IOException()).thenReturn(clientHttpResponse); when(this.lbRequestFactory.createRequest(any(), any(), any())).thenReturn(mock(LoadBalancerRequest.class)); lbProperties.setEnabled(true); - RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRetryPolicyFactory, - lbRequestFactory, backOffPolicyFactory, retryListenerFactory); + RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, + lbRequestFactory, new MyLoadBalancedRetryFactory(policy)); byte[] body = new byte[]{}; ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.class); interceptor.intercept(request, body, execution); @@ -265,19 +247,15 @@ public class RetryLoadBalancerInterceptorTest { ClientHttpResponse clientHttpResponse = new MockClientHttpResponse(new byte[]{}, HttpStatus.OK); LoadBalancedRetryPolicy policy = mock(LoadBalancedRetryPolicy.class); when(policy.canRetryNextServer(any(LoadBalancedRetryContext.class))).thenReturn(true); - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class); - when(lbRetryPolicyFactory.create(eq("listener"), any(ServiceInstanceChooser.class))).thenReturn(policy); - LoadBalancedBackOffPolicyFactory backOffPolicyFactory = mock(LoadBalancedBackOffPolicyFactory.class); MyBackOffPolicy backOffPolicy = new MyBackOffPolicy(); - when(backOffPolicyFactory.createBackOffPolicy(eq("listener"))).thenReturn(backOffPolicy); ServiceInstance serviceInstance = mock(ServiceInstance.class); when(client.choose(eq("listener"))).thenReturn(serviceInstance); when(client.execute(eq("listener"), eq(serviceInstance), any(LoadBalancerRequest.class))).thenThrow(new IOException()).thenReturn(clientHttpResponse); lbProperties.setEnabled(true); - MyRetryListeners retryListeners = new MyRetryListeners(); + MyRetryListener retryListener = new MyRetryListener(); when(this.lbRequestFactory.createRequest(any(), any(), any())).thenReturn(mock(LoadBalancerRequest.class)); - RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRetryPolicyFactory, lbRequestFactory, - backOffPolicyFactory, retryListeners); + RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRequestFactory, + new MyLoadBalancedRetryFactory(policy, backOffPolicy, new RetryListener[]{retryListener})); byte[] body = new byte[]{}; ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.class); ClientHttpResponse rsp = interceptor.intercept(request, body, execution); @@ -285,28 +263,26 @@ public class RetryLoadBalancerInterceptorTest { assertThat(rsp, is(clientHttpResponse)); verify(lbRequestFactory, times(2)).createRequest(request, body, execution); assertThat(backOffPolicy.getBackoffAttempts(), is(1)); - assertThat(retryListeners.getOnError(), is(1)); + assertThat(retryListener.getOnError(), is(1)); } @Test(expected = TerminatedRetryException.class) public void retryListenerTestNoRetry() throws Throwable { HttpRequest request = mock(HttpRequest.class); when(request.getURI()).thenReturn(new URI("http://noRetry")); - ClientHttpResponse clientHttpResponse = new MockClientHttpResponse(new byte[]{}, HttpStatus.OK); LoadBalancedRetryPolicy policy = mock(LoadBalancedRetryPolicy.class); - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class); - when(lbRetryPolicyFactory.create(eq("noRetry"), any(ServiceInstanceChooser.class))).thenReturn(policy); - LoadBalancedBackOffPolicyFactory backOffPolicyFactory = mock(LoadBalancedBackOffPolicyFactory.class); MyBackOffPolicy backOffPolicy = new MyBackOffPolicy(); - when(backOffPolicyFactory.createBackOffPolicy(eq("noRetry"))).thenReturn(backOffPolicy); - ServiceInstance serviceInstance = mock(ServiceInstance.class); lbProperties.setEnabled(true); - MyRetryListenersNotRetry retryListeners = new MyRetryListenersNotRetry(); - RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRetryPolicyFactory, lbRequestFactory, - backOffPolicyFactory, retryListeners); - byte[] body = new byte[]{}; + RetryListener myRetryListener = new RetryListenerSupport(){ + @Override + public boolean open(RetryContext context, RetryCallback callback) { + return false; + } + }; + RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRequestFactory, + new MyLoadBalancedRetryFactory(policy, backOffPolicy, new RetryListener[]{myRetryListener})); ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.class); - interceptor.intercept(request, body, execution); + interceptor.intercept(request, new byte[]{}, execution); } @Test @@ -316,18 +292,14 @@ public class RetryLoadBalancerInterceptorTest { ClientHttpResponse clientHttpResponse = new MockClientHttpResponse(new byte[]{}, HttpStatus.OK); LoadBalancedRetryPolicy policy = mock(LoadBalancedRetryPolicy.class); when(policy.canRetryNextServer(any(LoadBalancedRetryContext.class))).thenReturn(true); - LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class); - when(lbRetryPolicyFactory.create(eq("default"), any(ServiceInstanceChooser.class))).thenReturn(policy); - LoadBalancedBackOffPolicyFactory backOffPolicyFactory = mock(LoadBalancedBackOffPolicyFactory.class); MyBackOffPolicy backOffPolicy = new MyBackOffPolicy(); - when(backOffPolicyFactory.createBackOffPolicy(eq("default"))).thenReturn(backOffPolicy); ServiceInstance serviceInstance = mock(ServiceInstance.class); when(client.choose(eq("default"))).thenReturn(serviceInstance); when(client.execute(eq("default"), eq(serviceInstance), any(LoadBalancerRequest.class))).thenThrow(new IOException()).thenReturn(clientHttpResponse); lbProperties.setEnabled(true); when(this.lbRequestFactory.createRequest(any(), any(), any())).thenReturn(mock(LoadBalancerRequest.class)); - RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRetryPolicyFactory, lbRequestFactory, - backOffPolicyFactory, new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory()); + RetryLoadBalancerInterceptor interceptor = new RetryLoadBalancerInterceptor(client, lbProperties, lbRequestFactory, + new MyLoadBalancedRetryFactory(policy, backOffPolicy)); byte[] body = new byte[]{}; ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.class); ClientHttpResponse rsp = interceptor.intercept(request, body, execution); @@ -337,6 +309,50 @@ public class RetryLoadBalancerInterceptorTest { assertThat(backOffPolicy.getBackoffAttempts(), is(1)); } + class MyLoadBalancedRetryFactory implements LoadBalancedRetryFactory { + private LoadBalancedRetryPolicy loadBalancedRetryPolicy; + private BackOffPolicy backOffPolicy; + private RetryListener[] retryListeners; + + public MyLoadBalancedRetryFactory(LoadBalancedRetryPolicy loadBalancedRetryPolicy) { + this.loadBalancedRetryPolicy = loadBalancedRetryPolicy; + } + + public MyLoadBalancedRetryFactory(LoadBalancedRetryPolicy loadBalancedRetryPolicy, BackOffPolicy backOffPolicy) { + this(loadBalancedRetryPolicy); + this.backOffPolicy = backOffPolicy; + } + + public MyLoadBalancedRetryFactory(LoadBalancedRetryPolicy loadBalancedRetryPolicy, BackOffPolicy backOffPolicy, + RetryListener[] retryListeners) { + this(loadBalancedRetryPolicy, backOffPolicy); + this.retryListeners = retryListeners; + } + + @Override + public LoadBalancedRetryPolicy createRetryPolicy(String service, ServiceInstanceChooser serviceInstanceChooser) { + return loadBalancedRetryPolicy; + } + + @Override + public BackOffPolicy createBackOffPolicy(String service) { + if(backOffPolicy == null) { + return new NoBackOffPolicy(); + } else { + return backOffPolicy; + } + } + + @Override + public RetryListener[] createRetryListeners(String service) { + if(retryListeners == null) { + return new RetryListener[0]; + } else { + return retryListeners; + } + } + } + class MyBackOffPolicy implements BackOffPolicy { private int backoffAttempts = 0; @@ -361,55 +377,17 @@ public class RetryLoadBalancerInterceptorTest { } } - class MyRetryListeners implements LoadBalancedRetryListenerFactory { + class MyRetryListener extends RetryListenerSupport { private int onError = 0; - @Override - public RetryListener[] createRetryListeners(String service) { - return new RetryListener[] {new RetryListener() { - @Override - public boolean open(RetryContext context, RetryCallback callback) { - return true; - } - - @Override - public void close(RetryContext context, RetryCallback callback, Throwable throwable) { - - } - - @Override - public void onError(RetryContext context, RetryCallback callback, Throwable throwable) { - onError++; - } - }}; - } + @Override + public void onError(RetryContext retryContext, RetryCallback retryCallback, Throwable throwable) { + onError++; + } int getOnError() { return onError; } - } - - class MyRetryListenersNotRetry implements LoadBalancedRetryListenerFactory { - - @Override - public RetryListener[] createRetryListeners(String service) { - return new RetryListener[] {new RetryListener() { - @Override - public boolean open(RetryContext context, RetryCallback callback) { - return false; - } - - @Override - public void close(RetryContext context, RetryCallback callback, Throwable throwable) { - - } - - @Override - public void onError(RetryContext context, RetryCallback callback, Throwable throwable) { - } - }}; - } - - } + } } \ No newline at end of file diff --git a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/reactive/ReactiveLoadBalancerAutoConfigurationTests.java b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/reactive/ReactiveLoadBalancerAutoConfigurationTests.java index 6a56cd1d..101931bf 100644 --- a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/reactive/ReactiveLoadBalancerAutoConfigurationTests.java +++ b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/reactive/ReactiveLoadBalancerAutoConfigurationTests.java @@ -23,7 +23,7 @@ import org.springframework.boot.builder.SpringApplicationBuilder; import org.springframework.cloud.client.DefaultServiceInstance; import org.springframework.cloud.client.ServiceInstance; import org.springframework.cloud.client.loadbalancer.LoadBalanced; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory; import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; import org.springframework.cloud.client.loadbalancer.LoadBalancerRequest; import org.springframework.context.ConfigurableApplicationContext; @@ -111,7 +111,7 @@ public class ReactiveLoadBalancerAutoConfigurationTests { } @Bean - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory() { return new LoadBalancedRetryPolicyFactory.NeverRetryFactory();} + LoadBalancedRetryFactory loadBalancedRetryFactory() {return new LoadBalancedRetryFactory(){};} }