我正在使用Spring-Retry进行一些数据库操作。在SQLRecoverableException
上我重试了三次(假设导致异常的任何内容如果失败三次都是非瞬态的),在SQLTransientException
上我无限期地重试(如果没有访问数据库,程序就无法执行任何操作,因此可能并继续重试,直到用户决定重新启动服务器),并在任何其他异常我不重试。我使用指数退避策略,基本重试为100毫秒,最大重试次数为30,000毫秒。
private static final int MAX_RECOVERABLE_RETRIES = 3;
private static final long INITIAL_INTERVAL = 100;
private static final long MAX_INTERVAL = 30 * 1000;
private static final double MULTIPLIER = 2.0;
public static RetryTemplate databaseTemplate() {
RetryTemplate template = new RetryTemplate();
ExceptionClassifierRetryPolicy retryPolicy = new ExceptionClassifierRetryPolicy();
Map<Class<? extends Throwable>, RetryPolicy> policyMap = new HashMap<>();
NeverRetryPolicy baseException = new NeverRetryPolicy();
SimpleRetryPolicy recoverablePolicy = new SimpleRetryPolicy();
recoverablePolicy.setMaxAttempts(MAX_RECOVERABLE_RETRIES);
AlwaysRetryPolicy transientPolicy = new AlwaysRetryPolicy();
policyMap.put(Exception.class, baseException);
policyMap.put(SQLRecoverableException.class, recoverablePolicy);
policyMap.put(SQLTransientException.class, transientPolicy);
retryPolicy.setPolicyMap(policyMap);
template.setRetryPolicy(retryPolicy);
ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
backOffPolicy.setInitialInterval(INITIAL_INTERVAL);
backOffPolicy.setMaxInterval(MAX_INTERVAL);
backOffPolicy.setMultiplier(MULTIPLIER);
template.setBackOffPolicy(backOffPolicy);
return template;
}
理想情况下,我想对所有SQLRecoverableExceptions
使用100ms的固定退避,并且仅将指数退避策略应用于SQLTransientExceptions
。我可以通过嵌套重试来实现这一点,但这会大大增加代码的复杂性 - 如果没有其他选项,我宁愿简单地将指数退避应用于SQLRecoverableException
和SQLTransientException
异常。
有没有办法让我使用单个重试模板将不同的退避策略应用于不同的异常?
确实,ExceptionClassifierRetryPolicy
是要走的路。我没有设法让它与policyMap
一起工作。
这是我如何使用它:
@Component("yourRetryPolicy")
public class YourRetryPolicy extends ExceptionClassifierRetryPolicy
{
@PostConstruct
public void init()
{
final SimpleRetryPolicy simpleRetryPolicy = new SimpleRetryPolicy();
simpleRetryPolicy.setMaxAttempts( 3 );
this.setExceptionClassifier( new Classifier<Throwable, RetryPolicy>()
{
@Override
public RetryPolicy classify( Throwable classifiable )
{
if ( classifiable instanceof YourException )
{
return new NeverRetryPolicy();
}
// etc...
return simpleRetryPolicy;
}
});
}
}
然后,您只需在重试模板上设置它:
@Autowired
@Qualifier("yourRetryPolicy")
private YourRetryPolicy yourRetryPolicy;
//...
RetryTemplate retryTemplate = new RetryTemplate();
retryTemplate.setRetryPolicy( yourRetryPolicy );
接受的答案仅处理特定于异常的RetryPolicy实例。对于特定于异常的BackOffPolicy实例,Spring不提供任何开箱即用的功能。幸运的是,它很容易实现。
import org.springframework.classify.Classifier
import org.springframework.classify.ClassifierSupport
import org.springframework.classify.SubclassClassifier
import org.springframework.retry.RetryContext
import org.springframework.retry.backoff.BackOffContext
import org.springframework.retry.backoff.BackOffInterruptedException
import org.springframework.retry.backoff.BackOffPolicy
import org.springframework.retry.backoff.NoBackOffPolicy
class ExceptionClassifierBackoffPolicy implements BackOffPolicy {
private static class ExceptionClassifierBackoffContext implements BackOffContext, BackOffPolicy {
Classifier<Throwable, BackOffPolicy> exceptionClassifier
RetryContext retryContext
Map<BackOffPolicy, BackOffContext> policyContextMap = [:]
ExceptionClassifierBackoffContext(Classifier<Throwable, BackOffPolicy> exceptionClassifier, RetryContext retryContext) {
this.exceptionClassifier = exceptionClassifier
this.retryContext = retryContext
}
@Override
BackOffContext start(RetryContext context) {
return null
}
@Override
void backOff(BackOffContext backOffContext) throws BackOffInterruptedException {
def policy = exceptionClassifier.classify(retryContext.lastThrowable)
def policyContext = policyContextMap.get(policy)
if (!policyContext) {
policyContext = policy.start(retryContext)
policyContextMap.put(policy, policyContext)
}
policy.backOff(policyContext)
}
}
private Classifier<Throwable, BackOffPolicy> exceptionClassifier = new ClassifierSupport<Throwable, BackOffPolicy>(new NoBackOffPolicy());
void setPolicyMap(Map<Class<? extends Throwable>, BackOffPolicy> policyMap) {
exceptionClassifier = new SubclassClassifier<Throwable, BackOffPolicy>(policyMap, new NoBackOffPolicy());
}
@Override
BackOffContext start(RetryContext context) {
return new ExceptionClassifierBackoffContext(exceptionClassifier, context)
}
@Override
void backOff(BackOffContext backOffContext) throws BackOffInterruptedException {
def classifierBackOffContext = (ExceptionClassifierBackoffContext) backOffContext
classifierBackOffContext.backOff(backOffContext)
}
}
然后就是:
BackOffPolicy backOffPolicy = new ExceptionClassifierBackoffPolicy()
def policyMap = [
(RuntimeException): new FixedBackOffPolicy(backOffPeriod: 1000),
(IOException) : new ExponentialRandomBackOffPolicy(initialInterval: 500, maxInterval: 360000, multiplier: 2)
] as Map<Class<? extends Throwable>, BackOffPolicy>
backOffPolicy.policyMap = backoffPolicyMap