基于OkHttp3封装网络请求框架

• 前言

网络请求可以说是开发一款移动APP最核心的基础功能了，通过实际工作中以及浏览了许多网络框架之后，本篇在这里分享慕课一位老师基于OkHttp封装的一个轻量的网络框架，至于为什么说它轻量，因为代码少啊！在这里会实现基本的get/post请求，并且支持https加密请求，通过封装方便使用的API，来简化我们的调用方式，对于文件的上传和下载在后续的功能中我会补上这一部分，因为时间关系，前期就没有把它做进去，因为是说的是封装，所以关于okhttp的基本使用这里就不做说明了，不了解的朋友们可以自行百度或者谷歌查找相关资料，这里甩出GitHub和官网的地址，大家可以简单的了解一下。

GitHub地址：https://github.com/square/okhttp

官网地址：http://square.github.io/okhttp/

一、为什么要封装？

首先来看不封装的情况下我们来完成一个最基本的网络请求该如何去做，来看代码：

//1、创建OkHttpClient对象
OkHttpClient mOkHttpClient = new OkHttpClient();
//2、创建一个Request
final Request request = new Request.Builder()
        .url("https://www.baidu.com/")
        .build();
//3、通过okhttpclient对象来构建Call对象
Call call = mOkHttpClient.newCall(request);
//4、请求加入调度
call.enqueue(new Callback() {
    
    //请求失败
    @Override
    public void onFailure(@NonNull Call call, @NonNull IOException e) {

    }
    
    //请求成功
    @Override
    public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {

    }
});

有人说了，这代码也不是很多啊，但是如果我们每个请求都这么写就显得很繁琐了，而且这还是最基本的get请求，所以实际工作中我们完全不可能这么使用，原因也说了：1、代码冗余；2：如果官方的api发生了更新，那么你每个网络请求的地方都要修改，这就有点得不偿失了；3：作为一个高逼格的程序猿，网络请求的逻辑全都暴露在了Activity里面，这肯定是不允许的，所以综合以上几点，我们肯定要对它做一个封装，接下来就来看看如何去封装。

二、封装思路说明

1、首先是封装我们的Request，创建一个类来接收请求参数和URL，然后返回给我们一个创建好的请求对象；2、然后是封装我们的okhttp核心部分，这部分首先要能完成请求的发送（主要是get和post请求，反正我在实际工作中是没有碰到过put和delete请求的），然后是配置我们的okhttp相关的参数，并且我们还添加了https请求的支持，这里是对所有https类型站点的信任；3、最后封装callback部分，我们为这部分封装了对成功和失败的回调处理以及相关的异常处理，还有就是okhttp在回调完成后此时还是处于子线程中的，这点是它框架的机制导致的，所以这时候我们还不能进行UI操作，我们需要把消息转发到主线程中去，最后为了方便应用层的处理，我们在框架层就提前将服务器返回的json数据解析成对应的实体对象，然后我们在应用层中就可以直接操作我们Bean类中的属性了，好了，思路就是这样，那说干就干，开始封装。

三、撸起袖子加油干——代码实战

这里我们需要创建一个框架Module，这个Module是一个Android Library，然后将封装的代码都放在这个Module中进行编写，然后让应用层的app Module依赖框架Module即可，这样不会将封装的具体实现逻辑暴露在应用层。

1、封装Request

封装我们的请求参数到一个HashMap中，这个类并不是我写的，是参考了之前使用的一个网络框架AsyncHttpClient中的代码，创建了两个线程安全的HashMap，将请求参数以键值对的形式放到我们的HashMap中，代码如下：

package com.archie.netlibrary.okhttp.request;

import java.io.FileNotFoundException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 项目名:   NetTest2
 * 包名:     com.archie.netlibrary.okhttp.request
 * 文件名:   RequestParams
 * 创建者:   Jarchie
 * 创建时间: 17/12/13 上午10:28
 * 描述:     封装所有的请求参数到HashMap中
 * 此类是仿照AsyncHttpClient中的请求参数写的
 */

@SuppressWarnings({"unused", "RedundantIfStatement"})
public class RequestParams {
    //线程安全的HashMap
    public ConcurrentHashMap<String, String> urlParams = new ConcurrentHashMap<>();
    public ConcurrentHashMap<String, Object> fileParams = new ConcurrentHashMap<>();

    /**
     * Constructs a new empty {@code RequestParams} instance.
     */
    public RequestParams() {
        this((Map<String, String>) null);
    }

    /**
     * Constructs a new RequestParams instance containing the key/value string
     * params from the specified map.
     *
     * @param source the source key/value string map to add.
     */
    public RequestParams(Map<String, String> source) {
        if (source != null) {
            for (Map.Entry<String, String> entry : source.entrySet()) {
                put(entry.getKey(), entry.getValue());
            }
        }
    }

    /**
     * Constructs a new RequestParams instance and populate it with a single
     * initial key/value string param.
     *
     * @param key   the key name for the intial param.
     * @param value the value string for the initial param.
     */
    public RequestParams(final String key, final String value) {
        this(new HashMap<String, String>() {
            {
                put(key, value);
            }
        });
    }

    /**
     * Adds a key/value string pair to the request.
     *
     * @param key   the key name for the new param.
     * @param value the value string for the new param.
     */
    public void put(String key, String value) {
        if (key != null && value != null) {
            urlParams.put(key, value);
        }
    }

    public void put(String key, Object object) throws FileNotFoundException {
        if (key != null) {
            fileParams.put(key, object);
        }
    }

    public boolean hasParams() {
        if (urlParams.size() > 0 || fileParams.size() > 0) {
            return true;
        }
        return false;
    }

}

创建一个CommonRequest类，接收请求参数，然后生成Request对象，这里因为内容较少所有没有采用构建者的模式，二是采用公共静态的方法，在下一篇介绍对Retrofit的一个封装时我会采用构建者模式，因为它的封装过程比这个要稍微复杂一些，内容也更全面一些，敬请期待吧！这个类中我们创建了两个方法用于生成get和post类型的Request，都是通过循环遍历Map中的请求参数来完成的，不同的是，get请求的key-value是通过“&”拼接的，所以这里使用了StringBuilder来完成字符串的拼接，效率更高，post请求是通过okhttp中的FormBody对象的建造者来完成的，具体实现的代码如下：

package com.archie.netlibrary.okhttp.request;

import java.util.Map;

import okhttp3.FormBody;
import okhttp3.Request;

/**
 * 项目名:   NetTest2
 * 包名:     com.archie.netlibrary.okhttp.request
 * 文件名:   CommonRequest
 * 创建者:   Jarchie
 * 创建时间: 17/12/13 上午10:31
 * 描述:     接收请求参数，为我们生成Request对象
 */

public class CommonRequest {

    /**
     * 创建Get请求的Request
     *
     * @param url
     * @param params
     * @return 通过传入的参数返回一个Get类型的请求
     */
    public static Request getRequest(String url, RequestParams params) {
        StringBuilder urlBuilder = new StringBuilder(url).append("?");

        if (params != null) {
            for (Map.Entry<String, String> entry : params.urlParams.entrySet()) {
                urlBuilder
                        .append(entry.getKey())
                        .append("=")
                        .append(entry.getValue())
                        .append("&");
            }
        }

        return new Request.Builder().url(urlBuilder.substring(0, urlBuilder.length() - 1))
                .get().build();
    }

    /**
     * 创建Post请求的Request
     *
     * @param url
     * @param params
     * @return 返回一个创建好的Request对象
     */
    public static Request createPostRequest(String url, RequestParams params) {
        FormBody.Builder mFromBodyBuilder = new FormBody.Builder();

        if (params != null) {
            for (Map.Entry<String, String> entry : params.urlParams.entrySet()) {
                //将请求参数逐一遍历添加到我们的请求构建类中
                mFromBodyBuilder.add(entry.getKey(), entry.getValue());
            }
        }

        //通过请求构建类的build方法获取到真正的请求体对象
        FormBody mFormBody = mFromBodyBuilder.build();
        return new Request.Builder().url(url).post(mFormBody).build();
    }

}

2、封装OkHttp核心部分

这部分主要完成的功能是：1、请求的发送；2、请求参数的配置（这里配置了连接超时和读写超时时间，允许重定向）；3、添加https的支持，在hostnameVerifier的回调中我们返回的是true，表明对所有类型的https证书的支持，无论是自己生成的还是购买的，对于sslSocketFactory的设置，我这里是参考网上的相关代码做了一个封装，https就是在TCP和HTTP协议之间加了一层SSL协议，是介于传输层和应用层之间的协议，需要注意的是加密算法的类型要与服务端的保持一致，一般为TSL/SSL，关于https我本人并不是太了解，讲的也不清楚，这里推荐给大家一篇鸿洋的文章，Android Https相关完全解析http://blog.csdn.net/lmj623565791/article/details/48129405。关于配置的一系列操作都是放在静态语句块中执行的，主要是通过OkHttpClient对象的Builder对象来设置的，最后我们创建了get()和post()两个方法，用于发送具体的请求，参数传入我们的Request和CallBack回调，具体代码如下：

package com.archie.netlibrary.okhttp;

import com.archie.netlibrary.okhttp.https.HttpsUtils;
import com.archie.netlibrary.okhttp.listener.DisposeDataHandle;
import com.archie.netlibrary.okhttp.response.CommonJsonCallback;

import java.util.concurrent.TimeUnit;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLSession;

import okhttp3.Call;
import okhttp3.OkHttpClient;
import okhttp3.Request;

/**
 * 项目名:   NetTest2
 * 包名:     com.archie.netlibrary.okhttp
 * 文件名:   CommonOkHttpClient
 * 创建者:   Jarchie
 * 创建时间: 17/12/13 上午10:25
 * 描述:     请求的发送，请求参数的配置，https支持
 */

public class CommonOkHttpClient {

    private static final int TIME_OUT = 30; //超时参数
    private static OkHttpClient mOkHttpClient;

    //为我们的Client配置参数，使用静态语句块来配置
    static {
        //创建我们Client对象的构建者
        OkHttpClient.Builder okHttpBuilder = new OkHttpClient.Builder();
        okHttpBuilder
                //为构建者填充超时时间
                .connectTimeout(TIME_OUT, TimeUnit.SECONDS)
                .readTimeout(TIME_OUT, TimeUnit.SECONDS)
                .writeTimeout(TIME_OUT, TimeUnit.SECONDS)
                //允许重定向
                .followRedirects(true)
                //添加https支持
                .hostnameVerifier(new HostnameVerifier() {
                    @Override
                    public boolean verify(String s, SSLSession sslSession) {
                        return true;
                    }
                })
                .sslSocketFactory(HttpsUtils.initSSLSocketFactory(), HttpsUtils.initTrustManager());
        mOkHttpClient = okHttpBuilder.build();
    }

    //发送具体的HTTP以及Https请求
    public static Call sendRequest(Request request, CommonJsonCallback commonCallback) {
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(commonCallback);
        return call;
    }

    //GET请求
    public static Call get(Request request, DisposeDataHandle handle) {
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(new CommonJsonCallback(handle));
        return call;
    }

    //POST请求
    public static Call post(Request request, DisposeDataHandle handle) {
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(new CommonJsonCallback(handle));
        return call;
    }

}

关于HttpsUtils的代码，文末会给出项目源码，这里就不贴出了，不然代码太多了。

3、封装Callback

首先我们创建一个接口类，自定义事件监听的回调，用于处理成功和失败的请求，参数中使用的是Object类型，这样能够更灵活的处理数据：

public interface DisposeDataListener {

    //请求成功回调事件处理
    public void onSuccess(Object responseObj);

    //请求失败回调事件处理
    public void onFailure(Object responseObj);

}

接着新建一个类，将我们的事件回调和用于处理Json转换实体对象的字节码对象做一个封装，给出单参和双参的构造方法：

public class DisposeDataHandle {

    public DisposeDataListener mListener = null;
    public Class<?> mClass = null;

    public DisposeDataHandle(DisposeDataListener listener) {
        this.mListener = listener;
    }

    public DisposeDataHandle(DisposeDataListener listener, Class<?> clazz) {
        this.mListener = listener;
        this.mClass = clazz;
    }

}

接着我们再自定义一个异常类，返回错误码和错误信息到业务层：

public class OkHttpException extends Exception {
    private static final long serialVersionUID = 1L;

    private int ecode; //错误码
    private Object emsg; //错误消息

    public OkHttpException(int ecode, Object emsg) {
        this.ecode = ecode;
        this.emsg = emsg;
    }

    public int getEcode() {
        return ecode;
    }

    public Object getEmsg() {
        return emsg;
    }

}

最后我们创建一个类用于专门处理Json数据的响应，命名为CommonJsonCallback实现OKHTTP3中的Callback接口，重写onFailure和onResponse这两个失败和成功的回调函数，在这个类中我们定义了一些基本的常量，首先定义了与服务器字段的对应关系的常量，其次自定义了一些异常类型，这些字段需要和自己公司的后台开发人员进行商定，这里我只是简单的举个栗子，具体如下代码所示：

//与服务器的字段的一个对应关系
protected final String RESULT_CODE = "ecode"; //有返回则对于http请求来说是成功的，但还有可能是业务逻辑上的错误
protected final int RESULT_CODE_VALUE = 0;
protected final String ERROR_MSG = "emsg";
protected final String EMPTY_MSG = "";

//自定义异常类型
protected final int NETWORK_ERROR = -1; //the network relative error
protected final int JSON_ERROR = -2; //the JSON relative error
protected final int OTHER_ERROR = -3; //the unknow error

接着我们定义了一个Handler对象用于进行消息的转发，自定义回调监听用于对响应数据的回调处理，字节码文件用于对实体对象的转化，如下所示：

private Handler mDeliveryHandler; //进行消息的转发
private DisposeDataListener mListener;
private Class<?> mClass;

public CommonJsonCallback(DisposeDataHandle handle) {
    this.mListener = handle.mListener;
    this.mClass = handle.mClass;
    this.mDeliveryHandler = new Handler(Looper.getMainLooper());
}

接着是处理请求失败的回调，我们在这里用handler将异常信息通过自定义的回调监听发送到应用层中去处理，如下所示：

//请求失败的处理
@Override
public void onFailure(@NonNull Call call, @NonNull final IOException e) {
    mDeliveryHandler.post(new Runnable() {
        @Override
        public void run() {
            mListener.onFailure(new OkHttpException(NETWORK_ERROR, e));
        }
    });
}

最后来处理请求成功的回调，这也是最重要的一步，同样的我们首先是将响应数据发送到主线程中，然后判断字节码mClass对象是否为null，如果为空则表示我们不需要转换实体对象，直接将原始的Json数据回调到应用层，你可以直接操作json数据，如果mClass对象不为空，我这里直接通过谷歌的Gson将json数据解析成了对应的实体对象返回，这样我们在应用层可以直接操作实体对象，对于异常信息也是直接回调到应用层去处理的，具体代码如下：

//处理成功的响应
private void handleResponse(Object responseObj) {
    //为了保证代码的健壮性
    if (responseObj == null && responseObj.toString().trim().equals("")) {
        mListener.onFailure(new OkHttpException(NETWORK_ERROR, EMPTY_MSG));
        return;
    }
    try {
        JSONObject result = new JSONObject(responseObj.toString());
        if (result.has(RESULT_CODE)) {
            //从JSON对象中取出我们的响应码，如果为0，则是正确的响应
            if (result.getInt(RESULT_CODE) == RESULT_CODE_VALUE) {
                if (mClass == null) {
                    mListener.onSuccess(responseObj);
                } else { //需要转化为实体对象
                    Object obj = new Gson().fromJson((String) responseObj, mClass);
                    if (obj != null) { //表明正确的转为了实体对象
                        mListener.onSuccess(obj);
                    } else {
                        mListener.onFailure(new OkHttpException(JSON_ERROR, EMPTY_MSG));
                    }
                }
            } else { //将服务端返回的异常回调到应用层去处理
                mListener.onFailure(new OkHttpException(OTHER_ERROR, result.get(RESULT_CODE)));
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        mListener.onFailure(new OkHttpException(OTHER_ERROR, e.getMessage()));
    }
}

好了，这样我们就已经封装完成了基本的get/post请求，已经能够满足一般的开发要求了，关于框架层的封装就说这么多，接下来，我们去看看在应用层中该如何调用？

四、测试框架是否运行正常

1、准备服务器数据

我这里在本地环境下开了一个Tomcat，然后在它的webapps目录下新建了一个文件夹youdu，然后在里面新建了一个test.json的文件，在里面放入了一些简单的测试数据，并且我们在本地浏览器中访问这个地址，发现可以正常访问，数据如下：

2、根据对应的json数据，这里创建一个TestModel实体类，定义获取数据的各个字段，可以通过GsonFormat插件快速生成。

3、定义接口管理类，统一管理接口地址（实际项目中都要这么做）：

public class HttpConstant {
    private static final String URL = "http://10.10.7.146:8080/";

    public static String HOME_RECOMMAND = URL + "youdu/test.json";
}

4、为了调用简单，我们在应用层中再做一层封装，定义一个RequestCenter类，在其中通过方法的重载，对外只暴露一个我们自定义的回调监听，其它几个参数都在这个类中传入即可，代码如下：

public class RequestCenter {

    //根据参数发送所有的get请求
    private static void getRequest(String url, RequestParams params,
                                   DisposeDataListener listener,
                                   Class<?> clazz){
        CommonOkHttpClient.get(CommonRequest.createGetRequest(url, params),
                new DisposeDataHandle(listener,clazz));
    }

    public static void requestRecommandData(DisposeDataListener listener){
        RequestCenter.getRequest(HttpConstant.HOME_RECOMMAND,null,listener, TestModel.class);
    }

}

5、这样我们在调用的时候就十分方便了，并且在回调方法中可以直接处理我们实体数据，具体的调用方法如下：

//测试网络框架
RequestCenter.requestRecommandData(new DisposeDataListener() {
    @Override
    public void onSuccess(Object responseObj) {
        TestModel model = (TestModel) responseObj;
        //设置名称字段显示到TextView上
        textView.setText(model.getData().getList().get(0).getUname());
    }

    @Override
    public void onFailure(Object responseObj) {
        Log.e("测试网络框架", "onFailure: " + responseObj.toString() );
    }
});

可以看到，我们的调用现在已经变的十分简单了，就这么几行代码就完成了数据请求解析以及展示的过程，来看一下程序运行的结果：

双手奉上项目源码地址：https://github.com/JArchie/NetTest2