Spring Retry

山高自有客行路

已于 2025-03-16 17:16:08 修改

阅读量1k

点赞数 29

分类专栏： # Springboot 文章标签： java spring boot

于 2025-03-16 17:02:38 首次发布

本文链接：https://blog.youkuaiyun.com/m0_50742275/article/details/146297634

版权

Springboot 专栏收录该内容

38 篇文章

订阅专栏

1. Spring Retry 的工作原理

内部机制

Spring Retry 主要通过 AOP（面向切面编程）实现重试逻辑。以下是 Spring Retry 的内部工作流程：

AOP 拦截器：当一个方法被标记为需要重试，并且该方法抛出了指定类型的异常时，Spring AOP 拦截器会拦截该调用。
异常捕获：如果该方法抛出指定类型的异常，AOP 拦截器会检查是否符合重试条件。
重试策略判断：根据配置的 RetryPolicy 和 BackOffPolicy，决定是否进行重试以及重试的时间间隔。
等待：根据 BackOffPolicy 等待一段时间。
重试：再次调用目标方法。
恢复逻辑：如果所有重试都失败，则执行 @Recover 注解定义的恢复逻辑。

RetryTemplate 的工作流程

RetryTemplate 是 Spring Retry 的核心类，它负责管理重试逻辑。以下是它的主要步骤：

初始化：根据配置初始化 RetryPolicy 和 BackOffPolicy。
方法调用：尝试调用目标方法。
异常捕获：如果方法抛出异常，检查是否符合重试条件。
等待：根据 BackOffPolicy 等待一段时间。
重试：再次调用目标方法。
恢复：如果所有重试都失败，执行 RecoveryCallback。

2. 核心概念的深度解析

RetryPolicy

RetryPolicy 定义了重试策略，决定了在什么情况下应该重试。Spring 提供了几种内置的 RetryPolicy 实现，同时支持自定义实现。

SimpleRetryPolicy：基于尝试次数的简单策略。

SimpleRetryPolicy policy = new SimpleRetryPolicy();
policy.setMaxAttempts(5); // 设置最大重试次数为5次

TimeoutRetryPolicy：基于时间的策略，允许在指定时间内进行重试。

TimeoutRetryPolicy timeoutPolicy = new TimeoutRetryPolicy();
timeoutPolicy.setTimeout(5000L); // 设置超时时间为5秒

ExceptionClassifierRetryPolicy：根据异常类型决定是否重试。可以通过该策略为不同的异常设置不同的重试策略。

Map<Class<? extends Throwable>, Boolean> retryableExceptions = new HashMap<>();
retryableExceptions.put(IllegalArgumentException.class, true);
retryableExceptions.put(NullPointerException.class, false);

ExceptionClassifierRetryPolicy classifier = new ExceptionClassifierRetryPolicy();
classifier.setPolicyMap(retryableExceptions);

CompositeRetryPolicy：组合多个 RetryPolicy，可以定义复杂的重试策略。

BackOffPolicy

BackOffPolicy 控制每次重试之间的等待时间。常见的策略包括：

FixedBackOffPolicy：固定延迟时间。

FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
backOffPolicy.setBackOffPeriod(2000L); // 设置每次重试之间的延迟时间为2秒

ExponentialBackOffPolicy：指数增长的延迟时间。

ExponentialBackOffPolicy exponentialBackOffPolicy = new ExponentialBackOffPolicy();
exponentialBackOffPolicy.setInitialInterval(1000L); // 初始延迟时间1秒
exponentialBackOffPolicy.setMultiplier(2.0); // 每次重试延迟时间乘以2
exponentialBackOffPolicy.setMaxInterval(10000L); // 最大延迟时间10秒

NoBackOffPolicy：无延迟，立即重试。
UniformRandomBackOffPolicy：随机延迟时间，但有上下限。

RecoveryCallback

当所有重试都失败后执行的回调函数。用于处理最终失败的情况。

@Recover
public void recover(RuntimeException e) {
    System.out.println("All retries failed due to: " + e.getMessage());
}

3. 配置方式

注解方式

主配置类

首先，在主配置类中启用重试功能：

import org.springframework.context.annotation.Configuration;
import org.springframework.retry.annotation.EnableRetry;

@Configuration
@EnableRetry // 启用Spring Retry功能
public class AppConfig {
}

服务层实现

然后，在需要重试的方法上添加 @Retryable 注解，并且可以定义恢复逻辑：

import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    /**
     * 使用@Retryable注解的方法，允许在遇到特定异常时进行重试。
     */
    @Retryable(
        value = {RuntimeException.class}, // 当发生RuntimeException异常时进行重试
        maxAttempts = 4, // 设置最大重试次数为4次
        backoff = @Backoff(delay = 2000) // 设置每次重试之间的延迟时间为2秒
    )
    public void serviceMethod() throws Exception {
        System.out.println("Attempting to execute service method...");
        throw new RuntimeException("Service failure"); // 模拟服务失败
    }

    /**
     * 定义恢复逻辑，当所有重试都失败后执行。
     */
    @Recover // 定义恢复逻辑，当所有重试都失败后执行
    public void recover(RuntimeException e) {
        System.out.println("All retries failed due to: " + e.getMessage());
    }
}

Java 配置类方式

通过 Java 配置类的方式可以手动配置重试模板和拦截器：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.retry.backoff.ExponentialBackOffPolicy;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.support.RetryTemplate;

@Configuration
public class RetryConfig {

    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();

        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
        retryPolicy.setMaxAttempts(4); // 设置最大重试次数为4次
        retryTemplate.setRetryPolicy(retryPolicy);

        ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
        backOffPolicy.setInitialInterval(2000L); // 初始延迟时间2秒
        retryTemplate.setBackOffPolicy(backOffPolicy);

        return retryTemplate;
    }
}

4. 高级用法

自定义 RetryPolicy 和 BackOffPolicy

你可以创建自定义的 RetryPolicy 和 BackOffPolicy，以满足特定需求。例如，创建一个基于业务逻辑的重试策略：

import org.springframework.retry.RetryPolicy;
import org.springframework.retry.RetryContext;

public class CustomRetryPolicy implements RetryPolicy {

    private int attempts = 0;
    private final int maxAttempts = 3;

    @Override
    public boolean canRetry(RetryContext context) {
        attempts++;
        return attempts <= maxAttempts;
    }

    @Override
    public void close(RetryContext context) {
        // 清理资源
    }

    @Override
    public void registerThrowable(RetryContext context, Throwable throwable) {
        // 处理抛出的异常
    }
}

异常分类器

可以使用 ExceptionClassifierRetryPolicy 来根据不同的异常类型应用不同的重试策略：

import org.springframework.retry.policy.ExceptionClassifierRetryPolicy;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.policy.TimeoutRetryPolicy;

@Bean
public RetryTemplate customRetryTemplate() {
    ExceptionClassifierRetryPolicy classifier = new ExceptionClassifierRetryPolicy();
    
    Map<Class<? extends Throwable>, RetryPolicy> policyMap = new HashMap<>();
    policyMap.put(IllegalArgumentException.class, new SimpleRetryPolicy(3));
    policyMap.put(NullPointerException.class, new TimeoutRetryPolicy());

    classifier.setPolicyMap(policyMap);
    
    RetryTemplate template = new RetryTemplate();
    template.setRetryPolicy(classifier);
    
    return template;
}

使用 `RetryTemplate` 手动控制重试

除了使用注解外，你还可以手动使用 RetryTemplate 来控制重试逻辑：

@Autowired
private RetryTemplate retryTemplate;

public void performOperation() {
    retryTemplate.execute(context -> {
        try {
            // 执行业务逻辑
            return null;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    });
}

5. 常见问题及解决方案

1. 重试不生效

确保已经正确启用了 @EnableRetry 注解，并且你的方法上有 @Retryable 注解。同时检查异常类型是否匹配。

2. 事务回滚问题

如果你在重试过程中使用了事务，确保事务能够正确回滚。可以使用 @Transactional 注解来管理事务。

import org.springframework.transaction.annotation.Transactional;

@Service
public class MyService {

    @Transactional
    @Retryable(
        value = {RuntimeException.class},
        maxAttempts = 4,
        backoff = @Backoff(delay = 2000)
    )
    public void serviceMethod() throws Exception {
        // 业务逻辑
    }
}

3. 性能瓶颈

过多的重试可能导致性能瓶颈。确保只在必要的情况下使用重试，并合理设置重试次数和延迟时间。

示例代码详解

示例1：结合 Spring Boot 和 Spring Retry

以下是一个完整的 Spring Boot 应用示例，展示了如何结合 Spring Retry 来处理临时性故障：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.retry.annotation.EnableRetry;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;

@SpringBootApplication
@EnableRetry // 启用Spring Retry功能
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Service
public class MyService {

    @Retryable(
        value = {RuntimeException.class},
        maxAttempts = 4,
        backoff = @Backoff(delay = 2000)
    )
    public void serviceMethod() throws Exception {
        System.out.println("Attempting to execute service method...");
        throw new RuntimeException("Service failure");
    }

    @Recover
    public void recover(RuntimeException e) {
        System.out.println("All retries failed due to: " + e.getMessage());
    }
}

示例2：自定义重试策略

以下是一个自定义重试策略的示例：

import org.springframework.retry.RetryPolicy;
import org.springframework.retry.RetryContext;

public class CustomRetryPolicy implements RetryPolicy {

    private int attempts = 0;
    private final int maxAttempts = 3;

    @Override
    public boolean canRetry(RetryContext context) {
        attempts++;
        return attempts <= maxAttempts;
    }

    @Override
    public void close(RetryContext context) {
        // 清理资源
    }

    @Override
    public void registerThrowable(RetryContext context, Throwable throwable) {
        // 处理抛出的异常
    }
}