Spring Retry ist ein von Spring bereitgestellter Wiederholungsmechanismus, der die Konfiguration von Anmerkungen unterstützt und Wiederholungsvorgänge ohne Eintauchen in Code ausführen kann. Es ist auch sehr einfach zu bedienen.Lassen Sie uns zunächst die grundlegenden Konzepte von Spring Retry verstehen.
1. Grundbegriffe:
String Retry unterstützt die normale Verwendung und die Verwendung von Anmerkungen (die Schreibmethode wird unten gezeigt). Konzentrieren wir uns auf die Verwendung von Anmerkungen.Hier entwerfen wir hauptsächlich drei Anmerkungen, wie folgt:
@EnableRetry : Der Startklasse hinzugefügt, um anzuzeigen, dass die Wiederholung aktiviert ist.
@Retryable: Diese Methode wurde der Methode hinzugefügt, die wiederholt werden muss, und versucht es erneut, wenn eine Ausnahme auftritt.
@Recover: Es wird für die Verarbeitungsmethode verwendet, nachdem die @Retryable-Wiederholung fehlgeschlagen ist.
String Retry hat 7 Wiederholungsstrategien, wie folgt:
NeverRetryPolicy: RetryCallback darf nur einmal aufgerufen werden, und es sind keine Wiederholungen zulässig.
AlwaysRetryPolicy: Lässt unendliche Wiederholungen bis zum Erfolg zu. Eine falsche Logik in dieser Methode führt zu einer Endlosschleife.
SimpleRetryPolicy: Richtlinie für eine feste Anzahl von Wiederholungen, die standardmäßige maximale Anzahl von Wiederholungen beträgt 3 Mal, die Richtlinie, die standardmäßig von RetryTemplate verwendet wird.
TimeoutRetryPolicy: Timeout-Wiederholungsrichtlinie, das Standardtimeout ist 1 Sekunde, und Wiederholungen sind innerhalb des angegebenen Timeouts zulässig.
ExceptionClassifierRetryPolicy: Legen Sie Wiederholungsrichtlinien für verschiedene Ausnahmen fest, ähnlich wie bei kombinierten Wiederholungsrichtlinien, der Unterschied besteht darin, dass hier nur Wiederholungen von verschiedenen Ausnahmen unterschieden werden.
CircuitBreakerRetryPolicy: Eine Wiederholungsrichtlinie mit Trennschalterfunktion, die 3 Parameter openTimeout, resetTimeout und Delegate festlegen muss.
CompositeRetryPolicy: Richtlinie für zusammengesetzte Wiederholungen, es gibt zwei Kombinationen, die optimistische Richtlinie für zusammengesetzte Wiederholungen bedeutet, dass Sie es wiederholen können, solange eine Richtlinie dies zulässt, und die pessimistische Richtlinie für zusammengesetzte Wiederholungen bedeutet, dass Sie es erneut versuchen können, solange eine Richtlinie dies nicht zulässt , aber unabhängig davon, welche Kombination verwendet wird, wird jede Strategie in der Kombination ausgeführt.
String Retry hat 5 Wiederholungs-Fallback-Strategien, wie folgt:
NoBackOffPolicy: Keine Backoff-Algorithmus-Richtlinie, versuchen Sie es bei jedem erneuten Versuch sofort.
FixedBackOffPolicy: Eine Backoff-Richtlinie für eine feste Zeit. Die Parameter sleeper und backOffPeriod müssen gesetzt werden. sleeper gibt die Warterichtlinie an. Der Standardwert ist Thread.sleep, was bedeutet, dass der Thread schläft. backOffPeriod gibt die Ruhezeit an, und der Standardwert ist 1 Sekunde.
UniformRandomBackOffPolicy: zufällige Backoff-Richtlinie, es muss Sleeper, minBackOffPeriod und maxBackOffPeriod festgelegt werden, diese Richtlinie nimmt eine zufällige Ruhezeit zwischen minBackOffPeriod und maxBackOffPeriod, minBackOffPeriod ist standardmäßig auf 500 Millisekunden, maxBackOffPeriod standardmäßig auf 1500 Millisekunden eingestellt.
ExponentialBackOffPolicy: Exponentielle Backoff-Richtlinie, Sie müssen die Parameter sleeper, initialInterval, maxInterval und multiplier festlegen, initialInterval gibt die anfängliche Ruhezeit an, der Standardwert ist 100 Millisekunden, maxInterval gibt die maximale Ruhezeit an, der Standardwert ist 30 Sekunden, multiplier gibt den Multiplikator an , das heißt, die nächste Schlafzeit ist der aktuelle Schlafzeitmultiplikator.
ExponentialRandomBackOffPolicy: Zufällige exponentielle Backoff-Richtlinie, die einen zufälligen Multiplikator einführt, kann einen zufälligen Multiplikator-Backoff realisieren.
2. Verwendung von Anmerkungen:
Wenn Sie String Retry verwenden möchten, müssen Sie zuerst das Rack-Paket einführen, dann die Annotation @EnableRetry zur Startklasse hinzufügen und schließlich die Annotation @Retryable zu der Methode hinzufügen, die wiederholt werden muss, um den Wiederholungsvorgang auszuführen Der Code lautet wie folgt (beachten Sie die Wiederherstellungsmethode Hinweis, da sie sonst möglicherweise nicht wirksam wird ):
----- ----- 引入架包 ----- -----
<dependency>
<groupId>org.springframework.retry</groupId>
<artifactId>spring-retry</artifactId>
<version>1.1.5.RELEASE</version>
</dependency>
----- ----- 具体代码 ----- -----
/**
* 方式2
* <p>
* 1. RemoteAccessException的异常才重试
* 2. @Backoff(delay = 2000L,multiplier = 2)) 表示第一次间隔2秒，以后都是次数的2倍，也就是第二次4秒，第三次6秒
*
* @return
*/
@Retryable(value = {RemoteAccessException.class}, maxAttempts = 3, backoff = @Backoff(delay = 2000L, multiplier = 2))
public Boolean retry2(String param) {
return RetryTask.task(param);
}
/**
* recover 机制：达到最大重试次数，或抛出了一个没有指定进行重试的异常，调用此方法
* <p>
* Tips：
* 1. 返回值必须和被重试的函数返回值一致
* 2. 参数中除了第一个是触发的异常外，后面的参数需要和被重试函数的参数列表一致
* 3. @Recover注解与@Retryable注解在通过方法中
*
* @param e
* @param param
* @return
*/
@Recover
public Boolean recover(Exception e, String param) {
log.error("达到最大重试次数,或抛出了一个没有指定进行重试的异常:{},请求参数:{}", e, param);
return false;
}
----- ----- 重试任务 ----- -----
public class RetryTask {
/**
* 具体任务
*
* @param param
* @return
*/
public static Boolean task(String param) {
int num = RandomUtils.nextInt(0, 9);
log.info("请求参数:[{}],生成随机数:[{}]", param, num);
if (num == 0) {
log.info("模拟抛出参数异常");
throw new IllegalArgumentException("参数异常");
} else if (num == 1) {
log.info("模拟执行成功");
return true;
} else if (num == 2) {
log.info("模拟执行失败");
return false;
} else {
log.info("模拟抛出特定异常");
throw new RemoteAccessException("抛出远程访问异常");
}
}
}
3. Gemeinsame Art zu verwenden:
Die Verwendung der üblichen Methode von String Retry ist ebenfalls sehr einfach, wie folgt:
public Boolean retry1() {
RetryTemplate retryTemplate = new RetryTemplate();
// 设置重试回退操作策略，主要设置重试间隔时间
FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
// 重试间隔时间ms，默认1000ms
backOffPolicy.setBackOffPeriod(1000L);
retryTemplate.setBackOffPolicy(backOffPolicy);
// 设置重试策略，主要设置：重试异常类型、重试次数，默认3次
Map<Class<? extends Throwable>, Boolean> exceptionMap = new HashMap<>();
exceptionMap.put(RemoteAccessException.class, true);
SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(3, exceptionMap);
retryTemplate.setRetryPolicy(retryPolicy);
// 执行
Boolean execute = retryTemplate.execute(
// 重试回调
retryCallback -> {
boolean result = RetryTask.task("retry1");
log.info("调用的结果:{}", result);
return result;
},
// 在所有尝试都用尽后进行有状态重试的回调
recoveryCallback -> {
log.info("已达到最大重试次数 或 或抛出了不重试的异常 后，进行一些操作");
return false;
}
);
log.info("执行结果:{}", execute);
return execute;
}