Add warnings for invalid setter values in ExponentialBackoffPolicy

- Add warning logs when setter values don't meet expected constraints
- Maintain backward compatibility by not changing behavior

Fixes #352

Signed-off-by: kssumin <[email protected]>

Author: kssumin

src/main/java/org/springframework/retry/backoff/ExponentialBackOffPolicy.java

@@ -43,11 +43,12 @@
  * @author Artem Bilan
  * @author Marius Lichtblau
  * @author Anton Aharkau
+ * @author Kim Sumin
  */
 @SuppressWarnings("serial")
 public class ExponentialBackOffPolicy implements SleepingBackOffPolicy<ExponentialBackOffPolicy> {
 
-	protected final Log logger = LogFactory.getLog(this.getClass());
+	protected Log logger = LogFactory.getLog(this.getClass());
 
 	/**
 	 * The default 'initialInterval' value - 100 millisecs. Coupled with the default
@@ -130,6 +131,11 @@ protected void cloneValues(ExponentialBackOffPolicy target) {
 	 * @param initialInterval the initial interval
 	 */
 	public void setInitialInterval(long initialInterval) {
+		if (initialInterval < 1) {
+			logger.warn("The initial interval value " + initialInterval +
+					" is less than 1. " +
+					"The initial interval should be at least 1. ");
+		}
 		this.initialInterval = initialInterval > 1 ? initialInterval : 1;
 	}
 
@@ -139,6 +145,12 @@ public void setInitialInterval(long initialInterval) {
 	 * @param multiplier the multiplier
 	 */
 	public void setMultiplier(double multiplier) {
+		if (multiplier <= 1.0) {
+			logger.warn("The multiplier value " + multiplier +
+					" is less than or equal to 1.0. " +
+					"For exponential backoff to work effectively, " +
+					"the multiplier should be greater than 1.0. ");
+		}
 		this.multiplier = multiplier > 1.0 ? multiplier : 1.0;
 	}
 
@@ -150,6 +162,11 @@ public void setMultiplier(double multiplier) {
 	 * @param maxInterval in milliseconds.
 	 */
 	public void setMaxInterval(long maxInterval) {
+		if (maxInterval < 1) {
+			logger.warn("The max interval value " + maxInterval +
+					" is less than or equal to 0. " +
+					"The max interval should be positive.");
+		}
 		this.maxInterval = maxInterval > 0 ? maxInterval : 1;
 	}
 
@@ -252,6 +269,18 @@ public void backOff(BackOffContext backOffContext) throws BackOffInterruptedExce
 		}
 	}
 
+	/**
+	 * Setter for {@link Log}. If not applied the following is used:
+	 * <p>
+	 * {@code LogFactory.getLog(getClass())}
+	 * </p>
+	 * @param logger the logger the exponential backoff policy uses for logging
+	 * @since 2.0.x
+	 */
+	public void setLogger(Log logger) {
+		this.logger = logger;
+	}
+
 	static class ExponentialBackOffContext implements BackOffContext {
 
 		private final double multiplier;

src/test/java/org/springframework/retry/backoff/ExponentialBackOffPolicyTests.java

@@ -16,17 +16,21 @@
 
 package org.springframework.retry.backoff;
 
+import org.apache.commons.logging.Log;
 import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.Mockito.*;
 
 /**
  * @author Rob Harrop
  * @author Dave Syer
  * @author Gary Russell
  * @author Marius Lichtblau
  * @author Anton Aharkau
+ * @author Kim Sumin
  */
 public class ExponentialBackOffPolicyTests {
 
@@ -125,4 +129,43 @@ public void sleep(long backOffPeriod) throws InterruptedException {
 		assertThat(Thread.interrupted()).isTrue();
 	}
 
+	@Test
+	public void testSetMultiplierWithWarning() {
+		Log logMock = mock(Log.class);
+		ExponentialBackOffPolicy strategy = new ExponentialBackOffPolicy();
+		strategy.setLogger(logMock);
+
+		strategy.setMultiplier(1.0);
+
+		ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+		verify(logMock).warn(captor.capture());
+		assertThat(captor.getValue()).contains("The multiplier value 1.0 is less than or equal to 1.0");
+	}
+
+
+	@Test
+	public void testSetInitialIntervalWithWarning() {
+		Log logMock = mock(Log.class);
+		ExponentialBackOffPolicy strategy = new ExponentialBackOffPolicy();
+		strategy.setLogger(logMock);
+
+		strategy.setInitialInterval(0);
+
+		ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+		verify(logMock).warn(captor.capture());
+		assertThat(captor.getValue()).contains("The initial interval value 0 is less than 1. The initial interval should be at least 1.");
+	}
+
+	@Test
+	public void testSetMaxIntervalWithWarning() {
+		Log logMock = mock(Log.class);
+		ExponentialBackOffPolicy strategy = new ExponentialBackOffPolicy();
+		strategy.setLogger(logMock);
+
+		strategy.setMaxInterval(0);
+
+		ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+		verify(logMock).warn(captor.capture());
+		assertThat(captor.getValue()).contains("The max interval value 0 is less than or equal to 0. The max interval should be positive.");
+	}
 }