第三方开源库 OKHttp - 上传进度监听和自定义缓存

最近这段时间的确有点忙，要处理的事情比较多，发现好久没有更新文章了，以后尽量一周更新一篇，这周要视频的人也特多，希望我们看了要多花点时间消化，最好我们自己能写一下总结，千万别又还给我了。那位替我打广告的哥们，虽然我不知道你是谁，但是打心底里说声谢谢。

OkHttp 我们总共花了四次去分析源码，花那么多时间去看源码到底是为了啥？其实每个人想的都不一样，有人觉得会用就很不错了，对于我来说我就是喜欢琢磨琢磨而已。但是开发过程中分析源码，对于我们其实会有很多好处，比如现在我想要监听文件上传的进度，又或者是我想要自定义缓存，又或者说我想要断点下载等等。当然这些网上都有，大家也都基本一个模板，但关键我们是否明白为什么要这么写？是否能够看得懂人家的代码？而这一切的一切在分析源码之后，我们不光能看懂别人为什么这么写，还能从源码的角度自己去分析扩展。

这里分析开发中最常见的几个扩展：
1. 文件上传进度监听
2. 自定义缓存（要求：有网 30s 内请求读缓存，无网直接读缓存）
3. 多线程断点下载

1.文件上传进度监听

---

我们先看下 OkHttp 上传文件是怎么写的，至于 OkHttp 怎么使用？这里不做过多的介绍，而且对于文件上传我们之前自己动手写过，直接贴代码：

        File file = new File(Environment.getExternalStorageDirectory(), "test.png");

        OkHttpClient httpClient = new OkHttpClient();
        // 构建请求 Body , 这个我们之前自己动手写过
        MultipartBody.Builder builder = new MultipartBody.Builder()
                .setType(MultipartBody.FORM);
        builder.addFormDataPart("platform", "android");
        builder.addFormDataPart("file", file.getName(),
                RequestBody.create(MediaType.parse(guessMimeType(file.getAbsolutePath())), file));
        // 构建一个请求
        final Request request = new Request.Builder()
                .url("https://www.easyjoke.com/xxxxx")
                .post(builder.build()).build();
        // new RealCall 发起请求
        Call call = httpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                Log.e("TAG", response.body().string());
            }
        });

怎么去添加进度？这个时候尽可能运用所有的脑细胞。先跑到源码中 CallServerInterceptor 这个拦截器，之前分析源码的时候说过，所有的读写操作都在这里，有这么一行向服务器写数据的代码：

BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);
// 调用 RequestBody的writeTo方法向服务器去写数据
request.body().writeTo(bufferedRequestBody);

看到上面这行代码，我们能够分析出，最终肯定会来到 MultipartBody 中的 writeTo 的方法。那么我们在这个方法里面去做处理不就行了，我们自己扩展一个 ExRequestBody 去继承 MultipartBody 然后复写 writeTo 方法做处理，但是发现 MultipartBody 是一个 final 类，不能继承这个时候怎么办？嗨，醒醒，不能继承怎么办？还好之前学了设计模式，设计模式学了就是要用的，用 静态代理 不就刚好能解决这个问题？

/**
 * description: RequestBody代理
 * author: Darren on 2017/11/24 10:16
 * email: [email protected]
 * version: 1.0
 */
public class ExRequestBody extends RequestBody {
    // 被代理的对象
    private RequestBody mOriginalBody;
    // 总的长度
    private long mTotalLength = -1;
    // 当前上传的长度
    private long mCurrentLength = -1;

    public ExRequestBody(RequestBody requestBody) {
        this.mOriginalBody = requestBody;
    }

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

    @Override
    public long contentLength() throws IOException {
        return mOriginalBody.contentLength();
    }

    @Override
    public void writeTo(BufferedSink sink) throws IOException {
        // Log.e("TAG", "进来了");
        // 获取总的长度
        mTotalLength = contentLength();

        // 这里又是一个代理模式
        ForwardingSink forwardingSink = new ForwardingSink(sink) {
            @Override
            public void write(Buffer source, long byteCount) throws IOException {
                super.write(source, byteCount);
                // 写了多少数据叠加起来
                mCurrentLength += byteCount;
                // 我们要自己写一个接口回调出去
                // Log.e("TAG", "-> " + mCurrentLength + " -> " + mContentLength);
            }
        };
        sink = Okio.buffer(forwardingSink);
        // 最终调用者还是被代理对象的方法
        mOriginalBody.writeTo(sink);
        // 一定要刷新，之前说过的连接池，复用等等
        sink.flush();
    }
}

2. 自定义缓存（要求：有网 30s 内请求读缓存，无网直接读缓存）

---

关于缓存的处理，我们需要了解我们之前所讲的缓存策略，熟读 CacheInterceptor 这个拦截器的源码就可以了，网上我看了很多例子，虽说效果都达到了，但准确的说应该分为两个部分去处理：
CacheRequestInterceptor

public class CacheRequestInterceptor implements Interceptor {
    private Context context;

    public CacheRequestInterceptor(Context context) {
        this.context = context;
    }

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

        if(!NetworkUtil.isNetworkAvailable(context)){
            // 直接读缓存
            request = request.newBuilder()
                    .cacheControl(CacheControl.FORCE_CACHE)
                    .build();
        }

        Response response = chain.proceed(request);
        return response;
    }
}

CacheResponseInterceptor

public class CacheResponseInterceptor implements Interceptor {

    @Override
    public Response intercept(Chain chain) throws IOException {
        // 有网的情况下 30s 之内访问同一接口，会直接读缓存，不会重复访问
        Request request = chain.request();
        Response response = chain.proceed(request);

        int maxAge = 30;
        return response.newBuilder()
                .removeHeader("Pragma")
                .removeHeader("Cache-Control")
                // max-age 是一种特例，既包含缓存策略又包含缓存过期时间
                .header("Cache-Control", "max-age=" + maxAge)
                .build();
    }
}

使用

.cache(cache)//开启缓存
// 一个添加在前
.addInterceptor(new CacheRequestInterceptor(MainActivity.this))
// 一个添加在后
.addNetworkInterceptor(new CacheResponseInterceptor())

OkHttp 自带的这种缓存的扩展还是会有一些坑的，比如不支持 post 数据缓存，某些特定接口也不应该这样去处理，所以我们还得会自己管理缓存，当然如果你对源码已经足够了解，什么事干不出来？

所有分享大纲：Android进阶之旅 - 系统架构篇

视频讲解地址：http://pan.baidu.com/s/1gfmzfYN