Rethrow particular not-retryable exceptions

README.md

@@ -580,7 +580,7 @@ Expressions can contain property placeholders, such as `#{${max.delay}}` or
 during initialization. There is no root object for the evaluation but they can reference
 other beans in the context.
 
-Version 1.3.3 added the `rethrow` attribute to `@Retryable`; when `true` any exceptions that are not retryable are thrown unchanged to the caller and the `@Recover` method is not called.
+Version 1.3.3 added the `rethrow` and `rethrowExceptions` attributes to `@Retryable`; when `rethrow` is `true` any exceptions that are not retryable are thrown unchanged to the caller and the `@Recover` method is not called. The same behavior for exceptions listed in `rethrowExceptions`.
 
 #### <a name="Additional_Dependencies"></a> Additional Dependencies
 

src/main/java/org/springframework/retry/annotation/AnnotationAwareRetryOperationsInterceptor.java

@@ -217,7 +217,7 @@ private MethodInterceptor getStatelessInterceptor(Object target, Method method,
 		RetryTemplate template = createTemplate(retryable.listeners());
 		template.setRetryPolicy(getRetryPolicy(retryable));
 		template.setBackOffPolicy(getBackoffPolicy(retryable.backoff()));
-		template.setNoRecoveryForNotRetryable(retryable.rethrow());
+		template.setNoRecoveryForNotRetryable(retryable.rethrow() || retryable.rethrowExceptions().length > 0);
 		return RetryInterceptorBuilder.stateless().retryOperations(template).label(retryable.label())
 				.recoverer(getRecoverer(target, method, retryable.rethrow())).build();
 	}
@@ -226,7 +226,7 @@ private MethodInterceptor getStatefulInterceptor(Object target, Method method, R
 		boolean rethrow = retryable.rethrow();
 		RetryTemplate template = createTemplate(retryable.listeners());
 		template.setRetryContextCache(this.retryContextCache);
-		template.setNoRecoveryForNotRetryable(rethrow);
+		template.setNoRecoveryForNotRetryable(rethrow || retryable.rethrowExceptions().length > 0);
 
 		CircuitBreaker circuit = AnnotatedElementUtils.findMergedAnnotation(method, CircuitBreaker.class);
 		if (circuit == null) {
@@ -343,7 +343,11 @@ private RetryPolicy getRetryPolicy(Annotation retryable) {
 						Integer.class);
 			}
 		}
-		if (includes.length == 0 && excludes.length == 0) {
+		Class<? extends Throwable>[] rethrowExceptions = (Class<? extends Throwable>[]) attrs.get("rethrowExceptions");
+		if (rethrowExceptions == null) {
+			rethrowExceptions = new Class[0];
+		}
+		if (includes.length == 0 && excludes.length == 0 && rethrowExceptions.length == 0) {
 			SimpleRetryPolicy simple = hasExpression
 					? new ExpressionRetryPolicy(resolve(exceptionExpression)).withBeanFactory(this.beanFactory)
 					: new SimpleRetryPolicy();
@@ -357,6 +361,9 @@ private RetryPolicy getRetryPolicy(Annotation retryable) {
 		for (Class<? extends Throwable> type : excludes) {
 			policyMap.put(type, false);
 		}
+		for (Class<? extends Throwable> type : rethrowExceptions) {
+			policyMap.put(type, false);
+		}
 		boolean retryNotExcluded = includes.length == 0;
 		if (hasExpression) {
 			return new ExpressionRetryPolicy(maxAttempts, policyMap, true, exceptionExpression, retryNotExcluded)

src/main/java/org/springframework/retry/annotation/Retryable.java

@@ -138,4 +138,12 @@
 	 */
 	boolean rethrow() default false;
 
+	/**
+	 * For these exception types raw exceptions are thrown without being wrapped and no
+	 * recovery is performed not-retryable exceptions.
+	 * @return exception types not to recover
+	 * @since 1.3.3
+	 */
+	Class<? extends Throwable>[] rethrowExceptions() default {};
+
 }

src/main/java/org/springframework/retry/support/RetryTemplate.java

@@ -547,8 +547,7 @@ protected <T> T handleRetryExhausted(RecoveryCallback<T> recoveryCallback, Retry
 			this.retryContextCache.remove(state.getKey());
 		}
 		// TODO: In 2.0 add retryForException() to the interface.
-		if (this.noRecoveryForNotRetryable && retryPolicy instanceof SimpleRetryPolicy
-				&& !((SimpleRetryPolicy) retryPolicy).retryForException(context.getLastThrowable())) {
+		if (shouldRethrowWithoutRecovery(context.getLastThrowable())) {
 			throw context.getLastThrowable();
 		}
 		if (recoveryCallback != null) {
@@ -587,6 +586,11 @@ protected boolean shouldRethrow(RetryPolicy retryPolicy, RetryContext context, R
 		return state != null && state.rollbackFor(context.getLastThrowable());
 	}
 
+	private boolean shouldRethrowWithoutRecovery(Throwable throwable) {
+		return this.noRecoveryForNotRetryable && retryPolicy instanceof SimpleRetryPolicy
+				&& !((SimpleRetryPolicy) retryPolicy).retryForException(throwable);
+	}
+
 	private <T, E extends Throwable> boolean doOpenInterceptors(RetryCallback<T, E> callback, RetryContext context) {
 		boolean result = true;
 

src/test/java/org/springframework/retry/annotation/EnableRetryTests.java

@@ -271,6 +271,22 @@ public void rethrow() {
 		context.close();
 	}
 
+	@Test
+	public void rethrowExceptions() {
+		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);
+		RethrowExceptionsService service = context.getBean(RethrowExceptionsService.class);
+		for (int i = 0; i < 3; i++) {
+			try {
+				service.service();
+			}
+			catch (RuntimeException e) {
+				assertEquals("Planned", e.getMessage());
+			}
+		}
+		assertEquals(3, service.getCount());
+		context.close();
+	}
+
 	private Object target(Object target) {
 		if (!AopUtils.isAopProxy(target)) {
 			return target;
@@ -455,6 +471,11 @@ public RethrowService rethrowService() {
 			return new RethrowService();
 		}
 
+		@Bean
+		public RethrowExceptionsService rethrowExceptionsService() {
+			return new RethrowExceptionsService();
+		}
+
 		@Bean
 		public MethodInterceptor retryInterceptor() {
 			return RetryInterceptorBuilder.stateless().maxAttempts(5).build();
@@ -734,6 +755,23 @@ public int getCount() {
 
 	}
 
+	private static class RethrowExceptionsService {
+
+		private int count = 0;
+
+		@Retryable(include = IllegalArgumentException.class, rethrowExceptions = RuntimeException.class)
+		public void service() {
+			if (this.count++ < 2) {
+				throw new RuntimeException("Planned");
+			}
+		}
+
+		public int getCount() {
+			return this.count;
+		}
+
+	}
+
 	public static class ExceptionChecker {
 
 		public boolean shouldRetry(Throwable t) {

src/test/java/org/springframework/retry/support/RetryTemplateTests.java

@@ -17,6 +17,8 @@
 package org.springframework.retry.support;
 
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Test;
@@ -431,6 +433,57 @@ public Object recover(RetryContext context) throws Exception {
 		assertEquals(value, result);
 	}
 
+	@Test
+	public void testRethrowExceptionsForNotRetryable() throws Throwable {
+		Map<Class<? extends Throwable>, Boolean> retryableExceptions = new HashMap<Class<? extends Throwable>, Boolean>();
+		retryableExceptions.put(IllegalArgumentException.class, true);
+		retryableExceptions.put(IllegalStateException.class, false);
+		SimpleRetryPolicy policy = new SimpleRetryPolicy(1, retryableExceptions);
+		RetryTemplate retryTemplate = new RetryTemplate();
+		retryTemplate.setRetryPolicy(policy);
+		retryTemplate.setNoRecoveryForNotRetryable(true);
+		try {
+			retryTemplate.execute(new RetryCallback<Object, Exception>() {
+				@Override
+				public Object doWithRetry(RetryContext context) throws Exception {
+					throw new IllegalStateException("Realllly bad!");
+				}
+			}, new RecoveryCallback<Object>() {
+				@Override
+				public Object recover(RetryContext context) throws Exception {
+					return new Object();
+				}
+			});
+			fail("Expected RuntimeException");
+		}
+		catch (IllegalStateException e) {
+			assertEquals("Realllly bad!", e.getMessage());
+		}
+	}
+
+	@Test
+	public void testRethrowExceptionsForRetryable() throws Throwable {
+		Map<Class<? extends Throwable>, Boolean> retryableExceptions = new HashMap<Class<? extends Throwable>, Boolean>();
+		retryableExceptions.put(IllegalArgumentException.class, true);
+		retryableExceptions.put(IllegalStateException.class, false);
+		SimpleRetryPolicy policy = new SimpleRetryPolicy(1, retryableExceptions);
+		RetryTemplate retryTemplate = new RetryTemplate();
+		retryTemplate.setRetryPolicy(policy);
+		final Object value = new Object();
+		Object result = retryTemplate.execute(new RetryCallback<Object, Exception>() {
+			@Override
+			public Object doWithRetry(RetryContext context) throws Exception {
+				throw new IllegalStateException("Will be recovered");
+			}
+		}, new RecoveryCallback<Object>() {
+			@Override
+			public Object recover(RetryContext context) throws Exception {
+				return value;
+			}
+		});
+		assertEquals(value, result);
+	}
+
 	private static class MockRetryCallback implements RetryCallback<Object, Exception> {
 
 		private int attempts;