了解 OkHttp 的 IO 操作和进度监听：高级教程

Android

2023-11-10 00:35:11

在现代应用程序中，网络交互至关重要，OkHttp 是 Android 和 Java 开发人员使用广泛的 HTTP 客户端库。它的 IO 操作和进度监听功能对于优化网络通信和提供更好的用户体验至关重要。

本文将深入探讨 OkHttp 的 IO 操作流程，展示如何通过拦截器实现进度监听，从而实现定制的上传和下载体验。

OkHttp 的 IO 操作流程

OkHttp 使用非阻塞 I/O 模型，该模型依赖于回调来异步处理网络请求和响应。当一个请求被发送时，OkHttp 会创建一个异步连接，用于在后台发送和接收数据。

请求体操作

当请求包含一个请求体时，OkHttp 会将该请求体写入一个输出流。输出流将数据缓冲到一个缓冲区，直到缓冲区已满或数据已被完全写入。然后，数据将被分块发送到网络。

响应体操作

当服务器响应到达时，OkHttp 会从输入流中读取响应体。输入流将数据缓冲到一个缓冲区，直到缓冲区已满或数据已被完全读取。然后，数据将被传递给应用程序。

进度监听

OkHttp 提供了拦截器机制，允许开发人员在请求和响应生命周期中插入自定义代码。通过实现 Interceptor 接口，我们可以拦截请求或响应，并在数据被写入或读取时执行自定义逻辑。

实现进度监听

为了实现进度监听，我们需要创建一个 Interceptor 实现，它可以拦截请求和响应，并更新进度信息。

public class ProgressInterceptor implements Interceptor {

    private ProgressListener listener;

    public ProgressInterceptor(ProgressListener listener) {
        this.listener = listener;
    }

    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response response = chain.proceed(request);

        // 请求监听
        RequestBody requestBody = request.body();
        if (requestBody != null) {
            requestBody = new ProgressRequestBody(requestBody, listener);
        }
        Request updatedRequest = request.newBuilder().body(requestBody).build();

        // 响应监听
        ResponseBody responseBody = response.body();
        if (responseBody != null) {
            responseBody = new ProgressResponseBody(responseBody, listener);
        }
        Response updatedResponse = response.newBuilder().body(responseBody).build();

        return updatedResponse;
    }

    // 进度监听接口
    public interface ProgressListener {
        void update(long bytesRead, long contentLength);
    }

    // 带有进度监听的请求体
    public static class ProgressRequestBody extends RequestBody {

        private final RequestBody delegate;
        private final ProgressListener listener;

        public ProgressRequestBody(RequestBody delegate, ProgressListener listener) {
            this.delegate = delegate;
            this.listener = listener;
        }

        @Override
        public MediaType contentType() {
            return delegate.contentType();
        }

        @Override
        public long contentLength() {
            return delegate.contentLength();
        }

        @Override
        public void writeTo(BufferedSink sink) throws IOException {
            CountingSink countingSink = new CountingSink(sink);
            delegate.writeTo(countingSink);
            listener.update(countingSink.bytesWritten(), contentLength());
        }

        // 计算写入的字节数
        private class CountingSink extends ForwardingSink {

            private long bytesWritten = 0;

            public CountingSink(Sink delegate) {
                super(delegate);
            }

            @Override
            public void write(Buffer source, long byteCount) throws IOException {
                super.write(source, byteCount);
                bytesWritten += byteCount;
            }
        }
    }

    // 带有进度监听的响应体
    public static class ProgressResponseBody extends ResponseBody {

        private final ResponseBody delegate;
        private final ProgressListener listener;

        public ProgressResponseBody(ResponseBody delegate, ProgressListener listener) {
            this.delegate = delegate;
            this.listener = listener;
        }

        @Override
        public MediaType contentType() {
            return delegate.contentType();
        }

        @Override
        public long contentLength() {
            return delegate.contentLength();
        }

        @Override
        public BufferedSource source() {
            CountingSource countingSource = new CountingSource(delegate.source());
            listener.update(countingSource.bytesRead(), contentLength());
            return countingSource;
        }

        // 计算读取的字节数
        private class CountingSource extends ForwardingSource {

            private long bytesRead = 0;

            public CountingSource(Source delegate) {
                super(delegate);
            }

            @Override
            public long read(Buffer sink, long byteCount) throws IOException {
                long bytesRead = super.read(sink, byteCount);
                if (bytesRead != -1) {
                    this.bytesRead += bytesRead;
                }
                return bytesRead;
            }
        }
    }
}

使用进度监听

要在应用程序中使用进度监听，可以创建一个 ProgressInterceptor 实例，并将其添加到 OkHttpClient 构建器中：

OkHttpClient client = new OkHttpClient.Builder()
    .addInterceptor(new ProgressInterceptor(new ProgressListener() {
        @Override
        public void update(long bytesRead, long contentLength) {
            // 更新进度 UI
        }
    }))
    .build();