最近需要對(duì)接很多第三方接口，有些接口因數(shù)據(jù)量大導(dǎo)致超時(shí)，有些因網(wǎng)絡(luò)不穩(wěn)定導(dǎo)致接口異常。在開(kāi)發(fā)階段還可以看日志、debugger處理，生產(chǎn)環(huán)境則需要更完善的方式處理。
重試的基本原則
在實(shí)現(xiàn)重試機(jī)制前，我們需要明確幾個(gè)基本原則：
- 不是所有錯(cuò)誤都適合重試：例如參數(shù)錯(cuò)誤、認(rèn)證失敗等客戶(hù)端錯(cuò)誤通常不適合重試
- 重試間隔應(yīng)該遞增：避免對(duì)目標(biāo)系統(tǒng)造成雪崩效應(yīng)
- 設(shè)置最大重試次數(shù)：防止無(wú)限重試導(dǎo)致資源耗盡
- 考慮冪等性：確保重試不會(huì)導(dǎo)致業(yè)務(wù)邏輯重復(fù)執(zhí)行
基礎(chǔ)實(shí)現(xiàn)：自定義重試邏輯
讓我們從一個(gè)基礎(chǔ)的實(shí)現(xiàn)開(kāi)始，逐步改進(jìn)我們的重試機(jī)制：
/**
* 基礎(chǔ)重試工具類(lèi)
*/
public class RetryUtil {
/**
* 執(zhí)行帶重試的操作
* @param operation 需要執(zhí)行的操作
* @param maxAttempts 最大嘗試次數(shù)
* @param initialDelayMs 初始延遲時(shí)間（毫秒）
* @param maxDelayMs 最大延遲時(shí)間（毫秒）
* @param retryableExceptions 需要重試的異常類(lèi)
* @param 返回值類(lèi)型
* @return 操作執(zhí)行的結(jié)果
* @throws Exception 如果重試后仍然失敗
*/
public static T executeWithRetry(
Supplier operation,
int maxAttempts,
long initialDelayMs,
long maxDelayMs,
Set<Class> retryableExceptions) throws Exception {
int attempts = 0;
long delay = initialDelayMs;
Exception lastException = null;
while (attempts < maxattempts try return operation.get catch exception e lastexception='e;' boolean isretryable='retryableExceptions.stream()' .anymatchexclass -> exClass.isAssignableFrom(e.getClass()));
if (!isRetryable || attempts == maxAttempts - 1) {
throw e; // 不可重試或已達(dá)到最大重試次數(shù)
}
// 記錄重試信息
System.out.printf("操作失敗，準(zhǔn)備第%d次重試，延遲%dms，異常：%s%n",
attempts + 1, delay, e.getMessage());
try {
// 線(xiàn)程休眠，實(shí)現(xiàn)重試延遲
Thread.sleep(delay);
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
throw new RuntimeException("重試過(guò)程被中斷", ie);
}
// 計(jì)算下一次重試的延遲時(shí)間（指數(shù)退避）
delay = Math.min(delay * 2, maxDelayMs);
attempts++;
}
}
// 這里通常不會(huì)執(zhí)行到，因?yàn)樽詈笠淮问r(shí)會(huì)直接拋出異常
throw new RuntimeException("達(dá)到最大重試次數(shù)后仍然失敗", lastException);
}
/**
* 使用示例
*/
public static void main(String[] args) {
try {
// 定義可重試的異常類(lèi)型
Set<Class> retryableExceptions = new HashSet<>();
retryableExceptions.add(IOException.class);
retryableExceptions.add(SocketTimeoutException.class);
// 執(zhí)行HTTP請(qǐng)求并帶有重試機(jī)制
String result = executeWithRetry(
() -> callExternalApi("https://api.example.com/data"),
3, // 最多重試3次
1000, // 初始延遲1秒
5000, // 最大延遲5秒
retryableExceptions
);
System.out.println("API調(diào)用成功，結(jié)果：" + result);
} catch (Exception e) {
System.err.println("最終調(diào)用失?。? + e.getMessage());
}
}
/**
* 模擬調(diào)用外部API
* @param url API地址
* @return API返回結(jié)果
* @throws IOException 如果API調(diào)用失敗
*/
private static String callExternalApi(String url) throws IOException {
// 這里是實(shí)際的API調(diào)用邏輯
// 示例中簡(jiǎn)化處理，隨機(jī)模擬成功或失敗
if (Math.random() < 0.7) { // 70%的概率失敗
throw new SocketTimeoutException("連接超時(shí)");
}
return "模擬API返回?cái)?shù)據(jù)";
}
}
上面的代碼實(shí)現(xiàn)了一個(gè)基礎(chǔ)的重試機(jī)制，具有以下特點(diǎn)：
- 支持設(shè)置最大重試次數(shù)
- 使用指數(shù)退避算法增加重試間隔
- 可以指定哪些異常類(lèi)型需要重試
- 透明地處理重試邏輯，對(duì)調(diào)用方幾乎無(wú)感知
使用Spring Retry提升重試能力
雖然自定義實(shí)現(xiàn)能夠滿(mǎn)足基本需求，但在企業(yè)級(jí)應(yīng)用中，我們通常會(huì)使用成熟的框架來(lái)處理重試邏輯。Spring Retry是一個(gè)功能強(qiáng)大的重試框架，它提供了更加豐富的配置選項(xiàng)和更好的集成能力。
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.RestTemplate;
import java.io.IOException;
import java.net.SocketTimeoutException;
/**
* 使用Spring Retry實(shí)現(xiàn)的API調(diào)用服務(wù)
*/
@Service
public class ExternalApiService {
private final RestTemplate restTemplate = new RestTemplate();
/**
* 調(diào)用外部支付API
*
* @param orderId 訂單ID
* @param amount 金額
* @return 支付結(jié)果
* @throws IOException 如果API調(diào)用失敗
*/
@Retryable(
value = {IOException.class, SocketTimeoutException.class}, // 指定需要重試的異常
maxAttempts = 3, // 最大嘗試次數(shù)（包括第一次）
backoff = @Backoff(delay = 1000, multiplier = 2, maxDelay = 5000) // 重試延遲策略
)
public PaymentResult processPayment(String orderId, double amount) throws IOException {
System.out.println("嘗試處理支付，訂單ID: " + orderId + ", 金額: " + amount);
// 這里是實(shí)際的API調(diào)用代碼
// 為了演示，我們模擬一個(gè)可能失敗的API調(diào)用
if (Math.random() < 0.7) { // 70%的概率失敗
throw new SocketTimeoutException("支付網(wǎng)關(guān)連接超時(shí)");
}
// 支付成功
return new PaymentResult(orderId, "SUCCESS", "TXN" + System.currentTimeMillis());
}
/**
* 恢復(fù)方法，當(dāng)重試達(dá)到最大次數(shù)后調(diào)用
*
* @param e 導(dǎo)致失敗的異常
* @param orderId 訂單ID
* @param amount 金額
* @return 支付結(jié)果（失敗狀態(tài)）
*/
@Recover
public PaymentResult recoverPayment(Exception e, String orderId, double amount) {
System.err.println("支付處理失敗，已達(dá)到最大重試次數(shù)，訂單ID: " + orderId);
// 記錄失敗日志，可能需要人工干預(yù)或其他補(bǔ)償措施
return new PaymentResult(orderId, "FAILED", null);
}
/**
* 支付結(jié)果類(lèi)
*/
public static class PaymentResult {
private final String orderId;
private final String status;
private final String transactionId;
public PaymentResult(String orderId, String status, String transactionId) {
this.orderId = orderId;
this.status = status;
this.transactionId = transactionId;
}
// getter方法省略...
@Override
public String toString() {
return "PaymentResult{" +
"orderId='" + orderId + ''' +
", status='" + status + ''' +
", transactionId='" + transactionId + ''' +
'}';
}
}
}
/**
* Spring Boot配置類(lèi)，啟用重試功能
*/
@Configuration
@EnableRetry
public class RetryConfig {
// 可以在這里添加更多的重試配置
}
Spring Retry的優(yōu)勢(shì)在于：
- 聲明式配置：通過(guò)注解即可完成重試配置，代碼更加簡(jiǎn)潔
- 統(tǒng)一管理：可以在配置類(lèi)中集中管理重試策略
- 恢復(fù)機(jī)制：提供了@Recover注解用于處理最終失敗的情況
- 豐富的策略：支持多種重試策略和回退策略
高級(jí)重試策略：斷路器模式
在處理第三方接口時(shí)，有時(shí)我們需要更復(fù)雜的重試策略。例如，當(dāng)接口持續(xù)失敗時(shí)，繼續(xù)重試可能會(huì)浪費(fèi)資源并延長(zhǎng)響應(yīng)時(shí)間。斷路器模式可以解決這個(gè)問(wèn)題。
import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig.SlidingWindowType;
import io.github.resilience4j.retry.Retry;
import io.github.resilience4j.retry.RetryConfig;
import java.io.IOException;
import java.time.Duration;
import java.util.function.Supplier;
/**
* 使用Resilience4j實(shí)現(xiàn)斷路器和重試組合
*/
public class ResilientApiClient {
private final CircuitBreaker circuitBreaker;
private final Retry retry;
public ResilientApiClient() {
// 配置斷路器
CircuitBreakerConfig circuitBreakerConfig = CircuitBreakerConfig.custom()
.failureRateThreshold(50) // 當(dāng)失敗率超過(guò)50%時(shí)斷路
.waitDurationInOpenState(Duration.ofSeconds(30)) // 斷路器打開(kāi)后等待30秒
.slidingWindowType(SlidingWindowType.COUNT_BASED) // 基于請(qǐng)求數(shù)量的滑動(dòng)窗口
.slidingWindowSize(10) // 滑動(dòng)窗口大小為10個(gè)請(qǐng)求
.build();
this.circuitBreaker = CircuitBreaker.of("paymentApi", circuitBreakerConfig);
// 配置重試
RetryConfig retryConfig = RetryConfig.custom()
.maxAttempts(3) // 最大嘗試次數(shù)
.waitDuration(Duration.ofMillis(1000)) // 初始等待時(shí)間
.retryExceptions(IOException.class) // 需要重試的異常
.exponentialBackoff() // 使用指數(shù)退避策略
.build();
this.retry = Retry.of("paymentApi", retryConfig);
}
/**
* 調(diào)用支付API，結(jié)合斷路器和重試功能
*
* @param orderId 訂單ID
* @param amount 金額
* @return 支付結(jié)果
*/
public String processPayment(String orderId, double amount) {
// 創(chuàng)建供應(yīng)商函數(shù)，封裝實(shí)際的API調(diào)用
Supplier paymentSupplier = () -> {
System.out.println("處理支付，訂單ID: " + orderId + ", 金額: " + amount);
// 這里是實(shí)際的API調(diào)用邏輯
if (Math.random() < 0.7) { // 70%的概率失敗
throw new IOException("支付網(wǎng)關(guān)連接超時(shí)");
}
return "支付成功，交易ID: TXN" + System.currentTimeMillis();
};
// 將斷路器和重試功能應(yīng)用到支付調(diào)用
// 先應(yīng)用重試，再應(yīng)用斷路器
Supplier resilientSupplier = Retry.decorateSupplier(retry,
CircuitBreaker.decorateSupplier(circuitBreaker,
paymentSupplier));
try {
// 執(zhí)行帶有彈性的支付調(diào)用
return resilientSupplier.get();
} catch (Exception e) {
System.err.println("支付處理最終失敗: " + e.getMessage());
// 檢查斷路器狀態(tài)
if (circuitBreaker.getState() == CircuitBreaker.State.OPEN) {
return "支付服務(wù)暫時(shí)不可用，請(qǐng)稍后重試";
} else {
return "支付處理失敗: " + e.getMessage();
}
}
}
/**
* 使用示例
*/
public static void main(String[] args) {
ResilientApiClient client = new ResilientApiClient();
// 模擬多次調(diào)用，觀察斷路器行為
for (int i = 0; i < 20; i++) {
System.out.println("=== 第" + (i + 1) + "次調(diào)用 ===");
String result = client.processPayment("ORDER-" + i, 100.0 * i);
System.out.println("結(jié)果: " + result);
System.out.println("斷路器狀態(tài): " + client.circuitBreaker.getState());
System.out.println();
try {
Thread.sleep(500); // 短暫延遲，便于觀察
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
}
通用重試框架：靈活且強(qiáng)大的解決方案
為了應(yīng)對(duì)各種復(fù)雜場(chǎng)景，我們可能需要更加靈活的重試框架。上面的代碼實(shí)現(xiàn)了一個(gè)通用重試框架，它具有以下特點(diǎn)：
Builder模式：使用Builder模式構(gòu)建重試配置，使API更加直觀 靈活的策略配置：支持配置最大嘗試次數(shù)、初始延遲、最大延遲、退避乘數(shù)等 多種退避策略：支持固定延遲和指數(shù)退避兩種策略 可定制的異常處理：可以精確控制哪些異常需要重試 日志記錄：通過(guò)接口抽象，支持可定制的日志記錄方式 鏈?zhǔn)秸{(diào)用：API設(shè)計(jì)支持鏈?zhǔn)秸{(diào)用，提升代碼可讀性
/**
* 通用重試框架
* 提供靈活的重試策略配置和全局異常處理
*/
public class GenericRetryFramework {
/**
* 重試策略配置類(lèi)
*/
public static class RetryConfig {
private int maxAttempts = 3; // 最大嘗試次數(shù)
private long initialDelayMs = 1000; // 初始延遲時(shí)間(毫秒)
private long maxDelayMs = 10000; // 最大延遲時(shí)間(毫秒)
private double backoffMultiplier = 2.0; // 退避乘數(shù)
private boolean exponentialBackoff = true; // 是否使用指數(shù)退避
private Set<Class> retryableExceptions = new HashSet<>(); // 可重試的異常
private RetryLogger logger = null; // 重試日志記錄器
// Builder模式構(gòu)建器
public static class Builder {
private RetryConfig config = new RetryConfig();
public Builder maxAttempts(int maxAttempts) {
config.maxAttempts = maxAttempts;
return this;
}
public Builder initialDelay(long delayMs) {
config.initialDelayMs = delayMs;
return this;
}
public Builder maxDelay(long maxDelayMs) {
config.maxDelayMs = maxDelayMs;
return this;
}
public Builder backoffMultiplier(double multiplier) {
config.backoffMultiplier = multiplier;
return this;
}
public Builder fixedDelay() {
config.exponentialBackoff = false;
return this;
}
public Builder exponentialBackoff() {
config.exponentialBackoff = true;
return this;
}
public Builder retryOn(Class... exceptions) {
Collections.addAll(config.retryableExceptions, exceptions);
return this;
}
public Builder logger(RetryLogger logger) {
config.logger = logger;
return this;
}
public RetryConfig build() {
// 如果沒(méi)有指定可重試異常，默認(rèn)重試所有異常
if (config.retryableExceptions.isEmpty()) {
config.retryableExceptions.add(Exception.class);
}
// 如果沒(méi)有指定日志記錄器，使用默認(rèn)日志記錄器
if (config.logger == null) {
config.logger = new DefaultRetryLogger();
}
return config;
}
}
public static Builder builder() {
return new Builder();
}
}
/**
* 重試日志記錄器接口
*/
public interface RetryLogger {
void logRetryAttempt(int attempt, long delay, Exception exception);
void logSuccess(int attempts);
void logFailure(int attempts, Exception lastException);
}
/**
* 默認(rèn)日志記錄器實(shí)現(xiàn)
*/
public static class DefaultRetryLogger implements RetryLogger {
@Override
public void logRetryAttempt(int attempt, long delay, Exception exception) {
System.out.printf("[重試框架] 第%d次嘗試失敗，將在%dms后重試，異常：%s: %s%n",
attempt, delay, exception.getClass().getSimpleName(), exception.getMessage());
}
@Override
public void logSuccess(int attempts) {
if (attempts > 1) {
System.out.printf("[重試框架] 操作在第%d次嘗試后成功%n", attempts);
}
}
@Override
public void logFailure(int attempts, Exception lastException) {
System.err.printf("[重試框架] 操作在嘗試%d次后最終失敗，最后異常：%s: %s%n",
attempts, lastException.getClass().getSimpleName(), lastException.getMessage());
}
}
/**
* 執(zhí)行需要重試的操作
*
* @param operation 需要執(zhí)行的操作
* @param config 重試配置
* @param 操作返回值類(lèi)型
* @return 操作執(zhí)行結(jié)果
* @throws Exception 如果重試后仍然失敗
*/
public static T executeWithRetry(Supplier operation, RetryConfig config) throws Exception {
int attempts = 0;
long delay = config.initialDelayMs;
Exception lastException = null;
while (attempts < config.maxattempts attempts try t result='operation.get();' config.logger.logsuccessattempts return result catch exception e lastexception='e;' boolean isretryable='config.retryableExceptions.stream()' .anymatchexclass -> exClass.isAssignableFrom(e.getClass()));
// 如果是不可重試異?；蛞堰_(dá)到最大嘗試次數(shù)，則直接拋出
if (!isRetryable || attempts >= config.maxAttempts) {
config.logger.logFailure(attempts, e);
throw e;
}
// 記錄重試日志
config.logger.logRetryAttempt(attempts, delay, e);
// 等待指定時(shí)間后重試
try {
Thread.sleep(delay);
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
throw new RuntimeException("重試過(guò)程被中斷", ie);
}
// 計(jì)算下一次重試的延遲時(shí)間
if (config.exponentialBackoff) {
delay = Math.min((long)(delay * config.backoffMultiplier), config.maxDelayMs);
}
}
}
// 這里通常不會(huì)執(zhí)行到，因?yàn)樽詈笠淮问?huì)直接拋出異常
throw new RuntimeException("達(dá)到最大重試次數(shù)后仍然失敗", lastException);
}
/**
* 使用示例
*/
public static void main(String[] args) {
try {
// 構(gòu)建重試配置
RetryConfig config = RetryConfig.builder()
.maxAttempts(5)
.initialDelay(500)
.maxDelay(8000)
.exponentialBackoff()
.retryOn(IOException.class, TimeoutException.class)
.build();
// 執(zhí)行需要重試的操作
String result = executeWithRetry(() -> {
// 模擬外部API調(diào)用
System.out.println("調(diào)用外部API...");
if (Math.random() < 0.8) { // 80%的概率失敗
if (Math.random() < 0.5) {
throw new IOException("網(wǎng)絡(luò)連接異常");
} else {
throw new TimeoutException("請(qǐng)求超時(shí)");
}
}
return "API調(diào)用成功返回的數(shù)據(jù)";
}, config);
System.out.println("最終結(jié)果: " + result);
} catch (Exception e) {
System.err.println("所有重試嘗試均失敗: " + e.getMessage());
}
}
}
// 針對(duì)HTTP調(diào)用的重試配置
RetryConfig httpConfig = RetryConfig.builder()
.maxAttempts(3)
.initialDelay(1000)
.exponentialBackoff()
.retryOn(IOException.class, SocketTimeoutException.class)
.logger(new CustomHttpRetryLogger())
.build();
// 針對(duì)數(shù)據(jù)庫(kù)操作的重試配置
RetryConfig dbConfig = RetryConfig.builder()
.maxAttempts(5)
.initialDelay(200)
.fixedDelay()
.retryOn(SQLTransientException.class)
.build();
總結(jié)
最后，重試雖好，但也不是萬(wàn)能的。有時(shí)候，優(yōu)化接口本身的性能和穩(wěn)定性，可能比添加復(fù)雜的重試邏輯更加重要。在系統(tǒng)設(shè)計(jì)中，我們應(yīng)該始終保持平衡的視角，選擇最適合當(dāng)前場(chǎng)景的解決方案。
版權(quán)聲明：本文內(nèi)容由互聯(lián)網(wǎng)用戶(hù)自發(fā)貢獻(xiàn)，該文觀點(diǎn)僅代表作者本人。本站僅提供信息存儲(chǔ)空間服務(wù)，不擁有所有權(quán)，不承擔(dān)相關(guān)法律責(zé)任。如發(fā)現(xiàn)本站有涉嫌抄襲侵權(quán)/違法違規(guī)的內(nèi)容， 請(qǐng)發(fā)送郵件至2705686032@qq.com 舉報(bào)，一經(jīng)查實(shí)，本站將立刻刪除。原文轉(zhuǎn)載： 原文出處：
