Request 1 -> Interceptor 1 -> Interceptor 2 -> ... -> Interceptor N -> Server
                            <-                <- ... <-                <-
Response 1 <- Interceptor 1 <- Interceptor 2 <- ... <- Interceptor N <- Server

OkHttpClient client = new OkHttpClient.Builder()
    .addInterceptor(new CustomInterceptor())
    .build();

Request request = new Request.Builder()
    .url("https://example.com/api")
    .build();
Call call = client.newCall(request);
Response response = call.execute();

public Response getResponseWithInterceptorChain() throws IOException {
    // 創(chuàng)建一個初始的Interceptor.Chain
    List<Interceptor> interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());
    interceptors.add(retryAndFollowUpInterceptor);
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    interceptors.add(new CacheInterceptor(client.internalCache()));
    interceptors.add(new ConnectInterceptor(client));
    interceptors.add(new CallServerInterceptor(false));
    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, 0, originalRequest, this, callStackTrace);
    // 依次執(zhí)行攔截器
    return chain.proceed(originalRequest);
}

public Response proceed(Request request) throws IOException {
    // 執(zhí)行下一個攔截器或者發(fā)起網(wǎng)絡請求
    if (index >= interceptors.size()) throw new AssertionError();
    calls++;
    if (chain == null) throw new IllegalStateException("Check failed.");
    if (eventListener != null) {
        eventListener.callStart(this);
    }
    // 獲取當前攔截器
    Interceptor interceptor = interceptors.get(index++);
    // 調(diào)用攔截器的intercept方法，將請求傳遞給下一個攔截器或者執(zhí)行網(wǎng)絡請求
    Response response = interceptor.intercept(this);
    if (eventListener != null) {
        eventListener.callEnd(this);
    }
    return response;
}

public class CustomInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        // 在請求前執(zhí)行的代碼
        Request originalRequest = chain.request();
        // 可以修改請求
        Request modifiedRequest = originalRequest.newBuilder()
                .addHeader("Authorization", "Bearer YourAccessToken")
                .build();
        // 執(zhí)行請求
        Response response = chain.proceed(modifiedRequest);
        // 在響應后執(zhí)行的代碼
        // 可以修改響應
        return response;
    }
}

public class LoggingInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        long startTime = System.nanoTime();
        Log.d("OkHttp", String.format("Sending request %s on %s%n%s",
            request.url(), chain.connection(), request.headers()));
        Response response = chain.proceed(request);
        long endTime = System.nanoTime();
        Log.d("OkHttp", String.format("Received response for %s in %.1fms%n%s",
            response.request().url(), (endTime - startTime) / 1e6d, response.headers()));
        return response;
    }
}

public class AuthInterceptor implements Interceptor {
    private final String authToken;
    public AuthInterceptor(String authToken) {
        this.authToken = authToken;
    }
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request originalRequest = chain.request();
        // 添加身份驗證標頭
        Request authenticatedRequest = originalRequest.newBuilder()
                .header("Authorization", "Bearer " + authToken)
                .build();
        return chain.proceed(authenticatedRequest);
    }
}

public class CacheInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        // 在這里檢查是否有緩存可用，如果有，返回緩存的響應
        Response response = chain.proceed(request);
        // 在這里將響應緩存起來
        return response;
    }
}

public class RetryInterceptor implements Interceptor {
    private final int maxRetryCount;
    public RetryInterceptor(int maxRetryCount) {
        this.maxRetryCount = maxRetryCount;
    }
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response response = null;
        IOException lastException = null;
        for (int retryCount = 0; retryCount < maxRetryCount; retryCount++) {
            try {
                response = chain.proceed(request);
                if (response.isSuccessful()) {
                    return response;
                }
            } catch (IOException e) {
                lastException = e;
            }
        }
        // 如果達到最大重試次數(shù)仍然失敗，拋出異常
        throw lastException;
    }
}

public class ResponseProcessingInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response response = chain.proceed(request);
        // 在這里對響應進行自定義處理
        return response;
    }
}

public class ErrorHandlingInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        try {
            Response response = chain.proceed(request);
            // 檢查響應是否成功
            if (!response.isSuccessful()) {
                // 在這里處理錯誤，可以拋出自定義異常
                throw new MyHttpException(response.code(), response.message());
            }
            return response;
        } catch (IOException e) {
            // 在這里處理網(wǎng)絡連接錯誤
            throw new MyNetworkException(e.getMessage(), e);
        }
    }
}

public class RedirectInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response response = chain.proceed(request);
        // 檢查是否是重定向響應
        if (response.isRedirect()) {
            String newUrl = response.header("Location");
            if (newUrl != null) {
                // 構建新的請求并繼續(xù)
                Request newRequest = request.newBuilder()
                        .url(newUrl)
                        .build();
                response = chain.proceed(newRequest);
            }
        }
        return response;
    }
}