阅读 1003

自己封装一个okhttp,一个看的懂的okhttp封装

前言:封装只是加深自己的理解,网上已经有很优秀的封装,我也是借鉴了okgo鸿洋的okhttputils。本项目是基于mvc模式下,但这篇只讲如何对okhttp进行封装(这里我按最基础步骤来,需要额外功能,看源码和本文理解,肯定可以实现)

我们封装要有的功能有:

  • 支持get请求
  • 支持post请求
  • 支持上传文件
  • 支持下载文件和断点续传
  • 有网络时,支持缓存(连接网络时的有效期)
  • 断开网络,支持离线缓存(离线缓存有效期)
  • 多次请求同一url,在网络还在请求时,是否只请求一次
  • 支持请求失败,自动重连

先看看我封装的效果(建议打开权限)

get请求 post请求 上传文件
下载文件

首先okhttp进行简单get请求代码是这样的:


OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .readTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(10, TimeUnit.SECONDS)
                .build();
        Request.Builder mBuilder = new Request.Builder();
        mBuilder.url("url?parm1=x&parm2=y");
        mBuilder.header("head","headValue");
        Request okHttpRequest = mBuilder.build();
        okHttpClient.newCall(okHttpRequest).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
 
            }
 
            @Override
            public void onResponse(Call call, Response response) throws IOException {
 
            }
        });
复制代码

get请求参数是拼在url后面的,而且上面是异步请求enqueue,这个方法是在子线程里的。回调onFailure和onResponse也都在子线程,我们可以把解析等耗时操作放在这里,但是这里不能直接更改UI,要把他切换到主线程里。

1、封装EasyOk

1.1 取消网络请求


//tag取消网络请求
    public void cancleOkhttpTag(String tag) {
        Dispatcher dispatcher = okHttpClient.dispatcher();
        synchronized (dispatcher) {
            //请求列表里的,取消网络请求
            for (Call call : dispatcher.queuedCalls()) {
                if (tag.equals(call.request().tag())) {
                    call.cancel();
                }
            }
            //正在请求网络的,取消网络请求
            for (Call call : dispatcher.runningCalls()) {
                if (tag.equals(call.request().tag())) {
                    call.cancel();
                }
            }
        }
    }
复制代码

可以看到,取消代码请求要用的okHttpClient,所以我们要保持okHttpClient的唯一性,EasyOk这里就要用到单例了

1.2 简单的EasyOk封装

public class EasyOk {
    private static EasyOk okHttpUtils;
    private OkHttpClient okHttpClient;
    //这个handler的作用是把子线程切换主线程。在后面接口中的具体实现,就不需要用handler去回调了
    private Handler mDelivery;
    private EasyOk() {
        mDelivery = new Handler(Looper.getMainLooper());
        okHttpClient = new OkHttpClient.Builder()
                .hostnameVerifier(new HostnameVerifier() {//证书信任
                    @Override
                    public boolean verify(String hostname, SSLSession session) {
                        return true;
                    }
                })
                .connectTimeout(10, TimeUnit.SECONDS)
                .readTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(10, TimeUnit.SECONDS)
                .build();
    }
 
 
    public static EasyOk getInstance() {
        if (okHttpUtils == null) {
            okHttpUtils = new EasyOk();
        }
        return okHttpUtils;
    }
 
 
    public OkHttpClient getOkHttpClient() {
        return okHttpClient;
    }
 
    public Handler getmDelivery() {
        return mDelivery;
    }
 
 
    //tag取消网络请求
    public void cancleOkhttpTag(String tag) {
        Dispatcher dispatcher = okHttpClient.dispatcher();
        synchronized (dispatcher) {
            //请求列表里的,取消网络请求
            for (Call call : dispatcher.queuedCalls()) {
                if (tag.equals(call.request().tag())) {
                    call.cancel();
                }
            }
            //正在请求网络的,取消网络请求
            for (Call call : dispatcher.runningCalls()) {
                if (tag.equals(call.request().tag())) {
                    call.cancel();
                }
            }
        }
    }
 
}
复制代码

mDelivery是将子线程切换到主线程的handler,这里借鉴了鸿洋大神的思路。因为我们最好把重复性的工作全部都放在封装里。封装最重要的优点不就是为了方便吗。

根据最原始的okhttp进行的get请求,我们还缺Request,还有一个网络请求的回调,那么请看下面。

2、封装OkGetBuilder(这里我将每种请求封装成了不同的Builder,虽然重复了好多操作,但更加清晰,偏于理解)

因为每次请求,Request 请求体都是需要new的,所以可想而知这里不可能是单例,而且每次调用请求都是new出来的Request。根据最原始的get请求,我们知道OkGetBuilder里需要1、url,2、参数,3、header,4、tag,5、还有自己的网络回调。

2.1 自定义请求回调抽象类(基于mvc二次封装建议用接口类)

所以我们得用有个网络回调接口,这里我用的是抽象类ResultMyCall,这里用抽象类的好处是,我们可以把统一重复操作放在父类里,只要不重写方法,都会按父类方法去实现,所以这里有时候你只需要重写一个onSuccess方法即可,不像接口一样要把方法全部实现。要注意的是,如果要基于mvc,最好用接口ResulCall,这块到时候介绍mvc的时候回介绍。现在我们都按抽象类ResultMyCall走。抽象类如下ResultMyCall

public abstract class ResultMyCall<T> {
 
    //请求网络之前,一般展示loading
    public void onBefore() {
        
    }
 
    //请求网络结束,消失loading
    public void onAfter() {
 
    }
 
    //监听上传图片的进度(目前支持图片上传,其他重写这个方法无效)
    public void inProgress(float progress) {
 
    }
 
 
    //错误信息
    public void onError(String errorMessage) {
        ToastUtils.showToast(errorMessage);
    }
 
    public void onSuccess(Object response) {
        
    }
 
    //如果带了泛型T,这里个方法会获取泛型的type,用于解析,如果不带泛型,默认返回的是String
    public Type getSuperclassTypeParameter(Class<?> subclass) {
        Type superclass = subclass.getGenericSuperclass();
        if (superclass instanceof Class) {
            return null;
        }
        ParameterizedType parameterized = (ParameterizedType) superclass;
        return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);
    }
 
    public Type getType() {
        return getSuperclassTypeParameter(getClass());
    }
 
 
}
复制代码

相信这个类也很容易理解,这里的OnError我写了一个Toast。所以每次请求的回调onError可以不重写,会自动弹Toast,如果你需要有其他操作,比如说不弹Toast,是需要打开另外一个页面则可以重写这个方法如:

            @Override
            public void onError(String errorMessage) {
                super.onError(errorMessage);
                //注释super.onError(errorMessage);那么不会走父类方法,
 
            }
复制代码

2.2 简单OkGetBuilder封装(去掉了部分代码,偏于理解清晰)

public class OkGetBuilder {

    private String url;
    private String tag;
    private Map<String, String> headers;
    private Map<String, String> params;


    private OkHttpClient okHttpClient;
    private Context context;
    private Handler mDelivery;
    private Request okHttpRequest;

    public OkGetBuilder() {
        this.okHttpClient = EasyOk.getInstance().getOkHttpClient();
        this.context = MyApplication.getContext();
        this.mDelivery = EasyOk.getInstance().getmDelivery();
    }


    public OkGetBuilder build() {
        Request.Builder mBuilder = new Request.Builder();
        if (params != null) {
            mBuilder.url(appendParams(url, params));
        } else {
            mBuilder.url(url);
        }

        if (!TextUtils.isEmpty(tag)) {
            mBuilder.tag(tag);
        }

        if (headers != null) {
            mBuilder.headers(appendHeaders(headers));
        }
        okHttpRequest = mBuilder.build();
        return this;
    }


    public void enqueue(final ResultMyCall resultMyCall) {
        if (resultMyCall != null) {
            mDelivery.post(new Runnable() {
                @Override
                public void run() {
                    resultMyCall.onBefore();
                }
            });
        }

        okHttpClient.newCall(okHttpRequest).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, final IOException e) {
                if (resultMyCall != null) {
                    mDelivery.post(new Runnable() {
                        @Override
                        public void run() {
                            resultMyCall.onAfter();
                            String errorMsg;
                            if (e instanceof SocketException) {

                            } else {
                                if (e instanceof ConnectException) {
                                    errorMsg = context.getString(R.string.network_unknow);
                                } else if (e instanceof SocketTimeoutException) {
                                    errorMsg = context.getString(R.string.network_overtime);
                                } else {
                                    errorMsg = context.getString(R.string.server_error);
                                }
                                resultMyCall.onError(errorMsg);
                            }


                        }
                    });

                }
            }

            @Override
            public void onResponse(Call call, final Response response) throws IOException {
                //网络请求成功
                if (response.isSuccessful()) {
                    if (resultMyCall != null) {
                        String result = response.body().string();
                        Object successObject = null;
                        try {
                            if (resultMyCall.getType() == null) {
                                successObject = result;
                            } else {
                                successObject = GsonUtil.deser(result, resultMyCall.getType());
                            }

                        } catch (Throwable e) {
                            mDelivery.post(new Runnable() {
                                @Override
                                public void run() {
                                    resultMyCall.onAfter();
                                    resultMyCall.onError("数据解析出错了");
                                }
                            });
                            return;
                        }

                        if (successObject == null) {
                            successObject = result;
                        }

                        final Object finalSuccessObject = successObject;
                        mDelivery.post(new Runnable() {
                            @Override
                            public void run() {
                                resultMyCall.onAfter();
                                resultMyCall.onSuccess(finalSuccessObject);
                            }
                        });

                    }
                } else {
                    //接口请求确实成功了,code 不是 200
                    if (resultMyCall != null) {
                        final String errorMsg = response.body().string();
                        mDelivery.post(new Runnable() {
                            @Override
                            public void run() {
                                resultMyCall.onAfter();
                                resultMyCall.onError(errorMsg);
                            }
                        });
                    }
                }

            }
        });
    }
    
    private Headers appendHeaders(Map<String, String> headers) {
        Headers.Builder headerBuilder = new Headers.Builder();
        if (headers == null || headers.isEmpty()) return null;

        for (String key : headers.keySet()) {
            headerBuilder.add(key, headers.get(key));
        }
        return headerBuilder.build();
    }

    //get 参数拼在url后面
    private String appendParams(String url, Map<String, String> params) {
        StringBuilder sb = new StringBuilder();
        if (url.indexOf("?") == -1) {
            sb.append(url + "?");
        } else {
            sb.append(url + "&");
        }

        if (params != null && !params.isEmpty()) {
            for (String key : params.keySet()) {
                sb.append(key).append("=").append(params.get(key)).append("&");
            }
        }
        sb = sb.deleteCharAt(sb.length() - 1);
        LogUtils.i("网络请求", "请求接口 ==>> " + sb.toString());
        return sb.toString();
    }
    
}
复制代码

首先我们new这个类的时候把唯一的okHttpClient拿到用来进行请求,把mDelivery拿到,用于子线程切换主线程,那么在后面的回调方法里可以直接进行UI操作。OkGetBuilder里要做的是把heads用map传入,那么要进行一个循环add到head上去如:appendHeaders方法,参数也用map传入,拼接参数如:appendParams方法。

那么接下来就是请求这块

  • 在调用自定义方法enqueue(我这里和okhttp重名了偏于理解),首先我们这里就要回调onBefore
  • 在原始回调失败onFailure里,当然是回调我们的onAfter和onError。
  • 在原始回调onResponse里,这里会比较麻烦,即使返回code=200;这里还有2种情况,一种是正常的按你传入的泛型解析,一种是比如:点击关注,网络请求也成功了,但接口问题返回关注失败。我们公司用的是status为0代表失败,这里要特别注意
  • OkGetBuilder封装好了,把它放进EasyOk里如下:
public static OkGetBuilder get() {
        return new OkGetBuilder();
    }
复制代码

3、最后封装后的进行GET请求用法如下:(其实post和上传文件都是这个思路,不同的是post有多种RequestBody,上传文件也是post的一种,这里具体可以看鸿洋和okgo的封装)

//这些是全部方法,没有用到的不使用
//paramsBuilder 是我封装用的一个传递参数的类。有要用的参数一致点下去就好了...
EasyOk.get().url("http://gank.io/api/xiandu/category/wow")
                .tag("cancleTag")
                //内部已经做了null处理,请求头部
                //.headers(paramsBuilder.getHeads())
                //内部已经做了null处理,请求参数
                //.params(paramsBuilder.getParams())
                .build().enqueue(new ResultMyCall<T>() {
            @Override
            public void onBefore() {
                super.onBefore();
 
            }
 
            @Override
            public void onAfter() {
                super.onAfter();
 
            }
 
 
            @Override
            public void onError(String errorMessage) {
                super.onError(errorMessage);
 
            }
 
            @Override
            public void onSuccess(Object response) {
                super.onSuccess(response);
               //如果你再new ResultMyCall的时候带了泛型,那么这里只需要
               //T bean = (T)response ;
               //如果没有带泛型,那么默认返回的string类型,
               //Sring bean = (String)response;
            }
        });
复制代码

如果onBefore和onAfter还有onError,都把统一操作封装好了并且不需要重写没有特殊操作的你可以这样:

EasyOk.get().url("http://gank.io/api/xiandu/category/wow")
                .tag("cancleTag")
                .build().enqueue(new ResultMyCall<T>() {
 
                @Override
                public void onSuccess(Object response) {
                super.onSuccess(response);
 
               //如果你再new ResultMyCall的时候带了泛型,那么这里只需要
               //T bean = (T)response ;
               //如果没有带泛型,那么默认返回的string类型,
               //Sring bean = (String)response;
 
                }
            });
复制代码

上面介绍我我把缓存和重连等其他功能没有说,因为加进去太复杂也不清晰,等后面单独拿出来讲,通过本文的理解,你会知道怎么去封装,加到什么地方去。

4、接下说的是下载文件及断点续传下载文件

经过上述介绍,咱们直接看OkDownloadBuilder里的内容(我把多余部分去掉了,便于理解):

public class OkDownloadBuilder {
    //断点续传的长度
    private long currentLength;
    private String url;
    private String tag;
    //文件路径(不包括文件名)
    private String path;
    //文件名
    private String fileName;

    //是否开启断点续传
    private boolean resume;
    private OkHttpClient okHttpClient;
    private Handler mDelivery;
    private Request.Builder mBuilder;

    public OkDownloadBuilder() {
        this.okHttpClient = EasyOk.getInstance().getOkHttpClient();
        this.mDelivery = EasyOk.getInstance().getmDelivery();
    }

    public OkDownloadBuilder build() {
        mBuilder = new Request.Builder();
        mBuilder.url(url);
        if (!TextUtils.isEmpty(tag)) {
            mBuilder.tag(tag);
        }
        //这里只要断点上传,总会走缓存。。所以强制网络下载
        mBuilder.cacheControl(CacheControl.FORCE_NETWORK);
        return this;
    }


    public void enqueue(final OnDownloadListener listener) {

        if (resume) {
            File exFile = new File(path, fileName);
            if (exFile.exists()) {
                currentLength = exFile.length();
                mBuilder.header("RANGE", "bytes=" + currentLength + "-");
            }
        }
        Request okHttpRequest = mBuilder.build();
        okHttpClient.newCall(okHttpRequest).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, final IOException e) {
                //下载失败监听回调
                mDelivery.post(new Runnable() {
                    @Override
                    public void run() {
                        listener.onDownloadFailed(e);
                    }
                });
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                InputStream is = null;
                byte[] buf = new byte[1024];
                int len = 0;
                FileOutputStream fos = null;

                //储存下载文件的目录
                File dir = new File(path);
                if (!dir.exists()) {
                    dir.mkdirs();
                }
                final File file = new File(dir, fileName);

                try {
                    is = response.body().byteStream();
                    //总长度
                    final long total;
                    //如果当前长度就等于要下载的长度,那么此文件就是下载好的文件
                    //前提是这里是默认下载的同意文件,要判断是否可以断点续传,最好在开启网络的时候判断是否是同意版本号
                    if (currentLength == response.body().contentLength()) {
                        mDelivery.post(new Runnable() {
                            @Override
                            public void run() {
                                listener.onDownloadSuccess(file);
                            }
                        });
                        return;
                    }
                    if (resume) {
                        total = response.body().contentLength() + currentLength;
                    } else {
                        total = response.body().contentLength();
                    }
                    mDelivery.post(new Runnable() {
                        @Override
                        public void run() {
                            listener.onDownLoadTotal(total);
                        }
                    });
                    if (resume) {
                        //这个方法是文件开始拼接
                        fos = new FileOutputStream(file, true);
                    } else {
                        //这个是不拼接,从头开始
                        fos = new FileOutputStream(file);
                    }
                    long sum;
                    if (resume) {
                        sum = currentLength;
                    } else {
                        sum = 0;
                    }
                    while ((len = is.read(buf)) != -1) {
                        fos.write(buf, 0, len);
                        sum += len;
                        final int progress = (int) (sum * 1.0f / total * 100);
                        //下载中更新进度条
                        mDelivery.post(new Runnable() {
                            @Override
                            public void run() {
                                listener.onDownloading(progress);
                            }
                        });

                    }
                    fos.flush();
                    //下载完成
                    mDelivery.post(new Runnable() {
                        @Override
                        public void run() {
                            listener.onDownloadSuccess(file);
                        }
                    });

                } catch (final Exception e) {
                    mDelivery.post(new Runnable() {
                        @Override
                        public void run() {
                            listener.onDownloadFailed(e);
                        }
                    });
                } finally {

                    try {
                        if (is != null) {
                            is.close();
                        }
                        if (fos != null) {
                            fos.close();
                        }
                    } catch (IOException e) {

                    }

                }


            }
        });

    }
}
复制代码

如果你不看断点续传这块,在onResponse里其实就是输入流和文件流,把流写进文件里的操作;断点的续传的关键点是哪些?要知道断点续传其实就是接着上次未下载的文件继续下载(当然这里要确保下载的是同一文件,如下载更新要保证是同一版本号,这里在获得版本更新内容的时候判断是否是同一版本)。关键有2点:

  • 在开启文件下载的时候,要在header里加上当前文件长度
mBuilder.header("RANGE", "bytes=" + currentLength + "-");
复制代码
  • 同时在文件流的时候要告诉流,我们不是覆盖,是拼接
fos = new FileOutputStream(file, true);//没错就是这个true
复制代码

5、有网的时候的在线缓存

场景如下:假如首页广告,get请求下来的数据,而且这个可能1个星期才会换一次数据,这个时候如果没有这个功能,每次进首页都会去请求网络,如果有这功能,那么如果缓存内容在有效期就会跳过网络请求,直接取缓存。这样节约流量之余还能减轻服务器压力。当然要实现缓存,要设置缓存文件,在初始化okHttpClient时候设置缓存文件

//设置缓存文件路径,和文件大小
okHttpClent.cache(new Cache(new File(Environment.getExternalStorageDirectory() +"/okhttp_cache/"), 50 * 1024 * 1024))
复制代码

查阅大量的资料,大量博客都很坑。坑的你懵逼这里给大家看下正解:okhttp缓存正解,文字地址
看到这篇的时候,你就知道其他地方都可以不用管,用拦截器可以实现,但是要清楚什么是在线缓存,什么是离线缓存。这是2个概念。在线缓存需要加网络拦截器

okHttpClient.addNetworkInterceptor(NetCacheInterceptor.getInstance())
复制代码

这里用的拦截器,我使用了单例,这样便于通过改变参数,可以达到是否使用缓存;NetCacheIntertor代码如下:

/**
 * Created by leo
 * on 2019/7/25.
 * 在有网络的情况下
 * 如果还在网络有效期呢则取缓存,否则请求网络
 * 重点 : 一般okhttp只缓存不大改变的数据适合get。(个人理解 : 例如你设置了我的方案列表接口的缓存后,你删除了一条方案,刷新下。
 * 他取的是缓存,结果那条删除的数据会出来。这个时候这个接口,不适合用缓存了)
 * (这里注意,如果一个接口设置了缓存30秒,下次请求这个接口的30秒内都会去取缓存,即使你设置0也不起效。因为缓存文件里的标识里已经有30秒的有效期)
 */
public class NetCacheInterceptor implements Interceptor {
    private static NetCacheInterceptor cacheInterceptor;
    //30在线的时候的缓存过期时间,如果想要不缓存,直接时间设置为0
    private int onlineCacheTime;
 
    public static NetCacheInterceptor getInstance() {
        if (cacheInterceptor == null) {
            cacheInterceptor = new NetCacheInterceptor();
        }
        return cacheInterceptor;
    }
 
    private NetCacheInterceptor() {
 
    }
 
    public void setOnlineTime(int time) {
        this.onlineCacheTime = time;
    }
 
 
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Request.Builder builder1 = request.newBuilder();
        //这里我们登陆,在head里获取令牌token存起来,网络请求的时候把令牌加入head,用于身份区分
        String token = (String) PreferenceUtil.get("USER_TOKEN", "");
        if (!TextUtils.isEmpty(token)) {
            builder1.addHeader("Token", token)
                    .build();
        }
        request = builder1.build();
        Response response = chain.proceed(request);
        List<String> list = response.headers().values("Token");
        if (list.size() > 0) {
            PreferenceUtil.put("USER_TOKEN", list.get(0));
        }
 
        
 
        //这里是设置缓存的操作
        if (onlineCacheTime != 0) {
            //如果有时间就设置缓存
            int temp = onlineCacheTime;
            Response response1 = response.newBuilder()
                    .header("Cache-Control", "public, max-age=" + temp)
                    .removeHeader("Pragma")
                    .build();
            onlineCacheTime = 0;
            return response1;
        } else {
            //如果没有时间就不缓存
            Response response1 = response.newBuilder()
                    .header("Cache-Control", "no-cache")
                    .removeHeader("Pragma")
                    .build();
            return response1;
        }
//        return response;
    }
}
复制代码

max-age是在线缓存的有效时间,如果我设置了max-age = 3600,那么意思是在首次请求网络缓存下来的数据后,在1小时之内都将会直接取缓存,跳过网络请求。这里我获取token是通过拦截器获取的,response.headers()可以获得,服务器返回的所有head信息,包括set-cookie信息。而且okhttp提供了.cookjar()。可以通过cookie持久化等自定义

这些设置完怎么验证呢?回到你原始网络请求onResponse回调里;通过:

                if (response.networkResponse()!=null){
                    LogUtils.i("内容来源","来自网络请求");
                }
                if (response.cacheResponse()!=null){
                    LogUtils.i("内容来源","来自缓存");
                }
复制代码

当然这里只是验证,在onResponse不需要改变,okhttp内部已经做好了所有的工作。

6、无网络的时候的离线缓存

例如腾讯新闻等,在你手机开启飞行模式的时候,在进app的时候,还是会依旧显示之前加载的数据。这个是就是离线缓存,离线缓存和在线缓存最大的区别,在线缓存即使有条件请求网络也可以跳过网络取缓存。同样通过拦截器添加,在无网络的时候,是不会走addNetworkInterceptor方法的。但是通过addInterceptor,有没有网都会走,而且addInterceptor会先于addNetworkInterceptor运行

okHttpClient.addInterceptor(OfflineCacheInterceptor.getInstance());
复制代码

同样用了单例,具体如下:

/**
 * Created by leo
 * on 2019/7/25.
 * 这个会比网络拦截器先 运行
 * 在没有网络连接的时候,会取的缓存
 * 重点 : 一般okhttp只缓存不大改变的数据适合get。(个人理解,无网络的时候可以将无网络有效期改长点)
 * 这里和前面的不同,立即设置,立即生效。例,你一个接口设置1个小时的离线缓存有效期,立即设置0.下次进入后,则无效
 */
public class OfflineCacheInterceptor implements Interceptor {
    private static OfflineCacheInterceptor offlineCacheInterceptor;
    //离线的时候的缓存的过期时间
    private int offlineCacheTime;
 
    private OfflineCacheInterceptor() {
 
    }
 
    public static OfflineCacheInterceptor getInstance() {
        if (offlineCacheInterceptor == null) {
            offlineCacheInterceptor = new OfflineCacheInterceptor();
        }
        return offlineCacheInterceptor;
    }
 
    public void setOfflineCacheTime(int time) {
        this.offlineCacheTime = time;
    }
 
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
 
        if (!NetWorkUtils.isNetworkConnected(MyApplication.getContext())) {
            if (offlineCacheTime != 0) {
                int temp = offlineCacheTime;
                request = request.newBuilder()
//                        .cacheControl(new CacheControl
//                                .Builder()
//                                .maxStale(60,TimeUnit.SECONDS)
//                                .onlyIfCached()
//                                .build()
//                        ) 两种方式结果是一样的,写法不同
                        .header("Cache-Control", "public, only-if-cached, max-stale=" + temp)
                        .build();
                offlineCacheTime = 0;
            } else {
                request = request.newBuilder()
                        .header("Cache-Control", "no-cache")
                        .build();
            }
        }
        return chain.proceed(request);
    }
}
复制代码

NetWorkUtils是一个判断有没有网络的工具类。你可以看到这里是max-stale,这里我理解就是要设置的离线缓存有效期,如果设置为max-stale=3600就是离线缓存1个小时。如果你去深山老林,在长达1小时01分的时候,离线缓存失效,那么你在此进app,页面将空白。当然你也可以设置离线缓存一直有效,Integer.MAX_VALUE。

7、多次请求同一url,在网络请求未结束,是否只请求一次

这里当然你可以利用tag来做,如果当前正在请求的池里的call.request.tag()或等待请求队列里的tag,包含你当前请求网络tag时,则不请求网络,只显示loading。但是这样的话必须每次都要加上tag。所以我直接在EasyOk里加上了一个

//防止网络重复请求的tagList;
private ArrayList<String> onesTag;
复制代码

如果没有tag的时候,这里我可以用请求url。在网络请求成功和结束的时候我从这个集合里remove掉这个元素。当然你会说,当我们取消网络请求的时候呢,其实取消网络请求的时候会走onFailure(Call call,IOException e)。这个时候错误类型是SocketException。所以你取消网络的时候是会走onFailure,同样会remove掉、代码大致如下(只放相关代码):

public void enqueue(final ResultCall resultMyCall) {
        if (resultMyCall != null) {
            //这里是子线程切换到主线程的操作,只要请求网络,我们都调onBefore,这里就是展示loading
            mDelivery.post(new Runnable() {
                @Override
                public void run() {
                    resultMyCall.onBefore();
                }
            });
        }
 
        
        //这里是否带了onlyOneNet参数,默认是不开启的,return后将不继续往下走,就不会开启网络了
        
        if (onlyOneNet) {
            if (!TextUtils.isEmpty(tag)) {
                if (EasyOk.getInstance().getOnesTag().contains(tag)) {
                    return;
                }
                EasyOk.getInstance().getOnesTag().add(tag);
            } else {
                if (EasyOk.getInstance().getOnesTag().contains(url)) {
                    return;
                }
                EasyOk.getInstance().getOnesTag().add(url);
            }
        }
 
        ...
 
}
复制代码

8、请求失败自动重连,以及重连次数

这里也查阅了大量博客,都说okhttp有设置重连,设置okHttpClient.retryOnConnectionFailure(true)既可用重连,但是我大量测试发现,然并软(有明白的小伙伴,求告知)。这里我用了自己的方式,只要走onFailure,那么我们看看有没有设置重连和重连次数,代码如下,此代码都在builder下,每次网络请求都会new一个builder,以OkGetBuilder为例:

okHttpClient.newCall(okHttpRequest).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, final IOException e) {
                //这里是取消网络请求,那么不用重连了
                if (e instanceof SocketException) {
 
                } else {
                    //tryAgainCount是重连,不设置,默认是0.不开启重连功能
                    //currentAgainCount,是OkGetBuilder里的属性,每次开启网络都会new一个Builder
                    //当然currentAgainCount初始是0
                    if (currentAgainCount < tryAgainCount && tryAgainCount > 0) { 
                        currentAgainCount++;
                        //这里就是重连操作,call.request会获取你最开始的request
                        //this这里就是你当前new Callback,所以网络回调还会走这里
                        okHttpClient.newCall(call.request()).enqueue(this);
                        return;
                    }
                }
        
        }
复制代码

至此,大致介绍完了。以上介绍的到底怎么用。可以去我的github上的介绍,看看以上的用法

9、那么基于mvc封装怎么用,下面我们具体来说本项目封装的用法

我定义了NetWorListener(get,post,上传文件网络回调),OnDownloadListener(文件下载网络回调),PermissionListener(权限申请结果回调),如果你想请求网络,只要实现这个接口,然后通过ModelSuperImpl去调用网络请求,就能在任何你实现这个接口的页面拿到网络请求回调,请求只需要这样:

//在外面调用只需要传入参数,把url和解析类什么的都放在ModelSuperImpl里
ModelSuperImpl.netWork().gankGet(ParamsBuilder.build().params(PARAMS.gank("android")) .command(GANK_COMMAND), this);
复制代码

ModelSuperImpl大致如下

public class ModelSuperImpl extends ModelBase {
    private static final ModelSuperImpl ourInstance = new ModelSuperImpl();
 
    public static ModelSuperImpl netWork() {
        return ourInstance;
    }
 
    public static ModelPermissionImpl permission() {
        return new ModelPermissionImpl();
    }
 
    private ModelSuperImpl() {
 
    }
 
   
    public void gankGet(ParamsBuilder paramsBuilder, NetWorkListener netWorkListener) {
        paramsBuilder.url(SystemConst.GANK_GET)
                .type(new TypeToken<ResponModel<User>>() {
                }.getType())
        ;
        sendOkHttpGet(paramsBuilder, netWorkListener);
    }
}

复制代码

在Activity/Fragment里或是只要实现接口(NetWorListener)的地方拿到回调就是这样,command是为了区分一个页面可能请求多个网络请求:

@Override
public void onNetCallBack(int command, Object object) {
    switch (command) {
        case GANK_COMMAND:
            Response<User> userModel = (Response<User>)object;
            break;
    }
}
复制代码

这里的ParamsBuilder有多个参数具体如下(去掉部分代码,偏于理解):


public class ParamsBuilder {
    //请求网络的url(必填)
    private String url;
    //网络回调的int值(必填)
    private int command;
    //网络返回的type类型(选填)不填,则会返回string类型
    private Type type;
    //网络请求需要带的头部信息(选填,不填为null)
    private HashMap<String, String> heads;
    //网络请求需要带的参数(选填,不填为null)
    private HashMap<String, String> params;
    //网络loading需要带的文字信息(选填,不填为null)
    private String loadMessage;
    //是否显示网络loading(默认为显示loading)
    private boolean isShowDialog = true;
    //网络请求的tag,可根据tag取消网络请求(选填,不填:默认当前宿主类名,退出后自动取消)
    private String tag;
    //是否重写网络问题还是超时问题对回调进行一个重写
    //如果是true,则在回调的时候可对那部分额外操作,除了弹提示还可以做别的操作
    //(选填,不填:重写不了且只弹提示)
    private boolean overrideError;
    //json上传要带的参数
    private String json;
    //网络接口code=200, 但没有成功,此用户已关注
    //需要重写带true,重写可以写逻辑包括弹提示
    //不需要重写只弹提示
    private boolean successErrorOverrid;
 
    //离线缓存时间  单位秒
    private int cacheOfflineTime;
    //有网络请求时缓存最大时间
    private int cacheOnlineTime;
    //多次点击按钮,只进行一次联网请求
    //场景:网络还在loading,又点了一次请求,那么不发送新请求,只显示loading
    private boolean onlyOneNet = true;
    //联网失败,重试次数
    private int tryAgainCount;
    //如果是在网络请求接口回调不是activity,也不是fragment,用于传context
    
    //用于showdialog,当请求网络的页面不是Activity或是Fragment时必传
    private Context context;
 
 
    /**
     * 下载文件才用的到
     */
    private String path;
    private String fileName;
    //是否开启断点续传,要注意的是开启断点续传,要保证下载的是同一文件
    //默认是不开启断点续传,除非判断要下载文件和当前未下载文件属于同一文件
    //如果不是那么重新下载,会清掉之前的文件。
    private boolean resume;
 
}
复制代码

看到上面,具体设计的参数都写上了。但是我没有封装的很完美,当然必传的字段,没传时,你可以throw new NullPonintException("参数没传");把异常抛出去,一旦不传,程序就崩溃了。

同样在下载文件只需要实现OnDownliadListener,即可。调用只需要这样:

ModelSuperImpl.netWork().downApk(ParamsBuilder.build().path(path)
        .fileName(fileName).tag("downApk"), this);
复制代码

这里我把请求权限所有逻辑封装在了 ModelPerissionImpl里,只要实现PerimissionListener即可拿到网络请求回调,调用只需这样:

/RESUME_COMMAND一个页面可能要请求多个权限,用于区分,this即是PerimissionListener实现类,后面权限参数是可变的如果有多个权限可以一直逗号加下去
ModelSuperImpl.permission().requestPermission(RESUME_COMMAND, this, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE);
复制代码

回调只需这样:

//回调只需要这样;command是区分一个页面多个权限申请,如果一个页面只有1个申请那么可以不传commad
@Override
    public void permissionSuccess(int command) {
        switch (command) {
            case NORMAL_COMMAND:
                ModelSuperImpl.netWork().downApk(ParamsBuilder.build().path(path)
                        .fileName(fileName).tag("downApk"), this);
                break;
           
        }
    }
复制代码

大致思路:我把具体的联网操作和具体的解析封装在了抽象类ModelBase,把具体的权限申请逻辑封装在了ModelPerissionImpl,ModelSuperImpl只负责调用网络请求方法,和权限申请方法,这样代码完美分隔了代码。视图层View收到了用户的操作或点击请求,响应controller,controller通知model处理逻辑业务,拿到结果通过接口告诉controller去更新Ui。加入你多个页面需要请求同一个url,你只需要通过ModelSuperImpl去调用方法就Ok了。

这里肯定很多人对ParamBuilder里的overrideError和successErrorOverrid不是很理解。其实这里默认不是重写方法,例如网络请求失败,我在ModelBase默认是弹出toast,如果是code=200,但是有可能接口走的错误方法,如关注失败,我也是默认不重写弹出toast。有可能实际操作需要我们做别的,如网络请求错误,需要我们跳另外一个页面,那么这个时候就需要你带.overrideError(true)和.successErrorOverrid(true)代码如下:

@Override
    public void onNetCallBack(int command, Object object) {
        switch (command) {
            case GANK_COMMAND:
                /**
                 * 请求接口失败(网络错误,或超时等造成)
                 * 如果需要重写则请求接口的时候加上.overrideError(true)
                 * 那么在下面代码写上逻辑,如果不需要重写,已经封住了会自动弹出错误提示,而且重            
                    写会无效
                 * */
 
//                if (obj instanceof NetFail) {
//                    NetFail netFailBean = (NetFail) obj;
//                    处理逻辑
//                    return;
//                }
 
                /**
                 * 这是接口请求成功
                 * 如果请求接口,写了.successErrorOverrid(true)
                 * 说明重写了虽然code=200,返回的result 不是1;但是需要做其他逻辑不只是Toast才需要true
                 * 如果只是需要Toast错误信息,那么可以不写,下面的就不用重写了。封装已经默认弹提示
                 * */
//                if (obj instanceof ErrorBean) {
//                    ErrorBean errorBean = (ErrorBean) obj;
//                    处理逻辑
//                    return;
//                }
 
 
                
                ResponModel<User> detailModel = (ResponModel<User>) obj;
                //更新UI
                break;
        }
    }
复制代码

结束语:我个人思路封装。如有不对欢迎指正,且如果有更好的思路欢迎留言。技术界的小学生,喜欢学习。看到这里,如果有帮助到你,帮博主star下吧

github传送门

记得把builder里的EventBus全部删除,我之前没考虑太多,所以在展示效果的时候用EventBus传递了p.p
当然这里用的泛型类ResponModel,ErrorBean,NetFail都是我根据我的项目来定义的,记得如有数据结构不同请修改成需要的

关注下面的标签,发现更多相似文章
评论