
fix per spring retry 1.3.x con toolkit di nicchia per CVE-2026-41710
Questo progetto fornisce supporto al retry dichiarativo per le applicazioni Spring. È utilizzato in Spring Batch, Spring Integration e altri. È inoltre supportato il retry imperativo per un utilizzo esplicito.
La versione corregge spring-retry con la 2.0.13 per java8 e spring4 o spring5, Per maggiori informazioni, fare riferimento alla versione ufficiale Spring 2.0.13
Questa sezione fornisce una rapida introduzione per iniziare con Spring Retry. Include un esempio dichiarativo e un esempio imperativo.
Il seguente esempio mostra come utilizzare Spring Retry nello stile dichiarativo:
@Configuration
@EnableRetry
public class Application {
@Bean
public Service service() {
return new Service();
}
}
@Service
class Service {
@Retryable(RemoteAccessException.class)
public void service() {
// ... do something
}
@Recover
public void recover(RemoteAccessException e) {
// ... panic
}
}
Questo esempio chiama il metodo service e, se fallisce con una RemoteAccessException, riprova
(per impostazione predefinita, fino a tre volte), e poi prova il metodo recover se non ha successo.
Ci sono varie opzioni negli attributi dell'annotazione @Retryable per includere ed
escludere tipi di eccezione, limitare il numero di tentativi e impostare la politica di backoff.
L'approccio dichiarativo all'applicazione della gestione dei tentativi tramite l'annotazione @Retryable mostrata in precedenza ha una dipendenza aggiuntiva
a runtime dalle classi AOP. Per i dettagli su come risolvere questa dipendenza nel tuo progetto, consulta la
sezione 'Java Configuration for Retry Proxies'.
Il seguente esempio mostra come utilizzare Spring Retry nel suo stile imperativo (disponibile dalla versione 1.3):
RetryTemplate template = RetryTemplate.builder()
.maxAttempts(3)
.fixedBackoff(1000)
.retryOn(RemoteAccessException.class)
.build();
template.execute(ctx -> {
// ... do something
});
Per le versioni precedenti alla 1.3, vedere gli esempi nella sezione RetryTemplate.
Spring Retry richiede Java 1.7 e Maven 3.0.5 (o superiore). Per compilare, eseguire il seguente comando Maven:
$ mvn install
Questa sezione illustra le funzionalità di Spring Retry e mostra come utilizzare la sua API.
RetryTemplatePer rendere l'elaborazione più robusta e meno soggetta a errori, a volte è utile
ritentare automaticamente un'operazione fallita, nel caso in cui possa riuscire in un tentativo successivo.
Gli errori suscettibili a questo tipo di trattamento sono di natura transitoria. Ad
esempio, una chiamata remota a un servizio web o a un servizio RMI che fallisce a causa di un problema
di rete o di una DeadLockLoserException in un aggiornamento del database può risolversi dopo una
breve attesa. Per automatizzare il nuovo tentativo di tali operazioni, Spring Retry dispone della
strategia RetryOperations. La definizione dell'interfaccia RetryOperations è la seguente:
public interface RetryOperations {
<T> T execute(RetryCallback<T> retryCallback) throws Exception;
<T> T execute(RetryCallback<T> retryCallback, RecoveryCallback<T> recoveryCallback)
throws Exception;
<T> T execute(RetryCallback<T> retryCallback, RetryState retryState)
throws Exception, ExhaustedRetryException;
<T> T execute(RetryCallback<T> retryCallback, RecoveryCallback<T> recoveryCallback,
RetryState retryState) throws Exception;
}
La callback di base è un'interfaccia semplice che consente di inserire una logica di business da ritentare:
public interface RetryCallback<T> {
T doWithRetry(RetryContext context) throws Throwable;
}
Il callback viene tentato e, se fallisce (generando un'Exception), viene ritentato
finché non ha successo o finché l'implementazione decide di interrompere. Esistono diversi
metodi execute sovraccaricati nell'interfaccia RetryOperations, per gestire vari
casi d'uso di recupero quando tutti i tentativi di retry sono esauriti e per gestire lo stato di retry, che
consente ai client e alle implementazioni di memorizzare informazioni tra le chiamate (ne parleremo più avanti).
L'implementazione generale più semplice di RetryOperations è RetryTemplate.
L'esempio seguente mostra come utilizzarla:
RetryTemplate template = new RetryTemplate();
TimeoutRetryPolicy policy = new TimeoutRetryPolicy();
policy.setTimeout(30000L);
template.setRetryPolicy(policy);
Foo result = template.execute(new RetryCallback<Foo>() {
public Foo doWithRetry(RetryContext context) {
// Do stuff that might fail, e.g. webservice operation
return result;
}
});
Nell'esempio precedente, eseguiamo una chiamata a un servizio web e restituiamo il risultato all'utente. Se tale chiamata fallisce, viene ritentata fino al raggiungimento di un timeout.
Dalla versione 1.3, è disponibile anche la configurazione fluente di RetryTemplate, come segue:
RetryTemplate.builder()
.maxAttempts(10)
.exponentialBackoff(100, 2, 10000)
.retryOn(IOException.class)
.traversingCauses()
.build();
RetryTemplate.builder()
.fixedBackoff(10)
.withinMillis(3000)
.build();
RetryTemplate.builder()
.infiniteRetry()
.retryOn(IOException.class)
.uniformRandomBackoff(1000, 3000)
.build();
RetryContextIl parametro del metodo per RetryCallback è un RetryContext. Molti callback ignorano
il contesto. Tuttavia, se necessario, è possibile utilizzarlo come contenitore di attributi per memorizzare dati per
la durata dell'iterazione.
Un RetryContext ha un contesto padre se è in corso un retry annidato nello stesso
thread. Il contesto padre è talvolta utile per memorizzare dati che devono essere condivisi
tra le chiamate a execute.
RecoveryCallbackQuando i tentativi di retry sono esauriti, RetryOperations può passare il controllo a un diverso
callback: RecoveryCallback. Per utilizzare questa funzionalità, i client possono passare i callback
insieme allo stesso metodo, come mostra l'esempio seguente:
Foo foo = template.execute(new RetryCallback<Foo>() {
public Foo doWithRetry(RetryContext context) {
// business logic here
},
new RecoveryCallback<Foo>() {
Foo recover(RetryContext context) throws Exception {
// recover logic here
}
});
Se la logica di business non ha successo prima che il template decida di interrompere, al client viene data la possibilità di eseguire un'elaborazione alternativa tramite il callback di recovery.
Nel caso più semplice, un retry è solo un ciclo while: il RetryTemplate può continuare a tentare
finché non riesce o fallisce. Il RetryContext contiene uno stato per determinare
se ritentare o interrompere. Tuttavia, questo stato si trova sullo stack e non c'è bisogno di
memorizzarlo globalmente. Di conseguenza, lo chiamiamo "retry senza stato". La distinzione
tra retry senza stato e con stato è contenuta nell'implementazione di RetryPolicy
(RetryTemplate può gestire entrambi). In un retry senza stato, il callback viene sempre eseguito
nello stesso thread in cui è fallito al momento del retry.