在当今云原生架构和微服务盛行的时代，分布式系统已成为企业应用的主流架构模式。然而，分布式环境下的服务调用常常面临网络不稳定、服务暂时不可用、数据库连接超时等临时性故障。这些故障通常是暂时性的，经过短暂等待后可能会自动恢复。
在这种情况下，简单粗暴地向用户返回错误并不是最佳选择。相反，通过实现优雅的重试策略，可以显著提高系统的弹性和可靠性。Spring Retry是Spring生态系统中的一个强大工具，专为解决这类问题而设计。
本文将深入探讨Spring Retry的实现原理、核心功能和最佳实践，帮助开发者在分布式系统中构建更为稳健的重试机制。
为什么需要重试机制？
在讨论具体的实现之前，我们先来理解为什么在分布式系统中需要重试机制：
- 临时性故障处理：网络抖动、服务临时不可用等问题通常是短暂的，通过重试可以避免向用户返回不必要的错误。
- 提高系统弹性：重试机制是构建弹性系统的关键组件，可以帮助系统在面对各种故障时保持稳定运行。
- 减少人工干预：自动重试可以解决许多临时性问题，减少人工干预的需求。
- 提升用户体验：对于用户而言，系统可以自动处理临时性故障，避免用户遇到不必要的错误提示。
然而，重试策略如果实现不当，可能会带来一系列问题：
- 资源浪费：过度重试会消耗额外的系统资源
- 雪崩效应：在系统已经过载的情况下，大量重试可能会加剧系统负担
- 数据不一致：对于非幂等操作的重试可能导致数据错误
因此，我们需要一个成熟、可配置且功能完善的框架来处理重试逻辑，这就是Spring Retry的价值所在。
Spring Retry简介
Spring Retry是Spring生态系统的一部分，专门提供声明式重试支持。它提供了一系列注解和编程接口，使开发者能够以最小的侵入性实现复杂的重试逻辑。
核心功能特性
- 声明式重试：通过简单的注解配置实现重试逻辑
- 多种重试策略：支持固定间隔、指数退避等多种重试策略
- 重试模板：提供编程式的重试模板，适用于复杂场景
- 回退机制：当重试失败后，可以指定回退方法
- 重试监听：提供重试过程中的各种事件监听
- 与Spring整合：无缝集成Spring事务管理和AOP
添加依赖
首先，我们需要在项目中添加Spring Retry依赖：
<!-- Maven -->
<dependency>
<groupId>org.springframework.retry</groupId>
<artifactId>spring-retry</artifactId>
<version>2.0.2</version>
</dependency>
<!-- 由于Spring Retry基于AOP，我们还需要添加Spring AOP依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
</dependency>
<!-- 使用AspectJ作为AOP实现 -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
</dependency>
对于Gradle项目：
// Gradle
implementation 'org.springframework.retry:spring-retry:2.0.2'
implementation 'org.springframework:spring-aop'
implementation 'org.aspectj:aspectjweaver'
启用Spring Retry
要在Spring Boot应用中启用Spring Retry，我们需要在主配置类上添加@EnableRetry注解：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.retry.annotation.EnableRetry;
@SpringBootApplication
@EnableRetry
public class RetryDemoApplication {
public static void main(String[] args) {
SpringApplication.run(RetryDemoApplication.class, args);
}
}
声明式重试：基于注解的重试配置
Spring Retry的一大特色是支持声明式重试，通过简单的注解就可以实现复杂的重试逻辑。以下是核心注解及其使用方法：
@Retryable注解
@Retryable是最基本的重试注解，用于标记需要进行重试的方法：
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
@Service
public class RemoteServiceClient {
@Retryable(value = {ServiceTemporarilyUnavailableException.class},
maxAttempts = 3,
backoff = @Backoff(delay = 1000, multiplier = 2))
public String callRemoteService(String param) {
// 调用远程服务的逻辑
// 可能抛出ServiceTemporarilyUnavailableException异常
return remoteServiceCall(param);
}
private String remoteServiceCall(String param) {
// 实际的远程调用逻辑
if (/* 模拟远程服务暂时不可用 */) {
throw new ServiceTemporarilyUnavailableException("Service temporarily unavailable");
}
return "Response from remote service";
}
}
@Retryable注解的主要参数说明：
value或include：指定触发重试的异常类型exclude：指定不触发重试的异常类型maxAttempts：最大重试次数（包括第一次调用）backoff：重试间隔配置，通过@Backoff注解指定
@Backoff注解
@Backoff注解用于配置重试的间隔策略：
@Backoff(delay = 1000, multiplier = 2, maxDelay = 10000)
参数说明：
delay：初始重试延迟时间（毫秒）multiplier：延迟倍数，用于指数退避策略maxDelay：最大延迟时间（毫秒）random：是否添加随机因子（避免重试风暴）
当multiplier大于1时，实现了指数退避（Exponential Backoff）策略，即每次重试的间隔时间会逐渐增加。例如，初始延迟1秒，倍数为2，则重试间隔依次为：1秒、2秒、4秒…
@Recover注解
当重试次数耗尽后，如果操作仍然失败，我们可能需要一个回退方法来处理最终的失败情况。这时可以使用@Recover注解：
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
@Service
public class RemoteServiceClient {
@Retryable(value = {ServiceTemporarilyUnavailableException.class},
maxAttempts = 3,
backoff = @Backoff(delay = 1000, multiplier = 2))
public String callRemoteService(String param) {
// 调用可能失败的远程服务
System.out.println("Calling remote service with param: " + param);
if (Math.random() > 0.7) {
throw new ServiceTemporarilyUnavailableException("Service down temporarily");
}
return "Remote service response for: " + param;
}
@Recover
public String recoverFromFailure(ServiceTemporarilyUnavailableException e, String param) {
// 记录失败日志
System.err.println("All retries failed. Last error: " + e.getMessage());
// 返回备选结果或执行替代逻辑
return "Fallback response for: " + param;
}
}
@Recover方法的要求：
- 方法参数的第一个必须是触发重试的异常类型
- 后续参数必须与@Retryable方法的参数列表一致
- 返回类型必须与@Retryable方法的返回类型一致或是其子类
@CircuitBreaker注解
除了基本的重试功能，Spring Retry还提供了断路器模式的实现，可以在服务持续失败时”熔断”请求，防止系统资源被耗尽：
import org.springframework.retry.annotation.CircuitBreaker;
import org.springframework.stereotype.Service;
@Service
public class CircuitBreakerService {
@CircuitBreaker(value = Exception.class,
maxAttempts = 3,
openTimeout = 10000,
resetTimeout = 30000)
public String callWithCircuitBreaker(String param) {
// 可能失败的服务调用
if (Math.random() > 0.7) {
throw new RuntimeException("Service call failed");
}
return "Service response: " + param;
}
@Recover
public String fallback(Exception e, String param) {
return "Circuit open, using fallback for: " + param;
}
}
@CircuitBreaker参数说明：
value：触发断路器的异常类型maxAttempts：断路器开启前的最大失败次数openTimeout：断路器打开的超时时间（毫秒）resetTimeout：断路器重置的超时时间（毫秒）
当失败次数达到maxAttempts时，断路器会打开，在openTimeout时间内直接拒绝所有请求。经过resetTimeout时间后，断路器会尝试半开状态，允许一部分请求通过以检测服务是否恢复。
编程式重试：RetryTemplate的使用
除了声明式重试，Spring Retry还提供了更为灵活的编程式重试接口——RetryTemplate。这在需要动态配置重试策略或处理更复杂场景时特别有用。
基本使用
import org.springframework.retry.RetryCallback;
import org.springframework.retry.RetryContext;
import org.springframework.retry.support.RetryTemplate;
import org.springframework.stereotype.Service;
@Service
public class RetryTemplateService {
private final RetryTemplate retryTemplate;
public RetryTemplateService() {
this.retryTemplate = RetryTemplate.builder()
.maxAttempts(3)
.fixedBackoff(1000)
.retryOn(IOException.class)
.build();
}
public String executeWithRetry(final String input) {
return retryTemplate.execute(
new RetryCallback<String, RuntimeException>() {
@Override
public String doWithRetry(RetryContext context) {
// 显示当前重试次数
System.out.println("Retry count: " + context.getRetryCount());
// 执行可能失败的操作
return callRemoteService(input);
}
}
);
}
private String callRemoteService(String input) {
// 模拟远程调用，有时会失败
if (Math.random() > 0.7) {
throw new IOException("Network error occurred");
}
return "Response for: " + input;
}
}
自定义重试策略
RetryTemplate提供了多种重试策略的构建方式：
// 使用构建器模式创建RetryTemplate
RetryTemplate template = RetryTemplate.builder()
// 固定间隔重试
.fixedBackoff(1000)
// 或使用指数退避
//.exponentialBackoff(1000, 2, 10000)
// 设置最大重试次数
.maxAttempts(3)
// 指定需要重试的异常
.retryOn(IOException.class, TimeoutException.class)
// 指定不需要重试的异常
.notRetryOn(IllegalArgumentException.class)
// 构建模板
.build();
高级配置：RetryPolicy和BackOffPolicy
对于更复杂的场景，可以直接配置RetryPolicy和BackOffPolicy：
import org.springframework.retry.backoff.ExponentialBackOffPolicy;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.support.RetryTemplate;
import java.util.HashMap;
import java.util.Map;
// 创建RetryTemplate并配置策略
RetryTemplate template = new RetryTemplate();
// 配置重试策略
Map<Class<? extends Throwable>, Boolean> retryableExceptions = new HashMap<>();
retryableExceptions.put(IOException.class, true);
retryableExceptions.put(TimeoutException.class, true);
SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(3, retryableExceptions);
template.setRetryPolicy(retryPolicy);
// 配置退避策略
ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
backOffPolicy.setInitialInterval(1000); // 初始间隔1秒
backOffPolicy.setMultiplier(2); // 间隔倍数
backOffPolicy.setMaxInterval(10000); // 最大间隔10秒
template.setBackOffPolicy(backOffPolicy);
设置重试回调
RetryTemplate还支持设置各种回调，用于在重试过程中的不同阶段执行自定义逻辑：
import org.springframework.retry.RetryCallback;
import org.springframework.retry.RetryContext;
import org.springframework.retry.RetryListener;
import org.springframework.retry.listener.RetryListenerSupport;
import org.springframework.retry.support.RetryTemplate;
// 创建RetryTemplate
RetryTemplate template = new RetryTemplate();
// 添加重试监听器
template.registerListener(new RetryListenerSupport() {
@Override
public <T, E extends Throwable> void onError(RetryContext context,
RetryCallback<T, E> callback,
Throwable throwable) {
System.out.println("Retry error occurred: " + throwable.getMessage());
System.out.println("Retry count: " + context.getRetryCount());
}
@Override
public <T, E extends Throwable> void close(RetryContext context,
RetryCallback<T, E> callback,
Throwable throwable) {
if (throwable != null) {
System.out.println("All retries failed with: " + throwable.getMessage());
} else {
System.out.println("Retry successful on attempt: " + context.getRetryCount());
}
}
});
// 执行重试逻辑
String result = template.execute(context -> {
// 业务逻辑
return callRemoteService();
});
实际应用案例
接下来，我们将通过几个实际案例，展示Spring Retry在不同场景下的应用。
案例1：HTTP远程服务调用重试
在微服务架构中，服务间的HTTP调用是最常见的场景之一，也是最需要重试机制的场景：
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
import org.springframework.web.client.ResourceAccessException;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestTemplate;
@Service
public class RemoteApiService {
private final RestTemplate restTemplate;
public RemoteApiService(RestTemplate restTemplate) {
this.restTemplate = restTemplate;
}
@Retryable(
value = {ResourceAccessException.class, RestClientException.class},
maxAttempts = 3,
backoff = @Backoff(delay = 1000, multiplier = 2, maxDelay = 5000)
)
public String fetchDataFromRemoteApi(String resourceId) {
String url = "https://api.example.com/resources/" + resourceId;
System.out.println("Calling remote API: " + url);
// 执行HTTP调用，可能抛出网络相关异常
return restTemplate.getForObject(url, String.class);
}
@Recover
public String recoverFetchData(Exception e, String resourceId) {
System.err.println("All retries failed for resource: " + resourceId);
System.err.println("Last error: " + e.getMessage());
// 返回缓存数据或默认值
return "Cached or default data for resource: " + resourceId;
}
}
案例2：数据库操作重试
数据库操作中的死锁、连接超时等问题也是重试的典型场景：
import org.springframework.dao.DataAccessException;
import org.springframework.dao.TransientDataAccessException;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
@Repository
public class OrderRepository {
private final JdbcTemplate jdbcTemplate;
public OrderRepository(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Transactional
@Retryable(
value = {TransientDataAccessException.class},
maxAttempts = 3,
backoff = @Backoff(delay = 500, multiplier = 1.5)
)
public void saveOrder(Order order) {
try {
// 插入订单数据
jdbcTemplate.update(
"INSERT INTO orders (id, customer_id, amount, status) VALUES (?, ?, ?, ?)",
order.getId(), order.getCustomerId(), order.getAmount(), order.getStatus()
);
// 插入订单项
for (OrderItem item : order.getItems()) {
jdbcTemplate.update(
"INSERT INTO order_items (order_id, product_id, quantity, price) VALUES (?, ?, ?, ?)",
order.getId(), item.getProductId(), item.getQuantity(), item.getPrice()
);
}
} catch (DataAccessException e) {
System.err.println("Database error: " + e.getMessage());
throw e; // 重新抛出异常以触发重试
}
}
}
案例3：消息队列重试
在处理消息队列消息时，也常常需要重试机制来处理临时性的处理失败：
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
@Service
public class OrderProcessingService {
private final PaymentService paymentService;
private final InventoryService inventoryService;
public OrderProcessingService(PaymentService paymentService, InventoryService inventoryService) {
this.paymentService = paymentService;
this.inventoryService = inventoryService;
}
@RabbitListener(queues = "order.processing")
@Retryable(
value = {PaymentServiceException.class, InventoryServiceException.class},
maxAttempts = 5,
backoff = @Backoff(delay = 1000, multiplier = 2, random = true)
)
public void processOrder(OrderMessage orderMessage) {
System.out.println("Processing order: " + orderMessage.getOrderId());
// 处理支付
paymentService.processPayment(orderMessage.getPaymentDetails());
// 处理库存
inventoryService.reserveInventory(orderMessage.getItems());
System.out.println("Order processed successfully: " + orderMessage.getOrderId());
}
@Recover
public void handleOrderProcessingFailure(Exception e, OrderMessage orderMessage) {
System.err.println("Failed to process order: " + orderMessage.getOrderId());
System.err.println("Error: " + e.getMessage());
// 将订单移至死信队列或标记为需要人工处理
// deadLetterQueue.send(orderMessage);
}
}
与Spring Boot的集成
在Spring Boot应用中，我们可以通过配置属性来定制Spring Retry的行为。例如，可以配置默认的重试策略和超时时间：
# application.yml
spring:
retry:
enabled: true
max-attempts: 3
initial-interval: 1000
multiplier: 1.5
max-interval: 10000
如果需要更复杂的配置，可以通过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(3);
retryTemplate.setRetryPolicy(retryPolicy);
// 配置退避策略
ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
backOffPolicy.setInitialInterval(1000);
backOffPolicy.setMultiplier(2);
backOffPolicy.setMaxInterval(10000);
retryTemplate.setBackOffPolicy(backOffPolicy);
return retryTemplate;
}
}
最佳实践与注意事项
在使用Spring Retry时，以下最佳实践和注意事项可以帮助你更好地设计重试策略：
1. 识别适合重试的操作
并非所有操作都适合重试。一般来说，满足以下条件的操作适合使用重试机制：
- 幂等操作：多次执行不会产生副作用的操作（如读取操作）
- 临时性故障：由网络抖动、资源竞争等导致的临时性故障
- 有合理成功概率：重试后有较高概率成功的操作
不适合重试的操作包括：
- 非幂等操作（例如没有去重机制的支付）
- 因客户端错误（如参数错误）导致的失败
- 系统性故障（如配置错误）导致的失败
2. 合理设置重试参数
- 重试次数：根据操作的重要性和成功概率来设置。通常3-5次是合理的范围。
- 重试间隔：初始间隔通常设为几百毫秒到1秒，视操作的耗时而定。
- 指数退避：对于涉及外部资源的操作，建议使用指数退避策略，避免对目标服务造成压力。
- 随机因子：添加随机因子可以避免多个客户端同时重试导致的”重试风暴”。
3. 正确处理异常
- 明确区分哪些异常需要重试，哪些不需要
- 对于不同类型的异常，可能需要不同的重试策略
- 重试耗尽后，提供合理的回退策略
4. 监控与记录
- 记录每次重试的情况，包括异常信息和重试次数
- 监控重试成功率和回退方法的调用频率
- 对频繁重试的操作进行分析，找出根本原因
5. 避免重试风暴
在分布式系统中，如果多个服务同时进行重试，可能会导致”重试风暴”，进一步加剧系统负担。缓解措施包括：
- 使用随机退避时间
- 实现断路器模式
- 设置合理的超时时间
6. 考虑业务影响
在设计重试策略时，需要考虑重试对业务的影响：
- 重试会增加操作的延迟，是否可接受？
- 重试失败后，如何保证数据一致性？
- 是否需要通知用户操作正在重试？
进阶主题：分布式重试与补偿事务
在某些复杂场景下，单纯的即时重试可能不足以解决问题。此时，我们可能需要考虑分布式重试和补偿事务模式：
分布式重试队列
对于一些可以异步处理的操作，可以将失败的任务放入专门的重试队列中，由独立的重试处理服务来处理：
@Service
public class OrderProcessingService {
private final JmsTemplate jmsTemplate;
@Transactional
public void processOrder(Order order) {
try {
// 处理订单逻辑
processOrderInternally(order);
} catch (Exception e) {
// 将订单放入重试队列
RetryTask retryTask = new RetryTask(
"processOrder",
order,
System.currentTimeMillis(),
0 // 初始重试次数
);
jmsTemplate.convertAndSend("retry.queue", retryTask);
// 提交事务以确保消息被发送
throw new OrderProcessingRetryException("Order processing failed, scheduled for retry", e);
}
}
}
// 重试处理服务
@Service
public class RetryTaskProcessor {
private final OrderService orderService;
private final JmsTemplate jmsTemplate;
@JmsListener(destination = "retry.queue")
public void processRetryTask(RetryTask task) {
if (task.getRetryCount() >= 5) {
// 重试次数耗尽，移至死信队列
jmsTemplate.convertAndSend("retry.deadletter", task);
return;
}
try {
// 根据任务类型执行不同的处理逻辑
if ("processOrder".equals(task.getTaskType())) {
Order order = (Order) task.getPayload();
orderService.processOrder(order);
}
// 处理成功，不需要再重试
} catch (Exception e) {
// 增加重试计数
task.setRetryCount(task.getRetryCount() + 1);
// 计算下次重试时间（指数退避）
long delay = (long) (1000 * Math.pow(2, task.getRetryCount()));
// 重新入队，延迟执行
jmsTemplate.convertAndSend("retry.queue", task, message -> {
message.setLongProperty(
ScheduledMessage.AMQ_SCHEDULED_DELAY,
delay
);
return message;
});
}
}
}
补偿事务模式
对于分布式事务，可以采用补偿事务模式（也称为Saga模式）来处理失败的子事务：
@Service
public class OrderSagaCoordinator {
private final PaymentService paymentService;
private final InventoryService inventoryService;
private final ShippingService shippingService;
private final TransactionTemplate transactionTemplate;
public OrderSagaCoordinator(PaymentService paymentService,
InventoryService inventoryService,
ShippingService shippingService,
PlatformTransactionManager transactionManager) {
this.paymentService = paymentService;
this.inventoryService = inventoryService;
this.shippingService = shippingService;
this.transactionTemplate = new TransactionTemplate(transactionManager);
}
@Transactional
public void processOrder(Order order) {
// 记录Saga状态
SagaState sagaState = createInitialSagaState(order);
try {
// 第一步：处理支付
if (!sagaState.isPaymentProcessed()) {
processPayment(order, sagaState);
}
// 第二步：扣减库存
if (!sagaState.isInventoryReserved()) {
reserveInventory(order, sagaState);
}
// 第三步：创建配送单
if (!sagaState.isShippingCreated()) {
createShipping(order, sagaState);
}
// 完成订单处理
completeOrderProcessing(order, sagaState);
} catch (Exception e) {
// 处理失败，记录状态，稍后重试或补偿
handleFailure(order, sagaState, e);
}
}
private void processPayment(Order order, SagaState sagaState) {
try {
// 处理支付
PaymentResult result = paymentService.processPayment(order.getPaymentDetails());
// 更新Saga状态
sagaState.setPaymentProcessed(true);
sagaState.setPaymentId(result.getPaymentId());
updateSagaState(sagaState);
} catch (Exception e) {
throw new SagaExecutionException("Payment processing failed", e);
}
}
private void reserveInventory(Order order, SagaState sagaState) {
try {
// 扣减库存
InventoryResult result = inventoryService.reserveItems(order.getItems());
// 更新Saga状态
sagaState.setInventoryReserved(true);
sagaState.setInventoryReservationId(result.getReservationId());
updateSagaState(sagaState);
} catch (Exception e) {
// 补偿：回滚支付
if (sagaState.isPaymentProcessed()) {
try {
paymentService.refundPayment(sagaState.getPaymentId());
} catch (Exception compensationEx) {
// 记录补偿失败，可能需要人工干预
logCompensationFailure(order, "payment_refund", compensationEx);
}
}
throw new SagaExecutionException("Inventory reservation failed", e);
}
}
private void createShipping(Order order, SagaState sagaState) {
try {
// 创建配送单
ShippingResult result = shippingService.createShippingOrder(order);
// 更新Saga状态
sagaState.setShippingCreated(true);
sagaState.setShippingId(result.getShippingId());
updateSagaState(sagaState);
} catch (Exception e) {
// 补偿：释放库存
if (sagaState.isInventoryReserved()) {
try {
inventoryService.releaseReservation(sagaState.getInventoryReservationId());
} catch (Exception compensationEx) {
logCompensationFailure(order, "inventory_release", compensationEx);
}
}
// 补偿：回滚支付
if (sagaState.isPaymentProcessed()) {
try {
paymentService.refundPayment(sagaState.getPaymentId());
} catch (Exception compensationEx) {
logCompensationFailure(order, "payment_refund", compensationEx);
}
}
throw new SagaExecutionException("Shipping creation failed", e);
}
}
// 失败处理，可能安排重试或者补偿
private void handleFailure(Order order, SagaState sagaState, Exception exception) {
// 记录失败
sagaState.setStatus("FAILED");
sagaState.setError(exception.getMessage());
updateSagaState(sagaState);
// 将失败的订单放入重试队列或者通知人工处理
// ...
}
// 其他辅助方法...
}
## 与其他弹性模式的结合
重试机制通常不是单独使用的，而是与其他弹性模式结合，形成完整的弹性策略。以下是几种常见的组合模式：
### 重试 + 断路器
断路器模式可以防止系统反复重试已知的失败操作，从而保护系统资源。Spring Retry与Spring Cloud Circuit Breaker的结合使用示例：
```java
import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
@Service
public class ResilientService {
private final CircuitBreakerFactory circuitBreakerFactory;
private final RemoteService remoteService;
public ResilientService(CircuitBreakerFactory circuitBreakerFactory, RemoteService remoteService) {
this.circuitBreakerFactory = circuitBreakerFactory;
this.remoteService = remoteService;
}
public String executeWithResilience(String param) {
// 使用断路器包装重试逻辑
return circuitBreakerFactory.create("remoteServiceCall")
.run(() -> callWithRetry(param), throwable -> fallbackMethod(param, throwable));
}
@Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000))
private String callWithRetry(String param) {
return remoteService.call(param);
}
private String fallbackMethod(String param, Throwable throwable) {
return "Fallback response for: " + param;
}
}
重试 + 超时
设置合理的超时时间，可以避免重试操作长时间阻塞线程：
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
@Service
public class TimeoutAwareService {
@Retryable(
value = {TimeoutException.class, IOException.class},
maxAttempts = 3,
backoff = @Backoff(delay = 1000)
)
public String executeWithTimeout(String param) throws TimeoutException {
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
// 执行可能耗时的操作
return callSlowService(param);
});
try {
// 设置超时时间
return future.get(5, TimeUnit.SECONDS);
} catch (java.util.concurrent.TimeoutException e) {
// 取消执行
future.cancel(true);
throw new TimeoutException("Operation timed out after 5 seconds");
} catch (Exception e) {
throw new RuntimeException("Execution failed", e);
}
}
private String callSlowService(String param) {
// 模拟耗时操作
try {
Thread.sleep((long) (Math.random() * 10000));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Operation interrupted", e);
}
return "Response for: " + param;
}
}
重试 + 缓存
缓存可以用作回退策略，当重试失败时提供过期但可用的数据：
import org.springframework.cache.annotation.Cacheable;
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 CacheBackedService {
private final ProductRepository productRepository;
public CacheBackedService(ProductRepository productRepository) {
this.productRepository = productRepository;
}
@Retryable(
value = {ServiceUnavailableException.class},
maxAttempts = 3,
backoff = @Backoff(delay = 1000)
)
public Product getProduct(String productId) {
// 尝试从主数据源获取最新数据
return productRepository.findById(productId)
.orElseThrow(() -> new ProductNotFoundException("Product not found: " + productId));
}
@Recover
public Product recoverGetProduct(ServiceUnavailableException e, String productId) {
// 服务不可用时，尝试从缓存获取
return getProductFromCache(productId);
}
@Cacheable(value = "products", unless = "#result == null")
public Product getProductFromCache(String productId) {
try {
// 尝试从备用/只读数据源获取
return productRepository.findByIdFromReadReplica(productId)
.orElse(null);
} catch (Exception ex) {
// 如果备用数据源也不可用，返回默认值或null
return null;
}
}
}
测试重试机制
测试重试逻辑可能比较棘手，因为它涉及到异常、延迟和多次尝试。以下是几种测试重试机制的方法：
单元测试
使用模拟对象模拟失败然后成功的行为：
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.boot.test.mock.mockito.SpyBean;
@SpringBootTest
public class RemoteServiceClientTest {
@MockBean
private RemoteAPI remoteAPI;
@SpyBean
private RemoteServiceClient serviceClient;
@Test
void shouldRetryAndEventuallySucceed() {
// 准备测试数据
String testParam = "test123";
// 配置mock行为：前两次调用抛出异常，第三次成功
when(remoteAPI.callApi(testParam))
.thenThrow(new ServiceUnavailableException("First failure"))
.thenThrow(new ServiceUnavailableException("Second failure"))
.thenReturn("Success response");
// 执行测试
String result = serviceClient.callRemoteService(testParam);
// 验证结果
assertEquals("Success response", result);
// 验证远程API被调用了3次
verify(remoteAPI, times(3)).callApi(testParam);
}
@Test
void shouldUseRecoveryMethodAfterExhaustingRetries() {
// 准备测试数据
String testParam = "test456";
// 配置mock行为：始终抛出异常
when(remoteAPI.callApi(testParam))
.thenThrow(new ServiceUnavailableException("Always failing"));
// 执行测试
String result = serviceClient.callRemoteService(testParam);
// 验证结果是回退方法的返回值
assertEquals("Fallback response for: test456", result);
// 验证远程API被调用了最大重试次数
verify(remoteAPI, times(3)).callApi(testParam);
}
}
集成测试
对于集成测试，可以使用真实的依赖，但控制它们的行为：
@SpringBootTest
public class OrderServiceIntegrationTest {
@Autowired
private OrderService orderService;
@MockBean
private PaymentGateway paymentGateway;
@Test
void shouldRetryPaymentProcessing() throws Exception {
// 准备测试数据
Order testOrder = createTestOrder();
// 配置mock行为：前两次调用抛出异常，第三次成功
when(paymentGateway.processPayment(any(PaymentRequest.class)))
.thenThrow(new PaymentGatewayException("Network error"))
.thenThrow(new PaymentGatewayException("Timeout"))
.thenReturn(new PaymentResponse("PAY123", "SUCCESS"));
// 执行测试
OrderResult result = orderService.placeOrder(testOrder);
// 验证结果
assertEquals("COMPLETED", result.getStatus());
// 验证支付网关被调用了3次
verify(paymentGateway, times(3)).processPayment(any(PaymentRequest.class));
}
private Order createTestOrder() {
// 创建测试订单
// ...
}
}
使用测试框架辅助工具
一些测试框架提供了辅助工具，以简化重试逻辑的测试：
import org.springframework.retry.RetryCallback;
import org.springframework.retry.RetryContext;
import org.springframework.retry.RetryListener;
import org.springframework.retry.support.RetryTemplate;
@SpringBootTest
public class RetryTemplateTest {
@Autowired
private RetryTemplate retryTemplate;
@Test
void testRetryTemplate() {
// 创建计数器，用于记录调用次数
AtomicInteger counter = new AtomicInteger(0);
// 创建重试监听器，用于验证重试过程
List<RetryEvent> retryEvents = new ArrayList<>();
RetryListener retryListener = new RetryListener() {
@Override
public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
retryEvents.add(new RetryEvent("open", context.getRetryCount()));
return true;
}
@Override
public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
retryEvents.add(new RetryEvent("close", context.getRetryCount(), throwable));
}
@Override
public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
retryEvents.add(new RetryEvent("error", context.getRetryCount(), throwable));
}
};
// 添加监听器
retryTemplate.registerListener(retryListener);
// 执行测试
String result = retryTemplate.execute(context -> {
int attempt = counter.incrementAndGet();
if (attempt < 3) {
throw new RuntimeException("Simulated failure on attempt " + attempt);
}
return "Success on attempt " + attempt;
});
// 验证结果
assertEquals("Success on attempt 3", result);
assertEquals(3, counter.get());
// 验证重试事件
assertEquals(7, retryEvents.size()); // open + 2*error + 2*close + open + close
assertEquals("open", retryEvents.get(0).type);
assertEquals("error", retryEvents.get(1).type);
// ... 验证其他事件
}
// 用于记录重试事件的辅助类
private static class RetryEvent {
final String type;
final int retryCount;
final Throwable throwable;
RetryEvent(String type, int retryCount) {
this(type, retryCount, null);
}
RetryEvent(String type, int retryCount, Throwable throwable) {
this.type = type;
this.retryCount = retryCount;
this.throwable = throwable;
}
}
}
Spring Retry源码解析
对于想深入理解Spring Retry工作原理的开发者，我们可以探索一下其关键源码：
核心类和接口
Spring Retry的核心架构由以下几个关键组件组成：
- RetryOperations：定义重试操作的核心接口
- RetryTemplate：RetryOperations的主要实现类
- RetryPolicy：定义何时重试的策略
- BackOffPolicy：定义重试间隔的策略
- RetryContext：保存重试过程中的上下文信息
- RetryCallback：封装需要重试的业务逻辑
- RecoveryCallback：定义重试失败后的恢复逻辑
让我们看看关键接口定义：
// RetryOperations接口定义
public interface RetryOperations {
<T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback) throws E;
<T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback,
RecoveryCallback<T> recoveryCallback) throws E;
<T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback,
RetryState retryState) throws E, ExhaustedRetryException;
<T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback,
RecoveryCallback<T> recoveryCallback,
RetryState retryState) throws E;
}
// RetryCallback接口定义
public interface RetryCallback<T, E extends Throwable> {
T doWithRetry(RetryContext context) throws E;
}
// RecoveryCallback接口定义
public interface RecoveryCallback<T> {
T recover(RetryContext context) throws Exception;
}
RetryTemplate实现分析
RetryTemplate是Spring Retry的核心类，它实现了RetryOperations接口，并协调各种策略的应用：
// RetryTemplate核心方法（简化版）
public <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback) throws E {
return execute(retryCallback, null, null);
}
public <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback,
RecoveryCallback<T> recoveryCallback) throws E {
return execute(retryCallback, recoveryCallback, null);
}
public <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback,
RecoveryCallback<T> recoveryCallback,
RetryState retryState) throws E {
RetryContext context = open(retryState);
Throwable lastException = null;
try {
// 调用beforeRetry监听器
boolean running = doOpenInterceptors(retryCallback, context);
if (!running) {
throw new TerminatedRetryException("Retry terminated before first attempt");
}
// 重试循环
while (canRetry(context) && !context.isExhaustedOnly()) {
try {
// 执行重试回调
return retryCallback.doWithRetry(context);
} catch (Throwable e) {
lastException = e;
// 调用onError监听器
doOnErrorInterceptors(retryCallback, context, e);
// 注册异常
registerThrowable(context, e);
// 检查是否需要重试
if (canRetry(context) && !context.isExhaustedOnly()) {
// 计算退避时间
backOffPolicy.backOff(context);
}
// 如果不需要重试，则抛出异常
if (!shouldRethrow(e, context)) {
continue;
}
throw RetryTemplate.<E>wrapIfNecessary(e);
}
}
// 重试次数耗尽
return handleRetryExhausted(recoveryCallback, context, lastException);
} finally {
// 调用afterRetry监听器
close(retryState, context, lastException == null);
doCloseInterceptors(retryCallback, context, lastException);
}
}
重试策略实现
Spring Retry提供了多种重试策略实现，最常用的是SimpleRetryPolicy：
// SimpleRetryPolicy核心逻辑（简化版）
public boolean canRetry(RetryContext context) {
Throwable t = context.getLastThrowable();
return (t == null || retryForException(t)) && context.getRetryCount() < maxAttempts;
}
private boolean retryForException(Throwable ex) {
// 检查异常类型是否在可重试异常列表中
for (Class<? extends Throwable> retryable : retryableExceptions.keySet()) {
if (retryable.isInstance(ex)) {
return true;
}
}
return false;
}
退避策略实现
ExponentialBackOffPolicy是最常用的退避策略之一，它实现了指数退避算法：
// ExponentialBackOffPolicy核心逻辑（简化版）
public void backOff(RetryContext context) throws BackOffInterruptedException {
// 计算退避时间
long sleepTime = computeSleepTime(context);
// 执行休眠
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new BackOffInterruptedException("Thread interrupted while sleeping", e);
}
}
protected long computeSleepTime(RetryContext context) {
long initInterval = this.initialInterval;
int retryCount = context.getRetryCount();
// 计算指数退避时间
long sleepTime = (long) (initInterval * Math.pow(this.multiplier, retryCount));
// 应用随机因子
if (this.withRandomBackOff) {
sleepTime = (long) (sleepTime * (1.0 + this.random.nextDouble() * 0.2));
}
// 确保不超过最大间隔
return Math.min(sleepTime, this.maxInterval);
}
常见问题排查与性能优化
在使用Spring Retry时，可能会遇到一些常见问题，这里提供一些排查思路和性能优化建议：
常见问题与解决方案
- 循环依赖问题
当使用@Retryable注解的类中存在循环依赖时，可能会导致Spring容器启动失败：
解决方案：
- 使用@Lazy注解延迟初始化
- 重构代码，打破循环依赖
- 使用编程式RetryTemplate而非注解
- 事务与重试的相互影响
在事务方法中使用重试可能导致事务多次提交：
解决方案：
- 确保@Transactional注解在@Retryable内部方法上，而非外部
- 或使用编程式事务管理与重试模板
- 重试方法参数问题
使用@Recover时，方法参数需要按照特定顺序定义：
解决方案：
- 确保第一个参数是异常类型
- 后续参数与@Retryable方法参数保持一致
- AspectJ织入问题
有时@Retryable注解不生效，可能是AOP配置问题：
解决方案：
- 确保已添加spring-aop和aspectjweaver依赖
- 检查@EnableRetry注解是否添加到配置类
- 检查方法是否被代理（自调用问题）
性能优化建议
- 合理设置重试参数
过度重试会消耗系统资源，关键参数优化：
- 将maxAttempts设置为2-3次，避免过多重试
- 初始间隔设置为几百毫秒，避免过长等待
- 对于高并发服务，使用较短的最大间隔
- 区分异常类型
不同异常可能需要不同的重试策略：
@Service
public class OptimizedService {
@Retryable(
include = {TemporaryException.class}, // 临时性异常，多次重试
maxAttempts = 3,
backoff = @Backoff(delay = 1000)
)
@Retryable(
include = {ResourceLimitException.class}, // 资源限制异常，较长间隔
maxAttempts = 2,
backoff = @Backoff(delay = 5000)
)
public void performOperation() {
// 操作逻辑
}
}
- 使用异步重试
对于非关键路径的操作，考虑使用异步重试：
@Service
public class AsyncRetryService {
private final RetryTemplate retryTemplate;
private final AsyncTaskExecutor taskExecutor;
@Async
public CompletableFuture<String> executeAsync(String input) {
CompletableFuture<String> future = new CompletableFuture<>();
taskExecutor.execute(() -> {
try {
String result = retryTemplate.execute(context -> {
// 需要重试的操作
return callRemoteService(input);
});
future.complete(result);
} catch (Throwable t) {
future.completeExceptionally(t);
}
});
return future;
}
}
- 缓存临时结果
在重试过程中，可以缓存临时结果，避免重复计算：
@Service
public class CacheOptimizedService {
@Retryable(maxAttempts = 3)
public Result processData(String input) {
// 检查是否有缓存的中间结果
IntermediateResult cached = getFromCache(input);
if (cached != null) {
// 使用缓存的中间结果继续处理
return completeProcessing(cached);
} else {
// 从头开始处理
IntermediateResult intermediate = performInitialProcessing(input);
// 缓存中间结果
saveToCache(input, intermediate);
return completeProcessing(intermediate);
}
}
}
- 限制并发重试
使用信号量或限流器控制并发重试数量：
@Service
public class ConcurrencyLimitedRetryService {
private final Semaphore semaphore = new Semaphore(10); // 最多10个并发重试
@Retryable(maxAttempts = 3)
public String executeWithConcurrencyLimit(String input) throws InterruptedException {
boolean acquired = false;
try {
acquired = semaphore.tryAcquire(100, TimeUnit.MILLISECONDS);
if (!acquired) {
throw new TooManyRetriesException("Too many concurrent retries");
}
// 执行实际操作
return performOperation(input);
} finally {
if (acquired) {
semaphore.release();
}
}
}
}
## 企业级应用实践
在企业级应用中，重试策略往往需要更加灵活和可配置。以下是一些企业级应用实践：
### 集中式重试配置
在大型应用中，管理分散的重试配置可能会变得困难。可以考虑使用集中式配置：
```java
@Configuration
public class RetryConfiguration {
@Bean
public RetryTemplate orderServiceRetryTemplate() {
return RetryTemplate.builder()
.maxAttempts(3)
.exponentialBackoff(1000, 2, 5000)
.retryOn(OrderProcessingException.class)
.build();
}
@Bean
public RetryTemplate paymentServiceRetryTemplate() {
return RetryTemplate.builder()
.maxAttempts(5)
.exponentialBackoff(2000, 1.5, 10000)
.retryOn(PaymentGatewayException.class)
.build();
}
@Bean
public RetryTemplate defaultRetryTemplate() {
return RetryTemplate.builder()
.maxAttempts(2)
.fixedBackoff(1000)
.build();
}
}
然后在服务中注入这些模板：
@Service
public class OrderService {
private final RetryTemplate orderServiceRetryTemplate;
public OrderService(@Qualifier("orderServiceRetryTemplate") RetryTemplate retryTemplate) {
this.orderServiceRetryTemplate = retryTemplate;
}
public Order processOrder(OrderRequest request) {
return orderServiceRetryTemplate.execute(context -> {
// 订单处理逻辑
return createAndSubmitOrder(request);
});
}
}
动态重试策略
在某些情况下，可能需要根据运行时参数动态调整重试策略：
@Service
public class DynamicRetryService {
private final RetryTemplateBuilder retryTemplateBuilder;
private final ConfigService configService;
public DynamicRetryService(RetryTemplateBuilder retryTemplateBuilder, ConfigService configService) {
this.retryTemplateBuilder = retryTemplateBuilder;
this.configService = configService;
}
public <T> T executeWithDynamicRetry(String operationType, Supplier<T> operation) {
// 获取特定操作类型的重试配置
RetryConfig config = configService.getRetryConfig(operationType);
// 动态构建重试模板
RetryTemplate template = retryTemplateBuilder
.maxAttempts(config.getMaxAttempts())
.exponentialBackoff(
config.getInitialInterval(),
config.getMultiplier(),
config.getMaxInterval()
)
.build();
// 执行操作
return template.execute(context -> operation.get());
}
}
监控与告警
在生产环境中，重试情况的监控非常重要，可以帮助发现潜在问题：
@Component
public class RetryMonitoringListener extends RetryListenerSupport {
private final MeterRegistry meterRegistry;
private final AlertService alertService;
public RetryMonitoringListener(MeterRegistry meterRegistry, AlertService alertService) {
this.meterRegistry = meterRegistry;
this.alertService = alertService;
}
@Override
public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
// 记录重试指标
String operationName = getOperationName(context);
meterRegistry.counter("retry.error", "operation", operationName).increment();
// 记录重试原因
if (throwable != null) {
meterRegistry.counter(
"retry.error.reason",
"operation", operationName,
"exception", throwable.getClass().getSimpleName()
).increment();
}
// 如果重试次数达到阈值，触发告警
if (context.getRetryCount() >= 2) {
alertService.sendAlert(
"High retry count for operation: " + operationName,
"Retry count: " + context.getRetryCount() + ", Last error: " + throwable.getMessage()
);
}
}
@Override
public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {
String operationName = getOperationName(context);
if (throwable == null) {
// 重试成功
meterRegistry.counter("retry.success", "operation", operationName).increment();
meterRegistry.counter(
"retry.success.count",
"operation", operationName,
"attempts", String.valueOf(context.getRetryCount() + 1)
).increment();
} else {
// 重试失败
meterRegistry.counter("retry.exhausted", "operation", operationName).increment();
}
}
private String getOperationName(RetryContext context) {
// 尝试从上下文获取操作名称，或使用默认名称
Object attribute = context.getAttribute(RetryContext.NAME);
return attribute != null ? attribute.toString() : "unknown";
}
}
分布式锁与重试
在分布式环境中，某些操作可能需要结合分布式锁和重试机制：
@Service
public class DistributedLockRetryService {
private final DistributedLockManager lockManager;
private final RetryTemplate retryTemplate;
public DistributedLockRetryService(DistributedLockManager lockManager, RetryTemplate retryTemplate) {
this.lockManager = lockManager;
this.retryTemplate = retryTemplate;
}
public void executeWithLockAndRetry(String resourceId, Runnable operation) {
// 先尝试获取锁，如果失败则重试
retryTemplate.execute(context -> {
// 尝试获取分布式锁
DistributedLock lock = lockManager.acquire(resourceId, 30, TimeUnit.SECONDS);
if (lock == null) {
throw new LockAcquisitionException("Failed to acquire lock for: " + resourceId);
}
try {
// 获取锁成功，执行操作
operation.run();
return true;
} finally {
// 释放锁
lock.release();
}
});
}
}
未来展望与趋势
随着云原生和微服务架构的发展，重试机制也在不断演进。以下是一些未来的发展趋势：
自适应重试策略
传统的固定或指数退避策略可能不适合所有场景。自适应重试策略可以根据历史成功率、当前系统负载等动态调整重试行为：
public class AdaptiveRetryPolicy implements RetryPolicy {
private final HistoryTracker historyTracker;
private final LoadMonitor loadMonitor;
private final int maxAttempts;
@Override
public boolean canRetry(RetryContext context) {
if (context.getRetryCount() >= maxAttempts) {
return false;
}
// 获取当前系统负载
double currentLoad = loadMonitor.getCurrentLoad();
if (currentLoad > 0.8) {
// 系统负载较高，减少重试
return context.getRetryCount() < 1;
}
// 根据历史成功率计算是否值得继续重试
String operationKey = context.getAttribute(RetryContext.NAME).toString();
double successProbability = historyTracker.getSuccessProbability(
operationKey,
context.getRetryCount()
);
// 如果在当前重试次数下的成功概率很低，则不再重试
return successProbability > 0.1;
}
// 其他接口方法实现...
}
面向云原生的重试策略
随着Kubernetes等平台的普及，重试策略可以与容器编排平台结合，实现更智能的重试决策：
public class CloudNativeRetryTemplate extends RetryTemplate {
private final KubernetesClient kubernetesClient;
private final String serviceName;
@Override
protected <T, E extends Throwable> RetryPolicy getRetryPolicy(RetryContext context) {
// 检查目标服务的健康状态
ServiceStatus status = kubernetesClient.getServiceStatus(serviceName);
if (status.isRollingUpdate()) {
// 服务正在滚动更新，使用更宽松的重试策略
return new SimpleRetryPolicy(5);
} else if (status.isUnhealthy()) {
// 服务不健康，使用有限重试策略
return new SimpleRetryPolicy(2);
} else {
// 服务正常，使用标准策略
return super.getRetryPolicy(context);
}
}
}
重试即服务（Retry as a Service）
随着服务网格技术的发展，重试逻辑可能会从应用层下沉到基础设施层，作为服务网格的一部分提供：
# Istio VirtualService 配置示例
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
name: payment-service
spec:
hosts:
- payment-service
http:
- route:
- destination:
host: payment-service
retries:
attempts: 3
perTryTimeout: 2s
retryOn: connect-failure,refused-stream,unavailable,cancelled,resource-exhausted
在这种情况下，应用代码可以更简洁，不需要关注重试逻辑：
@Service
public class ModernPaymentService {
private final PaymentClient paymentClient;
public PaymentResult processPayment(PaymentRequest request) {
// 不需要显式重试逻辑，由服务网格处理
return paymentClient.processPayment(request);
}
}
总结
在分布式系统中，优雅的重试策略是提高系统弹性的关键手段之一。Spring Retry框架通过声明式和编程式接口，为Java开发者提供了丰富的重试功能，可以显著提高系统的可靠性。
本文深入探讨了Spring Retry的核心概念、使用方法和最佳实践，从基础的@Retryable注解到复杂的RetryTemplate，从简单的HTTP调用重试到分布式补偿事务，全面介绍了Spring Retry在各种场景下的应用。
无论是微服务架构、云原生应用还是传统企业系统，合理的重试策略都能帮助系统更优雅地处理各种临时性故障，提供更好的用户体验。通过本文的学习，相信你已经掌握了如何在自己的系统中实现优雅而高效的重试策略。
最后需要强调的是，重试只是提高系统弹性的手段之一，它应当与其他弹性模式（如断路器、舱壁隔离、限流等）结合使用，共同构建更可靠的分布式系统。