保障 REST 服务高可用

/**
 * RESTful API 请求容错重试
 */
public class RestfulApiClient {
    
    // 域名配置 - 中国区
    private static final String[] DOMAINS_CN = {
        "api.sd-rtn.com",                  // 主域名
        "api.agora.io",                    // 备用主域名
        "api-cn-east-1.sd-rtn.com",        // 区域域名 - 中国华东
        "api-cn-north-1.sd-rtn.com"        // 区域域名 - 中国华北
    };
    
    // 域名配置 - 海外
    private static final String[] DOMAINS_OVERSEAS = {
        "api.agora.io",                    // 主域名
        "api.sd-rtn.com",                  // 备用主域名
        "api-us-west-1.agora.io",          // 区域域名 - 美国西部
        "api-us-east-1.agora.io"           // 区域域名 - 美国东部
    };
    
    // 退避时间（毫秒）
    private static final int[] BACKOFF_DELAYS = {0, 1000, 3000, 6000, 10000};
    
    // 最大重试次数
    private static final int MAX_RETRIES = 4;
    
    // 请求超时时间（毫秒）
    private static final int TIMEOUT = 10000;
    
    /**
     * 发起带容错的 HTTP 请求
     * 
     * @param path    请求路径
     * @param method  HTTP 方法
     * @param body    请求 Body
     * @param isChina 是否中国区
     * @return 响应结果
     */
    public Response requestWithRetry(String path, String method, Object body, boolean isChina) {
        String[] domains = isChina ? DOMAINS_CN : DOMAINS_OVERSEAS;
        int retryCount = 0;
        Exception lastException = null;
        
        while (retryCount <= MAX_RETRIES) {
            // 1. 选择域名（根据重试次数切换）
            int domainIndex = Math.min(retryCount, domains.length - 1);
            String domain = domains[domainIndex];
            String url = "https://" + domain + path;
            
            // 2. 等待退避时间（首次请求不等待）
            if (retryCount > 0) {
                sleep(BACKOFF_DELAYS[retryCount]);
                log.info("第{}次重试，使用域名: {}", retryCount, domain);
            }
            
            try {
                // 3. 发起 HTTP 请求
                Response response = httpRequest(url, method, body, TIMEOUT);
                
                // 4. 请求成功，返回结果
                if (isSuccess(response)) {
                    return response;
                }
                
                // 5. 服务端错误（50x），触发重试
                if (isServerError(response)) {
                    log.warn("服务端错误: {} {}", response.getStatus(), url);
                    lastException = new ServerException(response.getStatus());
                } else {
                    // 客户端错误（4xx），不重试，直接返回
                    return response;
                }
                
            } catch (TimeoutException e) {
                log.warn("请求超时: {}", url);
                lastException = e;
            } catch (NetworkException e) {
                log.warn("网络异常: {} - {}", url, e.getMessage());
                lastException = e;
            }
            
            retryCount++;
        }
        
        // 所有重试均失败，抛出异常
        throw new ApiRequestException("请求失败，已重试" + MAX_RETRIES + "次", lastException);
    }
    
    /**
     * 判断是否成功响应（2xx）
     */
    private boolean isSuccess(Response response) {
        return response.getStatus() >= 200 && response.getStatus() < 300;
    }
    
    /**
     * 判断是否服务端错误（需要重试）
     */
    private boolean isServerError(Response response) {
        int status = response.getStatus();
        return status == 500 || status == 502 || status == 503 || status == 504;
    }
}

RestfulApiClient client = new RestfulApiClient();

// 中国区请求
Response response = client.requestWithRetry(
    "/cn/conference/apps/{appId}/v1/rooms",
    "POST",
    requestBody,
    true  // isChina = true
);

// 海外请求
Response response = client.requestWithRetry(
    "/conference/apps/{appId}/v1/rooms",
    "POST",
    requestBody,
    false  // isChina = false
);