OkHttp自定義重試次數

本文主要應用了OkHttp的Interceptor來實現自定義重試次數

雖然OkHttp自帶retryOnConnectionFailure(true)方法可以實現重試，但是不支持自定義重試次數，所以有時並不能滿足我們的需求。

#1.自定義重試攔截器：

/**
 * 重試攔截器
 */
public class RetryIntercepter implements Interceptor {

    public int maxRetry;//最大重試次數
    private int retryNum = 0;//假如設置為3次重試的話，則最大可能請求4次（默認1次+3次重試）

    public RetryIntercepter(int maxRetry) {
        this.maxRetry = maxRetry;
    }

    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        System.out.println("retryNum=" + retryNum);
        Response response = chain.proceed(request);
        while (!response.isSuccessful() && retryNum < maxRetry) {
            retryNum++;
            System.out.println("retryNum=" + retryNum);
            response = chain.proceed(request);
        }
        return response;
    }
}

#2.測試場景類：

public class RetryTest {
    String mUrl = "https://www.baidu.com/";
    OkHttpClient mClient;

    @Before
    public void setUp() {
        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BODY);

        mClient = new OkHttpClient.Builder()
                .addInterceptor(new RetryIntercepter(3))//重試
                .addInterceptor(logging)//網絡日志
                .addInterceptor(new TestInterceptor())//模擬網絡請求
                .build();
    }

    @Test
    public void testRequest() throws IOException {
        Request request = new Request.Builder()
                .url(mUrl)
                .build();
        Response response = mClient.newCall(request).execute();
        System.out.println("onResponse:" + response.body().string());
    }

    class TestInterceptor implements Interceptor {

        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            String url = request.url().toString();
            System.out.println("url=" + url);
            Response response = null;
            if (url.equals(mUrl)) {
                String responseString = "{\"message\":\"我是模擬的數據\"}";//模擬的錯誤的返回值
                response = new Response.Builder()
                        .code(400)
                        .request(request)
                        .protocol(Protocol.HTTP_1_0)
                        .body(ResponseBody.create(MediaType.parse("application/json"), responseString.getBytes()))
                        .addHeader("content-type", "application/json")
                        .build();
            } else {
                response = chain.proceed(request);
            }
            return response;
        }
    }

}

#3.輸出結果：

retryNum=0
--> GET https://www.baidu.com/ HTTP/1.1
--> END GET
url=https://www.baidu.com/
<-- 400 null https://www.baidu.com/ (13ms)
content-type: application/json

{"message":"我是模擬的數據"}
<-- END HTTP (35-byte body)
retryNum=1
--> GET https://www.baidu.com/ HTTP/1.1
--> END GET
url=https://www.baidu.com/
<-- 400 null https://www.baidu.com/ (0ms)
content-type: application/json

{"message":"我是模擬的數據"}
<-- END HTTP (35-byte body)
retryNum=2
--> GET https://www.baidu.com/ HTTP/1.1
--> END GET
url=https://www.baidu.com/
<-- 400 null https://www.baidu.com/ (0ms)
content-type: application/json

{"message":"我是模擬的數據"}
<-- END HTTP (35-byte body)
retryNum=3
--> GET https://www.baidu.com/ HTTP/1.1
--> END GET
url=https://www.baidu.com/
<-- 400 null https://www.baidu.com/ (0ms)
content-type: application/json

{"message":"我是模擬的數據"}
<-- END HTTP (35-byte body)
onResponse:{"message":"我是模擬的數據"}

#4.結果分析：
>1. 這里我用一個TestInterceptor攔截器攔截掉真實的網絡請求，實現response.code的自定義
2. 在RetryIntercepter中，通過response.isSuccessful()來對響應碼進行判斷，循環調用了多次chain.proceed(request)來實現重試攔截
3. 從輸出中可以看到，一共請求了4次（默認1次+重試3次）。

#5.其它實現方式
如果你是使用OkHttp+Retrofit+RxJava，你也可以使用retryWhen操作符：retryWhen(new RetryWithDelay())來實現重試機制

public class RetryWithDelay implements Func1<Observable<? extends Throwable>, Observable<?>> {

        private final int maxRetries;
        private final int retryDelayMillis;
        private int retryCount;

        public RetryWithDelay(int maxRetries, int retryDelayMillis) {
            this.maxRetries = maxRetries;
            this.retryDelayMillis = retryDelayMillis;
        }

        @Override
        public Observable<?> call(Observable<? extends Throwable> attempts) {
            return attempts
                    .flatMap(new Func1<Throwable, Observable<?>>() {
                        @Override
                        public Observable<?> call(Throwable throwable) {
                            if (++retryCount <= maxRetries) {
                                // When this Observable calls onNext, the original Observable will be retried (i.e. re-subscribed).
                                LogUtil.print("get error, it will try after " + retryDelayMillis + " millisecond, retry count " + retryCount);
                                return Observable.timer(retryDelayMillis,
                                        TimeUnit.MILLISECONDS);
                            }
                            // Max retries hit. Just pass the error along.
                            return Observable.error(throwable);
                        }
                    });
        }
}