Revert "GH-264: Add retrhro to @retryable"

This reverts commit ec245fd.

Author: garyrussell

Diff for: src/main/java/org/springframework/retry/annotation/AnnotationAwareRetryOperationsInterceptor.java

@@ -217,16 +217,13 @@ 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());
 		return RetryInterceptorBuilder.stateless().retryOperations(template).label(retryable.label())
-				.recoverer(getRecoverer(target, method, retryable.rethrow())).build();
+				.recoverer(getRecoverer(target, method)).build();
 	}
 
 	private MethodInterceptor getStatefulInterceptor(Object target, Method method, Retryable retryable) {
-		boolean rethrow = retryable.rethrow();
 		RetryTemplate template = createTemplate(retryable.listeners());
 		template.setRetryContextCache(this.retryContextCache);
-		template.setNoRecoveryForNotRetryable(rethrow);
 
 		CircuitBreaker circuit = AnnotatedElementUtils.findMergedAnnotation(method, CircuitBreaker.class);
 		if (circuit == null) {
@@ -244,15 +241,15 @@ private MethodInterceptor getStatefulInterceptor(Object target, Method method, R
 				label = method.toGenericString();
 			}
 			return RetryInterceptorBuilder.circuitBreaker().keyGenerator(new FixedKeyGenerator("circuit"))
-					.retryOperations(template).recoverer(getRecoverer(target, method, rethrow)).label(label).build();
+					.retryOperations(template).recoverer(getRecoverer(target, method)).label(label).build();
 		}
 		RetryPolicy policy = getRetryPolicy(retryable);
 		template.setRetryPolicy(policy);
 		template.setBackOffPolicy(getBackoffPolicy(retryable.backoff()));
 		String label = retryable.label();
 		return RetryInterceptorBuilder.stateful().keyGenerator(this.methodArgumentsKeyGenerator)
 				.newMethodArgumentsIdentifier(this.newMethodArgumentsIdentifier).retryOperations(template).label(label)
-				.recoverer(getRecoverer(target, method, rethrow)).build();
+				.recoverer(getRecoverer(target, method)).build();
 	}
 
 	private long getOpenTimeout(CircuitBreaker circuit) {
@@ -296,7 +293,7 @@ private RetryListener[] getListenersBeans(String[] listenersBeanNames) {
 		return listeners;
 	}
 
-	private MethodInvocationRecoverer<?> getRecoverer(Object target, Method method, boolean rethrow) {
+	private MethodInvocationRecoverer<?> getRecoverer(Object target, Method method) {
 		if (target instanceof MethodInvocationRecoverer) {
 			return (MethodInvocationRecoverer<?>) target;
 		}
@@ -313,9 +310,7 @@ public void doWith(Method method) throws IllegalArgumentException, IllegalAccess
 		if (!foundRecoverable.get()) {
 			return null;
 		}
-		RecoverAnnotationRecoveryHandler recoveryHandler = new RecoverAnnotationRecoveryHandler<Object>(target, method);
-		recoveryHandler.setThrowLastExceptionWhenNoRecoverMethod(rethrow);
-		return recoveryHandler;
+		return new RecoverAnnotationRecoveryHandler<Object>(target, method);
 	}
 
 	private RetryPolicy getRetryPolicy(Annotation retryable) {

Diff for: src/main/java/org/springframework/retry/annotation/RecoverAnnotationRecoveryHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2022 the original author or authors.
+ * Copyright 2013-2019 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.
@@ -64,23 +64,16 @@ public class RecoverAnnotationRecoveryHandler<T> implements MethodInvocationReco
 
 	private String recoverMethodName;
 
-	private boolean throwLastExceptionWhenNoRecoverMethod;
-
 	public RecoverAnnotationRecoveryHandler(Object target, Method method) {
 		this.target = target;
 		init(target, method);
 	}
 
-	public void setThrowLastExceptionWhenNoRecoverMethod(boolean throwLastExceptionWhenNoRecoverMethod) {
-		this.throwLastExceptionWhenNoRecoverMethod = throwLastExceptionWhenNoRecoverMethod;
-	}
-
 	@Override
 	public T recover(Object[] args, Throwable cause) {
 		Method method = findClosestMatch(args, cause.getClass());
 		if (method == null) {
-			throw throwLastExceptionWhenNoRecoverMethod && cause instanceof RuntimeException ? (RuntimeException) cause
-					: new ExhaustedRetryException("Cannot locate recovery method", cause);
+			throw new ExhaustedRetryException("Cannot locate recovery method", cause);
 		}
 		SimpleMetadata meta = this.methods.get(method);
 		Object[] argsToUse = meta.getArgs(cause, args);

Diff for: src/main/java/org/springframework/retry/annotation/Retryable.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2022 the original author or authors.
+ * Copyright 2014-2019 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.
@@ -130,12 +130,4 @@
 	 */
 	String[] listeners() default {};
 
-	/**
-	 * When true raw exceptions are thrown without being wrapped and no recovery is
-	 * performed for not-retryable exceptions.
-	 * @return true if to rethrow raw exceptions, default false
-	 * @since 1.3.3
-	 */
-	boolean rethrow() default false;
-
 }

Diff for: src/main/java/org/springframework/retry/policy/SimpleRetryPolicy.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2006-2022 the original author or authors.
+ * Copyright 2006-2019 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.
@@ -199,16 +199,6 @@ public RetryContext open(RetryContext parent) {
 		return new SimpleRetryContext(parent);
 	}
 
-	/**
-	 * Delegates to an exception classifier.
-	 * @param ex
-	 * @return true if this exception or its ancestors have been registered as retryable.
-	 * @since 1.3.3
-	 */
-	public boolean retryForException(Throwable ex) {
-		return this.retryableClassifier.classify(ex);
-	}
-
 	private static class SimpleRetryContext extends RetryContextSupport {
 
 		public SimpleRetryContext(RetryContext parent) {
@@ -217,6 +207,15 @@ public SimpleRetryContext(RetryContext parent) {
 
 	}
 
+	/**
+	 * Delegates to an exception classifier.
+	 * @param ex
+	 * @return true if this exception or its ancestors have been registered as retryable.
+	 */
+	private boolean retryForException(Throwable ex) {
+		return this.retryableClassifier.classify(ex);
+	}
+
 	@Override
 	public String toString() {
 		return ClassUtils.getShortName(getClass()) + "[maxAttempts=" + this.maxAttempts + "]";

Diff for: src/main/java/org/springframework/retry/support/RetryTemplate.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2006-2022 the original author or authors.
+ * Copyright 2006-2020 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.
@@ -96,8 +96,6 @@ public class RetryTemplate implements RetryOperations {
 
 	private boolean throwLastExceptionOnExhausted;
 
-	private boolean noRecoveryForNotRetryable;
-
 	/**
 	 * Main entry point to configure RetryTemplate using fluent API. See
 	 * {@link RetryTemplateBuilder} for usage examples and details.
@@ -126,14 +124,6 @@ public void setThrowLastExceptionOnExhausted(boolean throwLastExceptionOnExhaust
 		this.throwLastExceptionOnExhausted = throwLastExceptionOnExhausted;
 	}
 
-	/**
-	 * @param noRecoveryForNotRetryable the noRecoveryForNotRetryable to set
-	 * @since 1.3.3
-	 */
-	public void setNoRecoveryForNotRetryable(boolean noRecoveryForNotRetryable) {
-		this.noRecoveryForNotRetryable = noRecoveryForNotRetryable;
-	}
-
 	/**
 	 * Public setter for the {@link RetryContextCache}.
 	 * @param retryContextCache the {@link RetryContextCache} to set.
@@ -376,6 +366,7 @@ protected <T, E extends Throwable> T doExecute(RetryCallback<T, E> retryCallback
 						}
 						throw RetryTemplate.<E>wrapIfNecessary(e);
 					}
+
 				}
 
 				/*
@@ -393,7 +384,7 @@ protected <T, E extends Throwable> T doExecute(RetryCallback<T, E> retryCallback
 			}
 
 			exhausted = true;
-			return handleRetryExhausted(recoveryCallback, context, state, retryPolicy);
+			return handleRetryExhausted(recoveryCallback, context, state);
 
 		}
 		catch (Throwable e) {
@@ -471,6 +462,7 @@ private void registerContext(RetryContext context, RetryState state) {
 	 * was encountered
 	 */
 	protected RetryContext open(RetryPolicy retryPolicy, RetryState state) {
+
 		if (state == null) {
 			return doOpenInternal(retryPolicy);
 		}
@@ -504,6 +496,7 @@ protected RetryContext open(RetryPolicy retryPolicy, RetryState state) {
 		context.removeAttribute(RetryContext.EXHAUSTED);
 		context.removeAttribute(RetryContext.RECOVERED);
 		return context;
+
 	}
 
 	private RetryContext doOpenInternal(RetryPolicy retryPolicy, RetryState state) {
@@ -536,16 +529,12 @@ private RetryContext doOpenInternal(RetryPolicy retryPolicy) {
 	 * @return T the payload to return
 	 * @throws Throwable if there is an error
 	 */
-	protected <T> T handleRetryExhausted(RecoveryCallback<T> recoveryCallback, RetryContext context, RetryState state,
-			RetryPolicy retryPolicy) throws Throwable {
+	protected <T> T handleRetryExhausted(RecoveryCallback<T> recoveryCallback, RetryContext context, RetryState state)
+			throws Throwable {
 		context.setAttribute(RetryContext.EXHAUSTED, true);
 		if (state != null && !context.hasAttribute(GLOBAL_STATE)) {
 			this.retryContextCache.remove(state.getKey());
 		}
-		if (this.noRecoveryForNotRetryable && retryPolicy instanceof SimpleRetryPolicy
-				&& !((SimpleRetryPolicy) retryPolicy).retryForException(context.getLastThrowable())) {
-			throw context.getLastThrowable();
-		}
 		if (recoveryCallback != null) {
 			T recovered = recoveryCallback.recover(context);
 			context.setAttribute(RetryContext.RECOVERED, true);
@@ -559,7 +548,7 @@ protected <T> T handleRetryExhausted(RecoveryCallback<T> recoveryCallback, Retry
 	}
 
 	protected <E extends Throwable> void rethrow(RetryContext context, String message) throws E {
-		if (this.throwLastExceptionOnExhausted || this.noRecoveryForNotRetryable) {
+		if (this.throwLastExceptionOnExhausted) {
 			@SuppressWarnings("unchecked")
 			E rethrow = (E) context.getLastThrowable();
 			throw rethrow;
@@ -583,13 +572,15 @@ protected boolean shouldRethrow(RetryPolicy retryPolicy, RetryContext context, R
 	}
 
 	private <T, E extends Throwable> boolean doOpenInterceptors(RetryCallback<T, E> callback, RetryContext context) {
+
 		boolean result = true;
 
 		for (RetryListener listener : this.listeners) {
 			result = result && listener.open(context, callback);
 		}
 
 		return result;
+
 	}
 
 	private <T, E extends Throwable> void doCloseInterceptors(RetryCallback<T, E> callback, RetryContext context,

Diff for: src/test/java/org/springframework/retry/annotation/EnableRetryTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2022 the original author or authors.
+ * Copyright 2014-2021 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.
@@ -255,22 +255,6 @@ public void testExpression() throws Exception {
 		context.close();
 	}
 
-	@Test
-	public void rethrow() {
-		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);
-		RethrowService service = context.getBean(RethrowService.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;
@@ -450,11 +434,6 @@ public ExcludesOnlyService excludesOnly() {
 			return new ExcludesOnlyService();
 		}
 
-		@Bean
-		public RethrowService rethrowService() {
-			return new RethrowService();
-		}
-
 		@Bean
 		public MethodInterceptor retryInterceptor() {
 			return RetryInterceptorBuilder.stateless().maxAttempts(5).build();
@@ -717,23 +696,6 @@ public int getCount() {
 
 	}
 
-	private static class RethrowService {
-
-		private int count = 0;
-
-		@Retryable(include = IllegalArgumentException.class, rethrow = true)
-		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) {