
corrección de spring retry 1.3.x con kit especializado para CVE-2026-41710
Este proyecto proporciona soporte de reintentos declarativos para aplicaciones Spring. Se utiliza en Spring Batch, Spring Integration y otros. También se admite el reintento imperativo para un uso explícito.
La versión corrige spring-retry con 2.0.13 para java8 y spring4 o spring5, Para más información, consulte la versión oficial de Spring 2.0.13
Esta sección proporciona una introducción rápida para comenzar con Spring Retry. Incluye un ejemplo declarativo y un ejemplo imperativo.
El siguiente ejemplo muestra cómo usar Spring Retry en su estilo declarativo:
@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
}
}
Este ejemplo llama al método service y, si falla con una RemoteAccessException, reintenta
(por defecto, hasta tres veces), y luego intenta el método recover si no tiene éxito.
Hay varias opciones en los atributos de la anotación @Retryable para incluir y
excluir tipos de excepción, limitar el número de reintentos y establecer la política de retroceso.
El enfoque declarativo para aplicar el manejo de reintentos mediante el uso de la anotación @Retryable mostrada anteriormente tiene una dependencia adicional
en tiempo de ejecución de las clases de AOP. Para obtener detalles sobre cómo resolver esta dependencia en su proyecto, consulte la
sección 'Java Configuration for Retry Proxies'.
El siguiente ejemplo muestra cómo usar Spring Retry en su estilo imperativo (disponible desde la versión 1.3):
RetryTemplate template = RetryTemplate.builder()
.maxAttempts(3)
.fixedBackoff(1000)
.retryOn(RemoteAccessException.class)
.build();
template.execute(ctx -> {
// ... do something
});
Para versiones anteriores a la 1.3, consulte los ejemplos en la sección RetryTemplate.
Spring Retry requiere Java 1.7 y Maven 3.0.5 (o superior). Para compilar, ejecute el siguiente comando de Maven:
$ mvn install
Esta sección analiza las características de Spring Retry y muestra cómo usar su API.
RetryTemplatePara hacer que el procesamiento sea más robusto y menos propenso a fallos, a veces resulta útil
reintentar automáticamente una operación fallida, en caso de que pueda tener éxito en un intento posterior.
Los errores susceptibles a este tipo de tratamiento son de naturaleza transitoria. Por
ejemplo, una llamada remota a un servicio web o a un servicio RMI que falla debido a un problema
de red o a una DeadLockLoserException en una actualización de base de datos puede resolverse tras una
breve espera. Para automatizar el reintento de dichas operaciones, Spring Retry cuenta con la
estrategia RetryOperations. La definición de la interfaz RetryOperations es la siguiente:
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 básica es una interfaz simple que te permite insertar algo de lógica de negocio para que sea reintentada:
public interface RetryCallback<T> {
T doWithRetry(RetryContext context) throws Throwable;
}
Se intenta la callback y, si falla (lanzando una Exception), se reintenta hasta que tenga éxito o hasta que la implementación decida abortar. Existen varios métodos execute sobrecargados en la interfaz RetryOperations, para abordar diversos casos de uso de recuperación cuando se agotan todos los intentos de reintento y para gestionar el estado de reintento, lo que permite a los clientes y a las implementaciones almacenar información entre llamadas (más sobre esto más adelante).
La implementación de propósito general más sencilla de RetryOperations es RetryTemplate. El siguiente ejemplo muestra cómo usarla:
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;
}
});
En el ejemplo anterior, ejecutamos una llamada a un servicio web y devolvemos el resultado al usuario. Si esa llamada falla, se reintenta hasta que se alcanza un tiempo de espera.
Desde la versión 1.3, también está disponible la configuración fluida de RetryTemplate, de la siguiente manera:
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();
RetryContextEl parámetro de método para el RetryCallback es un RetryContext. Muchos callbacks ignoran
el contexto. Sin embargo, si es necesario, puedes usarlo como una bolsa de atributos para almacenar datos durante
la duración de la iteración.
Un RetryContext tiene un contexto padre si hay un reintento anidado en progreso en el mismo
hilo. El contexto padre es ocasionalmente útil para almacenar datos que necesitan ser compartidos
entre llamadas a execute.
RecoveryCallbackCuando se agota un reintento, el RetryOperations puede pasar el control a un callback
diferente: RecoveryCallback. Para usar esta característica, los clientes pueden pasar los callbacks
juntos al mismo método, como muestra el siguiente ejemplo:
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
}
});
Si la lógica de negocio no tiene éxito antes de que la plantilla decida abortar, se le da al cliente la oportunidad de realizar algún procesamiento alternativo mediante la función de recuperación (recovery callback).
En el caso más simple, un reintento es solo un bucle while: el RetryTemplate puede seguir intentándolo hasta que tenga éxito o falle. El RetryContext contiene cierto estado para determinar si reintentar o abortar. Sin embargo, este estado está en la pila, y no hay necesidad de almacenarlo en ningún lugar global. En consecuencia, llamamos a esto "reintento sin estado". La distinción entre reintento sin estado y con estado está contenida en la implementación de RetryPolicy (RetryTemplate puede manejar ambos). En un reintento sin estado, la función de recuperación siempre se ejecuta en el mismo hilo en el que falló al reintentar.