Android OKHttp3 二次封装网络框架

2020-02-26 本文已影响0人极客匠

简介：OKHttp是一个Android当前最火的处理网络请求第三方框架库，由移动支付Square公司开源贡献的。用于替代HttpUrlConnection和Apache HttpClient(android API23 6.0里已移除HttpClient）。

封装

对第三方框架进行封装，是为了达到对模块项目的控制，已最小的代价替换框架，达到对项目的控制。

首先看一下OKHttp的使用

private static OkHttpClient okHttpClient = new OkHttpClient.Builder().connectTimeout(10, TimeUnit.SECONDS).writeTimeout(10, TimeUnit.SECONDS)
               .readTimeout(30, TimeUnit.SECONDS)
               .addInterceptor(new LoggingInterceptor())
               .cache(new Cache(context.getExternalFilesDir("okhttp"),cacheSize)).build();


    public static void getRequest(String url, final ResultListener<Object> listener) {
        Request request = new Request.Builder().url(url).method("GET", null).build();
        Call call = okHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                if (null != listener) {
                    listener.onFailure(e.getMessage());
                }
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (null != listener) {
                    listener.onSuccess(response);
                }
            }
        });
    }

这种封装成工具类的比完全没有封装的好了很多，但是还是存在一定的问题的。封装成工具类的话，别人完全有权限访问你这个工具类，他可以随时修改你工具类里面的实现，这给维护带来了一定的成本。

再此之前，我们要先了解网络请求哪些参数是必要的，哪些是非必要的

必要选项
- url，请求地址
- paramMap，请求参数
- IResponseCallback，请求结果回调
非必要选项
- context 通常是用来配置配置一些缓存等一些信息
- headMap 请求头
- tag 请求 TAG，用来区分或者取消网络请求
- connectTimeout 连接超时时间
- readTimeout 读取超时时间
- writeTimeout 写入超时时间

了解完必要参数和非必要参数之后，我们就将采用建造者模式，把非必要的参数都提取封装在ManbaOkhttpOption当中。代码如下：

public class ManbaOkhttpOption {
    private String mUrl;
    private String mTag;
    private Map<String, String> mHeaders;

    public ManbaOkhttpOption(String mTag) {
        this.mTag = mTag;
    }

    public String getTag() {
        return mTag;
    }

    public Map<String, String> getHeaders() {
        return mHeaders;
    }

    public static final class Builder {
        public String mTag;
        public Map<String, String> mHeaders;
        public String mUrl;

        public Builder setTag(String mTag) {
            this.mTag = mTag;
            return this;
        }

        public Builder setHeaders(Map<String, String> mHeaders) {
            this.mHeaders = mHeaders;
            return this;
        }

        public Builder setUrl(String mUrl) {
            this.mUrl = mUrl;
            return this;
        }

        public ManbaOkhttpOption build() {
            ManbaOkhttpOption option = new ManbaOkhttpOption(mTag);
            option.mHeaders = mHeaders;
            option.mUrl = mUrl;
            return option;
        }
    }

}

建造者模式的优点：

- 封装性很好，将产品本身与产品的创建过程解耦，对外屏蔽了对象的构建过程
- 扩展性强，如果有新的需求，只需要增加新的具体建造者，无须修改原有类库的代码

这样封装实现出来的接口IManbaRequest：

public interface IManbaRequest {
    void init(Context context);

    void doGet(String url, IResponseCallback callback);

    void doGet(String url, Map<String, String> paramsMap, IResponseCallback callback);

    void doGet(String url, Map<String, String> paramsMap, ManbaOkhttpOption option, IResponseCallback callback);

    void doPost(String url, Map<String, String> paramsMap, IResponseCallback callback);

    void doPost(String url, Map<String, String> paramsMap, ManbaOkhttpOption option, IResponseCallback callback);

    void cancel(String tag);
}

可以看到，我们有几个方法：

init 方法，主要用来配置一些初始化参数
doGet 有两个方法，其中一个方法是另外一个方法的重载，这样设计的目的是为了减少调用方法的时候减少方法参数的传递
doPost 跟 doGet 方法一样，就不说了
cancel 主要是用来取消网络请求的。在项目当中，在 Activity 或者 Fragment 销毁的时候，最好取消网络请求，不然可能导致内存泄露或者异常，如空指针异常等。

ManbaOkhttpRequest实现

OkHttp 的配置是非常灵活的，这样我们主要看一下怎么配置请求头，请求参数，以及怎样取消网络请求。

package com.sunhdj.manbaokhttp;

import android.content.Context;
import android.os.Handler;

import com.sunhdj.manbaokhttp.utils.NetUtils;

import java.io.IOException;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import okhttp3.Cache;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.FormBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

/**
 * huangdaju
 * 2020-02-25
 **/

public class ManbaOkhttpRequest implements IManbaRequest {

    private static int cacheSize = 10 * 1024 * 1024; // 10 MiB

    private static OkHttpClient client;
    private Context mContext;

    public static Handler mHandler = new Handler();

    public static Handler getHandler() {
        if (mHandler == null) {
            mHandler = new Handler();
        }
        return mHandler;
    }

    private volatile static ManbaOkhttpRequest instance = null;

    private ManbaOkhttpRequest() {
    }


    public static ManbaOkhttpRequest getInstance() {
        if (null == instance) {
            synchronized (ManbaOkhttpRequest.class) {
                if (null == instance) {
                    instance = new ManbaOkhttpRequest();
                }
            }
        }
        return instance;
    }

    @Override
    public void init(Context context) {
        mContext = context.getApplicationContext();
        client = getCilent();
    }

    private OkHttpClient getCilent() {
        if (client == null) {
            OkHttpClient.Builder mBuilder = new OkHttpClient.Builder().
                    connectTimeout(10, TimeUnit.SECONDS).writeTimeout(10, TimeUnit.SECONDS)
                    .readTimeout(30, TimeUnit.SECONDS)
                    .addInterceptor(new LoggingInterceptor())
                    .cache(new Cache(mContext.getExternalFilesDir("manbaOkhttp"), cacheSize));
            client = mBuilder.build();
        }
        return client;

    }

    @Override
    public void doGet(String url, IResponseCallback callback) {
        doGet(url, null, null, callback);
    }

    @Override
    public void doGet(String url, Map<String, String> paramsMap, IResponseCallback callback) {
        doGet(url, paramsMap, null, callback);
    }

    @Override
    public void doGet(String url, Map<String, String> paramsMap, ManbaOkhttpOption option, final IResponseCallback callback) {

        url = NetUtils.appendUrl(url, paramsMap);
        final ManbaOkhttpOption manbaOkhttpOption = NetUtils.checkNetworkOption(option, url);
        Request.Builder builder = new Request.Builder().url(url).tag(manbaOkhttpOption.getTag());
        builder = configHeaders(builder, manbaOkhttpOption);

        Request build = builder.build();

        getCilent().newCall(build).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                handleError(e, callback);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                handleResult(response, callback);
            }
        });
    }

    @Override
    public void doPost(String url, Map<String, String> paramsMap, IResponseCallback callback) {
        doPost(url,paramsMap,null,callback);
    }

    @Override
    public void doPost(String url, Map<String, String> paramsMap, ManbaOkhttpOption option, final IResponseCallback callback) {
        url = NetUtils.appendUrl(url, paramsMap);
        final ManbaOkhttpOption manbaOkhttpOption = NetUtils.checkNetworkOption(option, url);
        // 以表单的形式提交
        FormBody.Builder builder = new FormBody.Builder();
        builder=configPostParam(builder,paramsMap);
        FormBody formBody = builder.build();

        Request.Builder requestBuilder = new Request.Builder().url(url).post(formBody).tag(manbaOkhttpOption.getTag());
        requestBuilder = configHeaders(requestBuilder, manbaOkhttpOption);

        Request build = requestBuilder.build();

        getCilent().newCall(build).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                handleError(e, callback);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                handleResult(response, callback);
            }
        });
    }

    private FormBody.Builder configPostParam(FormBody.Builder builder, Map<String, String> paramsMap) {
        if(paramsMap!=null){
            Set<Map.Entry<String, String>> entries = paramsMap.entrySet();
            for(Map.Entry<String,String> entry:entries ){
                String key = entry.getKey();
                String value = entry.getValue();
                builder.add(key,value);
            }
        }
        return builder;
    }

    private Request.Builder configHeaders(Request.Builder builder, ManbaOkhttpOption option) {
        Map<String, String> headers = option.getHeaders();
        if (headers == null || headers.size() == 0) {
            return builder;
        }
        Set<Map.Entry<String, String>> entries = headers.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            builder.addHeader(key, value);
        }
        return builder;

    }


    private void handleResult(Response response, final IResponseCallback callback) throws IOException {
        final String result = response.body().string();
        if (callback != null) {
            getHandler().post(new Runnable() {
                @Override
                public void run() {
                    callback.onResponse(result);
                }
            });
        }
    }

    private void handleError(IOException e, final IResponseCallback callback) {
        if (callback != null) {
            final ManbaOkHttpException httpException = new ManbaOkHttpException();
            httpException.e = e;
            getHandler().post(new Runnable() {
                @Override
                public void run() {
                    callback.onFail(httpException);
                }
            });

        }
    }

    @Override
    public void cancel(String tag) {
        if (client != null) {
            for (Call call : client.dispatcher().queuedCalls()) {
                if (call.request().tag().equals(tag)) {
                    call.cancel();
                }
            }
        }
    }
}

ManbaOkhttpRequest的实现其实很简单，主要根据ManbaOkhttpOption做相应的配置。如果不熟悉okhttp的request用法，请参考博客OkHttp使用完全教程。

每天多努力那么一点点，积少成多

Android OKHttp3 二次封装网络框架

封装

ManbaOkhttpRequest实现

猜你喜欢

热点阅读