一、基础循环重试策略

1.1 同步阻塞式循环重试

这是最基础的实现方式，通过for/while循环结构控制重试逻辑。典型实现包含三个核心要素：

最大重试次数限制（防止无限循环）
异常捕获与处理机制
指数退避算法（避免雪崩效应）

public static boolean retryWithForLoop(int maxRetries, long delayMillis) {
    for (int i = 0; i < maxRetries; i++) {
        try {
            // 实际业务调用
            return makeApiCall();
        } catch (Exception e) {
            if (i == maxRetries - 1) throw e;
            Thread.sleep(delayMillis * (long) Math.pow(2, i)); // 指数退避
        }
    }
    return false;
}

1.2 异步非阻塞式重试

对于高并发场景，建议采用CompletableFuture或回调机制实现异步重试：

public static CompletableFuture<Boolean> asyncRetry(int maxRetries) {
    CompletableFuture<Boolean> future = new CompletableFuture<>();
    atomicRetry(maxRetries, 0, future);
    return future;
}
private static void atomicRetry(int max, int current, CompletableFuture<Boolean> future) {
    if (current >= max) {
        future.completeExceptionally(new RetryExhaustedException());
        return;
    }
    makeApiCall()
        .thenAccept(future::complete)
        .exceptionally(e -> {
            try {
                Thread.sleep(1000 * (long) Math.pow(2, current));
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
            }
            atomicRetry(max, current + 1, future);
            return null;
        });
}

二、递归重试实现方案

2.1 基础递归结构

通过方法递归调用实现重试逻辑，需特别注意：

递归深度控制（避免栈溢出）
尾递归优化（部分JVM支持）
资源清理机制

public void recursiveRetry(int remainingRetries) {
    if (remainingRetries <= 0) {
        throw new RetryExhaustedException();
    }
    try {
        processRequest();
    } catch (Exception e) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ie) {
            Thread.currentThread().interrupt();
        }
        recursiveRetry(remainingRetries - 1);
    }
}

2.2 递归优化变体

采用分离式递归设计，将业务逻辑与重试控制解耦：

public interface RetryableOperation<T> {
    T execute() throws Exception;
}
public <T> T executeWithRetry(RetryableOperation<T> operation, int maxRetries) {
    try {
        return operation.execute();
    } catch (Exception e) {
        if (maxRetries <= 0) throw e;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ie) {
            Thread.currentThread().interrupt();
        }
        return executeWithRetry(operation, maxRetries - 1);
    }
}

三、框架集成方案

3.1 HTTP客户端内置重试

主流HTTP客户端均提供重试机制配置：

Apache HttpClient (4.5+)

RequestConfig config = RequestConfig.custom()
    .setRetryHandler((exception, executionCount, context) -> {
        if (executionCount >= 3) return false;
        return exception instanceof ConnectTimeoutException 
            || exception instanceof NoHttpResponseException;
    })
    .build();
CloseableHttpClient client = HttpClients.custom()
    .setDefaultRequestConfig(config)
    .build();

OkHttp 重试拦截器

public class RetryInterceptor implements Interceptor {
    private int maxRetry;
    public RetryInterceptor(int maxRetry) {
        this.maxRetry = maxRetry;
    }
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response response = null;
        IOException exception = null;
        for (int i = 0; i <= maxRetry; i++) {
            try {
                response = chain.proceed(request);
                if (response.isSuccessful()) return response;
            } catch (IOException e) {
                exception = e;
            }
        }
        throw exception != null ? exception : new IOException("Unknown error");
    }
}

3.2 Spring Retry 模块

基于AOP的声明式重试实现：

@Configuration
@EnableRetry
public class RetryConfig {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}
@Service
public class MyService {
    @Retryable(value = {RemoteAccessException.class}, 
               maxAttempts = 3, 
               backoff = @Backoff(delay = 1000, multiplier = 2))
    public void callRemoteApi() {
        // 业务实现
    }
    @Recover
    public void recover(RemoteAccessException e) {
        // 降级处理
    }
}

四、高级重试策略

4.1 熔断器模式集成

结合Hystrix或Resilience4j实现智能重试：

CircuitBreaker circuitBreaker = CircuitBreaker.ofDefaults("apiService");
Supplier<String> decoratedSupplier = CircuitBreaker
    .decorateSupplier(circuitBreaker, this::callExternalApi);
Try.ofSupplier(decoratedSupplier)
   .recover(throwable -> "Fallback response");

4.2 动态重试策略

根据实时监控数据调整重试参数：

public class DynamicRetryPolicy {
    private final MetricsCollector metrics;
    public int calculateRetryDelay(int baseDelay, int attempt) {
        double successRate = metrics.getSuccessRate();
        if (successRate < 0.7) {
            return (int) (baseDelay * Math.pow(2, attempt) * 1.5); // 增强退避
        }
        return baseDelay * (int) Math.pow(2, attempt);
    }
}

五、最佳实践建议

异常分类处理：区分可重试异常（网络超时）和不可重试异常（权限错误）
上下文传递：在重试时保持请求上下文（如分布式追踪ID）
幂等性保障：确保重试不会导致业务数据不一致
资源清理：在最终失败时释放占用的资源
监控告警：记录重试次数和失败原因，设置阈值告警

六、性能对比分析

策略类型	吞吐量	延迟	资源消耗	适用场景
同步循环	中	高	低	简单命令行工具
异步回调	高	中	中	高并发Web服务
框架集成	高	低	低	企业级应用
熔断器模式	中	中	高	微服务架构

通过合理选择重试策略组合，开发者可以构建出既健壮又高效的分布式系统通信模块。建议根据具体业务场景，结合服务SLA要求和系统资源状况，选择最适合的重试实现方案。

接口请求重试的八种实现策略深度解析