public class Retry {

  private static final int MAX_RETRIES = 5;

  public static Response request() throws Exception {
    int retries = 0;
    while (true) {
      try {
        // 發(fā)送請(qǐng)求,返回響應(yīng)
        Response response = HttpClient.sendRequest();

        // 請(qǐng)求成功則返回響應(yīng)
        if (response.isSuccess()) {
          return response; 
        }

      } catch (Exception e) {
        // 請(qǐng)求失敗進(jìn)行重試
      }

      // 判斷是否超過(guò)最大重試次數(shù)
      if (++retries >= MAX_RETRIES) {
        throw new Exception("Exceeded max retries");
      }

      // 增加間隔后重試
      int interval = (int) (Math.random() * 1000); 
      Thread.sleep(interval);
    }
  }

  public static void main(String[] args) throws Exception {
    Response response = request();
    // ...
  }

}

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
    <version>1.3.1</version>
</dependency>

@Retryable(value = Exception.class, maxAttempts = 3, backoff = @Backoff(delay = 5000))
public User getUser(String id) {
  // 遠(yuǎn)程調(diào)用接口 
}

RetryTemplate template = new RetryTemplate();

template.execute(context -> {
  // 可在此處自定義重試邏輯
  
  return remoteClient.invoke(); 
});

CompletableFuture<Response> future = CompletableFuture.supplyAsync(() -> {
  return service.call();
});

future = future.exceptionally(e -> {
  return service.retryAsync(); 
});

future
  .exceptionally(e -> {
     // 處理異常
  })
  .thenApplyAsync(resp -> {
     // 處理響應(yīng)
  })
  .retryAsync(retryCount, delay); 

// 1. 創(chuàng)建隊(duì)列
Queue retryQueue = new Queue("request.retry.queue");

// 2. 請(qǐng)求失敗,發(fā)送重試消息  
public void request() {
  try {
    // 調(diào)用接口
    httpClient.post(url, payload);
  } catch (Exception e) {
    // 發(fā)送重試消息
    Message msg = new Message(url, payload, maxRetries);
    retryQueue.send(msg);
  }
}

// 3. 消費(fèi)者線程進(jìn)行重試
class RetryConsumer implements Runnable {

  public void run() {
    while (true) {
      Message msg = retryQueue.take();
      
      for (int i = 0; i < msg.getMaxRetries(); i++) {
        try {
          // 重試請(qǐng)求
          httpClient.post(msg.getUrl(), msg.getPayload());
          // 請(qǐng)求成功,結(jié)束循環(huán)
          break;
        } catch (Exception e) {
          // 等待后繼續(xù)重試
        }  
      }
      
      // 重試完成后,確認(rèn)消息
      retryQueue.confirm(msg);
    }
  }
}

public class RetryUtil {

  public static <T> T retry(RetryCallable<T> callable, RetryPolicy policy) {
    int retries = 0; 
    while(true) {
      try {
        return callable.call();  
      } catch(Exception e) {
        if (retries >= policy.maxRetries) {
          throw e;
        }
        // 等待
        policy.delay();
        // 重試次數(shù)加1
        retries++;
      }
    }
  }

}

// 執(zhí)行請(qǐng)求的函數(shù)接口
interface RetryCallable<T> {
  T call(); 
}

// 重試策略 
class RetryPolicy {
  int maxRetries;
  int delay; 
}

// 使用示例
RetryUtil.retry(() -> {
  // 接口請(qǐng)求
  return httpClient.get(url); 
}, policy);

public class RetryRequest {

  private static final int MAX_RETRIES = 3;
  
  public static Response request(int retries) {
    
    try {
      // 發(fā)送請(qǐng)求
      Response response = HttpClient.get("http://example.com");
      return response;
      
    } catch (Exception e) {
      
      // 處理異常
      
      // 判斷是否需要重試
      if (retries < MAX_RETRIES) {
        // 增加重試次數(shù)
        retries++; 
        // 延遲1秒鐘
        Thread.sleep(1000); 
        // 遞歸調(diào)用自身進(jìn)行重試
        return request(retries);
      }
      
      // 重試失敗
      throw new RuntimeException("Request failed after " + MAX_RETRIES + " retries!");
      
    }
  }
  
  public static void main(String[] args) {  
    Response response = request(0);
    // 處理響應(yīng)
  }

}

<dependency>
  <groupId>io.github.resilience4j</groupId>
  <artifactId>resilience4j-retry</artifactId>
</dependency>

RetryConfig config = RetryConfig.custom()
  .maxAttempts(3)
  .waitDuration(Duration.ofMillis(500))
  .build();

Retry retry = Retry.of("backend", config);

String result = retry.executeSupplier(() -> {

  // 發(fā)送請(qǐng)求
  return backendService.callAPI(); 

});

RetryConfig config = RetryConfig.custom()
  .retryOnException(e -> isRetryable(e))
  .build();

public class RetryExample {

  private static final int MAX_RETRIES = 3;

  public static String request(String url) throws Exception {

    int retries = 0; 
    
    while (true) {
      
      try {
        // 使用HttpClient發(fā)送請(qǐng)求
        return HttpClientUtils.get(url);
        
      } catch (Exception e) {

        if (retries >= MAX_RETRIES) {
          throw e;
        }
        
        // 增加重試次數(shù)
        retries++;

        // 延遲1秒鐘
        TimeUnit.SECONDS.sleep(1);

      }
    }
  }
    
  public static void main(String[] args) throws Exception {
    String result = request("http://example.com/api");
    System.out.println(result);
  }

}

// 網(wǎng)絡(luò)工具類 
class HttpClientUtils {

  public static String get(String url) throws IOException {
    // 發(fā)送GET請(qǐng)求并返回結(jié)果
  }

}