feat: improve retry strategy (#196)

close #195

Author: MilletBo

src/main/java/io/github/doocs/im/ClientConfiguration.java

@@ -22,6 +22,11 @@ public class ClientConfiguration {
      */
     public static final int DEFAULT_MAX_RETRIES = 3;
 
+    /**
+     * 默认重试间隔时间（毫秒）
+     */
+    public static final long DEFAULT_RETRY_INTERVAL_MS = 200;
+
     /**
      * 默认自动更新签名
      */
@@ -45,6 +50,7 @@ public class ClientConfiguration {
     public static final ConnectionPool DEFAULT_CONNECTION_POOL = new ConnectionPool();
 
     private int maxRetries = DEFAULT_MAX_RETRIES;
+    private long retryIntervalMs = DEFAULT_RETRY_INTERVAL_MS;
     private long connectTimeout = DEFAULT_CONNECT_TIMEOUT;
     private long readTimeout = DEFAULT_READ_TIMEOUT;
     private long writeTimeout = DEFAULT_WRITE_TIMEOUT;
@@ -57,13 +63,14 @@ public class ClientConfiguration {
     public ClientConfiguration() {
     }
 
-    public ClientConfiguration(int maxRetries, long connectTimeout, long readTimeout, long writeTimeout,
+    public ClientConfiguration(int maxRetries, long retryIntervalMs, long connectTimeout, long readTimeout, long writeTimeout,
                                long callTimeout, long expireTime, boolean autoRenewSig,
                                String userAgent, ConnectionPool connectionPool) {
         if (connectionPool == null) {
             connectionPool = DEFAULT_CONNECTION_POOL;
         }
         this.maxRetries = Math.max(0, maxRetries);
+        this.retryIntervalMs = retryIntervalMs;
         this.connectTimeout = connectTimeout;
         this.readTimeout = readTimeout;
         this.writeTimeout = writeTimeout;
@@ -76,6 +83,7 @@ public ClientConfiguration(int maxRetries, long connectTimeout, long readTimeout
 
     private ClientConfiguration(Builder builder) {
         this.maxRetries = builder.maxRetries;
+        this.retryIntervalMs = builder.retryIntervalMs;
         this.connectTimeout = builder.connectTimeout;
         this.readTimeout = builder.readTimeout;
         this.writeTimeout = builder.writeTimeout;
@@ -98,6 +106,14 @@ public void setMaxRetries(int maxRetries) {
         this.maxRetries = Math.max(0, maxRetries);
     }
 
+    public long getRetryIntervalMs() {
+        return retryIntervalMs;
+    }
+
+    public void setRetryIntervalMs(long retryIntervalMs) {
+        this.retryIntervalMs = retryIntervalMs;
+    }
+
     public long getConnectTimeout() {
         return connectTimeout;
     }
@@ -178,6 +194,9 @@ public boolean equals(Object o) {
         if (maxRetries != that.maxRetries) {
             return false;
         }
+        if (retryIntervalMs != that.retryIntervalMs) {
+            return false;
+        }
         if (connectTimeout != that.connectTimeout) {
             return false;
         }
@@ -204,11 +223,12 @@ public boolean equals(Object o) {
 
     @Override
     public int hashCode() {
-        return Objects.hash(maxRetries, connectTimeout, readTimeout, writeTimeout, callTimeout, expireTime, autoRenewSig, userAgent, connectionPool);
+        return Objects.hash(maxRetries, retryIntervalMs, connectTimeout, readTimeout, writeTimeout, callTimeout, expireTime, autoRenewSig, userAgent, connectionPool);
     }
 
     public static final class Builder {
         private int maxRetries = DEFAULT_MAX_RETRIES;
+        private long retryIntervalMs = DEFAULT_RETRY_INTERVAL_MS;
         private long connectTimeout = DEFAULT_CONNECT_TIMEOUT;
         private long readTimeout = DEFAULT_READ_TIMEOUT;
         private long writeTimeout = DEFAULT_WRITE_TIMEOUT;
@@ -230,6 +250,11 @@ public Builder maxRetries(int maxRetries) {
             return this;
         }
 
+        public Builder retryIntervalMs(int retryIntervalMs) {
+            this.retryIntervalMs = retryIntervalMs;
+            return this;
+        }
+
         public Builder connectTimeout(long connectTimeout) {
             this.connectTimeout = connectTimeout;
             return this;

src/main/java/io/github/doocs/im/util/HttpUtil.java

@@ -4,11 +4,11 @@
 import okhttp3.*;
 
 import java.io.IOException;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * HTTP 工具类
@@ -31,7 +31,7 @@ public class HttpUtil {
             .writeTimeout(DEFAULT_CONFIG.getWriteTimeout(), TimeUnit.MILLISECONDS)
             .callTimeout(DEFAULT_CONFIG.getCallTimeout(), TimeUnit.MILLISECONDS)
             .retryOnConnectionFailure(false)
-            .addInterceptor(new RetryInterceptor(DEFAULT_CONFIG.getMaxRetries()))
+            .addInterceptor(new RetryInterceptor(DEFAULT_CONFIG.getMaxRetries(), DEFAULT_CONFIG.getRetryIntervalMs()))
             .build();
 
     private HttpUtil() {
@@ -58,7 +58,7 @@ private static OkHttpClient getClient(ClientConfiguration config) {
                 .writeTimeout(cfg.getWriteTimeout(), TimeUnit.MILLISECONDS)
                 .callTimeout(cfg.getCallTimeout(), TimeUnit.MILLISECONDS)
                 .retryOnConnectionFailure(false)
-                .addInterceptor(new RetryInterceptor(cfg.getMaxRetries()))
+                .addInterceptor(new RetryInterceptor(cfg.getMaxRetries(), cfg.getRetryIntervalMs()))
                 .build());
     }
 
@@ -98,28 +98,70 @@ public static String get(String url) throws IOException {
 }
 
 class RetryInterceptor implements Interceptor {
-    private int maxRetry;
-
-    RetryInterceptor(int maxRetry) {
-        this.maxRetry = maxRetry;
+    private static final Set<Integer> RETRYABLE_STATUS_CODES = Collections.unmodifiableSet(
+            Stream.of(408, 429, 500, 502, 503, 504).collect(Collectors.toSet())
+    );
+    private static final int MAX_DELAY_MS = 10000;
+    private final int maxRetries;
+    private final long retryIntervalMs;
+
+    public RetryInterceptor(int maxRetries, long retryIntervalMs) {
+        this.maxRetries = maxRetries;
+        this.retryIntervalMs = retryIntervalMs;
     }
 
-    public int getMaxRetry() {
-        return maxRetry;
+    @Override
+    public Response intercept(Chain chain) throws IOException {
+        Request request = chain.request();
+        Response response = null;
+        IOException exception = null;
+        for (int attempt = 0; attempt <= maxRetries; ++attempt) {
+            if (response != null) {
+                response.close();
+            }
+            try {
+                response = chain.proceed(request);
+                if (response.isSuccessful()) {
+                    return response;
+                }
+                if (!shouldRetry(response)) {
+                    return response;
+                }
+            } catch (IOException e) {
+                if (attempt >= maxRetries) {
+                    throw e;
+                }
+                exception = e;
+            }
+            if (attempt < maxRetries) {
+                waitForRetry(attempt);
+            }
+        }
+
+        if (response != null) {
+            return response;
+        }
+        if (exception != null) {
+            throw exception;
+        } else {
+            throw new IOException("Failed to get a valid response after all retries and no exception was caught.");
+        }
     }
 
-    public void setMaxRetry(int maxRetry) {
-        this.maxRetry = maxRetry;
+    private boolean shouldRetry(Response response) {
+        final int code = response.code();
+        if (code >= 500 && code < 600) {
+            return true;
+        }
+        return RETRYABLE_STATUS_CODES.contains(code);
     }
 
-    @Override
-    public Response intercept(Chain chain) throws IOException {
-        Request request = chain.request();
-        Response response = chain.proceed(request);
-        for (int i = 0; i < maxRetry && !response.isSuccessful(); ++i) {
-            response.close();
-            response = chain.proceed(request);
+    private void waitForRetry(int attempt) {
+        try {
+            final long delayMs = Math.min(MAX_DELAY_MS, retryIntervalMs * (1L << attempt));
+            TimeUnit.MILLISECONDS.sleep(delayMs);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
         }
-        return response;
     }
 }