Java接口请求重试机制的几种常见方法

public class Retry {

  private static final int MAX_RETRIES = 5;

  public static Response request() throws Exception {
    int retries = 0;
    while (true) {
      try {
        // 发送请求,返回响应
        Response response = HttpClient.sendRequest();

        // 请求成功则返回响应
        if (response.isSuccess()) {
          return response; 
        }

      } catch (Exception e) {
        // 请求失败进行重试
      }

      // 判断是否超过最大重试次数
      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) {
  // 远程调用接口 
}

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 -> {
     // 处理响应
  })
  .retryAsync(retryCount, delay); 

// 1. 创建队列
Queue retryQueue = new Queue("request.retry.queue");

// 2. 请求失败,发送重试消息  
public void request() {
  try {
    // 调用接口
    httpClient.post(url, payload);
  } catch (Exception e) {
    // 发送重试消息
    Message msg = new Message(url, payload, maxRetries);
    retryQueue.send(msg);
  }
}

// 3. 消费者线程进行重试
class RetryConsumer implements Runnable {

  public void run() {
    while (true) {
      Message msg = retryQueue.take();
      
      for (int i = 0; i < msg.getMaxRetries(); i++) {
        try {
          // 重试请求
          httpClient.post(msg.getUrl(), msg.getPayload());
          // 请求成功,结束循环
          break;
        } catch (Exception e) {
          // 等待后继续重试
        }  
      }
      
      // 重试完成后,确认消息
      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();
        // 重试次数加1
        retries++;
      }
    }
  }

}

// 执行请求的函数接口
interface RetryCallable<T> {
  T call(); 
}

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

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

public class RetryRequest {

  private static final int MAX_RETRIES = 3;
  
  public static Response request(int retries) {
    
    try {
      // 发送请求
      Response response = HttpClient.get("http://example.com");
      return response;
      
    } catch (Exception e) {
      
      // 处理异常
      
      // 判断是否需要重试
      if (retries < MAX_RETRIES) {
        // 增加重试次数
        retries++; 
        // 延迟1秒钟
        Thread.sleep(1000); 
        // 递归调用自身进行重试
        return request(retries);
      }
      
      // 重试失败
      throw new RuntimeException("Request failed after " + MAX_RETRIES + " retries!");
      
    }
  }
  
  public static void main(String[] args) {  
    Response response = request(0);
    // 处理响应
  }

}

<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(() -> {

  // 发送请求
  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发送请求
        return HttpClientUtils.get(url);
        
      } catch (Exception e) {

        if (retries >= MAX_RETRIES) {
          throw e;
        }
        
        // 增加重试次数
        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);
  }

}

// 网络工具类 
class HttpClientUtils {

  public static String get(String url) throws IOException {
    // 发送GET请求并返回结果
  }

}