在分布式系统和微服务架构中，服务调用失败是不可避免的现象。网络不稳定、服务过载、临时故障等因素都可能导致调用失败。重试机制作为一种处理临时性故障的解决方案，能够有效提高系统的可用性。 ## 一、Spring Retry ### 1. 基本原理 Spring Retry是Spring官方提供的重试框架，作为Spring生态系统的一部分，它通过AOP（面向切面编程）实现了对方法调用的重试能力。当方法调用失败时，Spring Retry会根据配置的策略自动重新执行该方法，直到成功或达到最大重试次数。 Spring Retry的核心组件包括： - **RetryOperations**：定义重试操作的接口 - **RetryTemplate**：RetryOperations的默认实现 - **RetryPolicy**：定义何时进行重试（如最大次数、重试的异常类型等） - **BackOffPolicy**：定义重试间隔策略（如固定间隔、指数退避等） - **RecoveryCallback**：定义最终失败后的恢复策略 ### 2. 集成配置在SpringBoot项目中集成Spring Retry： ``` org.springframework.retry spring-retry org.springframework spring-aspects ``` 然后在启动类上启用重试功能： ``` @SpringBootApplication @EnableRetry public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } ``` ### 3. 使用方法 Spring Retry提供了注解方式和编程方式两种使用方法。 #### 注解方式 ``` @Service public class RemoteServiceClient { private static final Logger logger = LoggerFactory.getLogger(RemoteServiceClient.class); @Retryable(value = {ServiceException.class}, maxAttempts = 3, backoff = @Backoff(delay = 1000, multiplier = 2)) public String callRemoteService(String param) { logger.info("调用远程服务，参数: {}", param); // 模拟调用失败 if (Math.random() > 0.7) { logger.error("服务调用失败"); throw new ServiceException("远程服务暂时不可用"); } return "调用成功: " + param; } @Recover public String recover(ServiceException e, String param) { logger.warn("重试失败，执行恢复方法, 参数: {}", param); return "降级响应: " + param; } } ``` 在上面的例子中： - `@Retryable` 注解定义了需要重试的方法，包括触发重试的异常类型、最大重试次数和退避策略 - `backoff` 属性设置初始延迟1秒，且每次延迟时间翻倍（指数退避） - `@Recover` 注解定义了重试失败后的恢复方法 #### 编程方式 ``` @Service public class RemoteServiceClient { private final RetryTemplate retryTemplate; @Autowired public RemoteServiceClient(RetryTemplate retryTemplate) { this.retryTemplate = retryTemplate; } public String callWithRetry(String param) { return retryTemplate.execute(context -> { // 重试的业务逻辑 if (Math.random() > 0.7) { throw new ServiceException("服务暂时不可用"); } return "调用成功: " + param; }, context -> { // 重试失败后的恢复逻辑 return "降级响应: " + param; }); } @Bean public RetryTemplate retryTemplate() { RetryTemplate template = new RetryTemplate(); // 设置重试策略 SimpleRetryPolicy policy = new SimpleRetryPolicy(); policy.setMaxAttempts(3); // 设置退避策略 ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy(); backOffPolicy.setInitialInterval(1000); backOffPolicy.setMultiplier(2.0); template.setRetryPolicy(policy); template.setBackOffPolicy(backOffPolicy); return template; } } ``` ### 4. 优缺点 **优点** - 与Spring生态系统完美集成 - 提供了丰富的重试策略和配置选项 - 支持注解和编程两种方式，使用灵活 - 可以精确控制重试的异常类型 - 支持声明式事务回滚和提交 **缺点** - 依赖Spring框架 - 代码侵入性相对较强 - 在复杂场景下配置略显复杂 - 与其他容错机制集成需要额外工作 ### 5. 适用场景 - Spring生态系统的项目 - 需要精细控制重试条件和策略的场景 - 与Spring事务结合的业务场景 - 方法级别的重试需求 ## 二、Resilience4j Retry ### 1. 基本原理 Resilience4j是受Netflix Hystrix启发而创建的轻量级容错库，其中Resilience4j Retry模块提供了强大的重试功能。与Spring Retry不同，Resilience4j采用函数式编程风格，使用装饰器模式实现重试功能。 Resilience4j Retry的特点： - 基于函数式接口 - 无外部依赖，轻量级设计 - 可与其他容错机制（如断路器、限流器）无缝集成 - 提供丰富的监控指标 ### 2. 集成配置在SpringBoot项目中集成Resilience4j Retry： ``` io.github.resilience4j resilience4j-spring-boot2 1.7.0 org.springframework.boot spring-boot-starter-aop ``` 配置application.yml： ``` resilience4j.retry: instances: backendService: maxAttempts: 3 waitDuration: 1s enableExponentialBackoff: true exponentialBackoffMultiplier: 2 retryExceptions: - java.io.IOException - java.util.concurrent.TimeoutException ``` ### 3. 使用方法 Resilience4j同样支持注解方式和编程方式。 #### 注解方式 ``` @Service public class BackendService { private static final Logger logger = LoggerFactory.getLogger(BackendService.class); @Retry(name = "backendService", fallbackMethod = "fallbackCall") public String callBackendService(String param) { logger.info("调用后端服务，参数: {}", param); if (Math.random() > 0.7) { logger.error("服务调用失败"); throw new IOException("服务连接失败"); } return "后端服务响应: " + param; } public String fallbackCall(String param, Exception ex) { logger.warn("所有重试失败，执行降级方法，参数: {}", param); return "降级响应: " + param; } } ``` #### 编程方式 ``` @Service public class BackendService { private final RetryRegistry retryRegistry; private final Logger logger = LoggerFactory.getLogger(BackendService.class); @Autowired public BackendService(RetryRegistry retryRegistry) { this.retryRegistry = retryRegistry; } public String executeWithRetry(String param) { // 获取已配置的重试实例 Retry retry = retryRegistry.retry("backendService"); // 创建一个可重试的函数 CheckedFunction0 retryableFunction = Retry.decorateCheckedSupplier( retry, () -> callBackendService(param)); try { // 执行重试函数 return retryableFunction.apply(); } catch (Throwable throwable) { logger.error("重试失败: {}", throwable.getMessage()); return "降级响应: " + param; } } private String callBackendService(String param) throws IOException { logger.info("调用后端服务，参数: {}", param); if (Math.random() > 0.7) { throw new IOException("服务连接失败"); } return "后端服务响应: " + param; } } ``` ### 4. 优缺点 **优点** - 轻量级设计，无外部依赖 - 函数式编程风格，代码简洁 - 提供丰富的监控和统计指标 - 可与断路器、限流器等容错机制无缝集成 - 支持多种高级重试策略 **缺点** - 学习曲线相对陡峭，尤其是函数式概念 - 对于不熟悉函数式编程的开发者可能不够直观 - 某些高级功能需要额外配置 ### 5. 适用场景 - 需要与其他容错机制结合的复杂场景 - 微服务架构中的服务间调用 - 需要详细监控指标的系统 ## 三、Guava Retrying ### 1. 基本原理 Guava Retrying是Google Guava库提供的重试机制，它提供了一个简单灵活的API来实现重试功能。 Guava Retrying通过构建器模式提供了灵活的重试配置，可以自定义重试条件、停止策略、等待策略等。 ### 2. 集成配置在SpringBoot项目中集成Guava Retrying： ``` com.github.rholder guava-retrying 2.0.0 ``` ### 3. 使用方法 Guava Retrying主要采用编程方式使用： ``` @Service public class ExternalServiceClient { private static final Logger logger = LoggerFactory.getLogger(ExternalServiceClient.class); public String callExternalService(String param) { Retryer retryer = RetryerBuilder.newBuilder() .retryIfException() // 发生任何异常时重试 .retryIfResult(result -> result == null) // 结果为null时重试 .withWaitStrategy(WaitStrategies.exponentialWait(1000, 10000, TimeUnit.MILLISECONDS)) // 指数退避 .withStopStrategy(StopStrategies.stopAfterAttempt(3)) // 最多重试3次 .withRetryListener(new RetryListener() { @Override public void onRetry(Attempt attempt) { logger.info("第{}次重试", attempt.getAttemptNumber()); if (attempt.hasException()) { logger.error("异常: {}", attempt.getExceptionCause().getMessage()); } } }) .build(); try { return retryer.call(() -> { logger.info("调用外部服务，参数: {}", param); // 模拟服务调用 if (Math.random() > 0.7) { throw new RuntimeException("服务暂时不可用"); } return "外部服务响应: " + param; }); } catch (RetryException | ExecutionException e) { logger.error("重试失败: {}", e.getMessage()); return "降级响应: " + param; } } } ``` 在SpringBoot中创建可复用的Retryer bean： ``` @Configuration public class RetryConfig { @Bean public Retryer defaultRetryer() { return RetryerBuilder.newBuilder() .retryIfException() .retryIfResult(Predicates.isNull()) .withWaitStrategy(WaitStrategies.exponentialWait(100, 1000, TimeUnit.MILLISECONDS)) .withStopStrategy(StopStrategies.stopAfterAttempt(3)) .build(); } } @Service public class ServiceWithRetry { private final Retryer retryer; @Autowired public ServiceWithRetry(Retryer retryer) { this.retryer = retryer; } public String executeWithRetry(String input) throws ExecutionException, RetryException { return retryer.call(() -> { // 业务逻辑 return processInput(input); }); } } ``` ### 4. 高级特性 Guava Retrying提供了丰富的定制选项： ``` Retryer complexRetryer = RetryerBuilder.newBuilder() // 定制重试条件 .retryIfExceptionOfType(IOException.class) .retryIfException(e -> e instanceof TimeoutException) .retryIfResult(result -> result != null && result.contains("error")) // 定制等待策略 .withWaitStrategy(WaitStrategies.join( WaitStrategies.fixedWait(1000, TimeUnit.MILLISECONDS), WaitStrategies.randomWait(1000, TimeUnit.MILLISECONDS, 2000, TimeUnit.MILLISECONDS) )) // 定制停止策略 .withStopStrategy(StopStrategies.stopAfterDelay(30, TimeUnit.SECONDS)) // 定制阻塞策略 .withBlockStrategy(BlockStrategies.threadSleepStrategy()) .build(); ``` ### 5. 优缺点 **优点** - API简单直观，容易上手 - 高度可定制的重试条件、等待策略和停止策略 - 不依赖Spring框架，可在任何Java项目中使用 **缺点** - 没有注解支持，只能通过编程方式使用 - 缺乏与Spring生态系统的深度集成 - 没有内置的监控和统计功能 - 已停止更新 ### 6. 适用场景 - 简单的重试需求 - 非Spring项目或对Spring依赖较少的项目 - 需要高度自定义重试逻辑的场景 ## 四、Failsafe ### 1. 基本原理 failsafe是一个相对较新的Java重试库，专注于高性能和低延迟场景。它的设计目标是提供一个简单、高效的重试机制，同时保持API的简洁性和使用的便捷性。failsafe支持同步和异步重试，具有灵活的重试策略和最小的依赖。 ### 2. 集成配置在SpringBoot项目中集成failsafe ``` dev.failsafe failsafe 3.3.2 ``` failsafe通常通过dev.failsafe:failsafe库来使用，这是一个现代化的重试和容错库。 ### 3. 使用方法 failsafe主要采用编程方式使用，具有流式API设计 ``` @Service public class FailsafeService { private static final Logger logger = LoggerFactory.getLogger(FailsafeService.class); public String executeWithRetry(String param) { return Failsafe.with( // 配置重试策略 RetryPolicy.builder() .handle(IOException.class, TimeoutException.class) .withMaxRetries(3) .withDelay(Duration.ofSeconds(1)) .withMaxDuration(Duration.ofSeconds(10)) .withBackoff(Duration.ofMillis(100), Duration.ofSeconds(2)) .onRetry(event -> logger.info("第{}次重试，上次异常: {}", event.getAttemptCount(), event.getLastException().getMessage())) .onFailure(event -> logger.error("重试失败，尝试次数: {}, 总耗时: {}ms", event.getAttemptCount(), event.getElapsedTime().toMillis())) .build() ) .get(() -> { logger.info("执行操作，参数: {}", param); // 模拟操作 if (Math.random() > 0.7) { throw new IOException("操作暂时失败"); } return "操作成功: " + param; }); } // 异步重试示例 public CompletableFuture executeWithRetryAsync(String param) { return Failsafe.with( RetryPolicy.builder() .handle(IOException.class) .withMaxRetries(3) .withBackoff(Duration.ofMillis(100), Duration.ofSeconds(1)) .build() ) .getAsync(() -> { logger.info("异步执行操作，参数: {}", param); // 模拟异步操作 if (Math.random() > 0.7) { throw new IOException("异步操作暂时失败"); } return "异步操作成功: " + param; }); } // 带降级的重试示例 public String executeWithFallback(String param) { return Failsafe.with( RetryPolicy.builder() .handle(IOException.class) .withMaxRetries(3) .build(), // 降级策略 Fallback.of(e -> "降级响应: " + param) ) .get(() -> { // 业务逻辑 if (Math.random() > 0.7) { throw new IOException("操作失败"); } return "操作成功: " + param; }); } } ``` 在SpringBoot中创建可复用的RetryPolicy bean ``` @Configuration public class FailsafeConfig { @Bean public RetryPolicy