android网络请求组件（一）OkHttp3的封装使用
现在程序员的能力是越来越强了，新技术新想法不断的涌现，然后并应用于实战上，有时候自己会不经意的发现手头上用的技术好老，有点脱节的感觉。为了摆脱这种不爽的感觉（其实就是怕被同行歧视），咋办？唯一的出路就是不断的学习！学习！！学习！！！
一、概述
现在的手机APP，能在应用商店上看到的APP，差不多有95%以上都需要网络需求。进而得出网络组件在APP中的重要性是非常高的！既然如此重要，我们战斗强悍的程序员们为了本着服务大众的奉献精神，创造出了很多非常优秀的开源网络框架，例如android-async-http、volley、retrofit、OkHttp3等等。这其中现在最受开发者们欢迎且用的非常多的框架就是retrofit和OkHttp3了。今天我们先聊OkHttp3，等以后我有时间再来和大家聊聊retroft的封装使用。
为什么要聊OkHttp3？我的答案就4个字“简单好用”，我们开发者使用的框架的目的就是方便我们开发，工具越简单、用起来舒服，你说开发者能不爱吗？说了这么多废话，接下来就要开始进入开发正题了，我会已两种实现模式向大家介绍OkHttp3的使用，一种是“基本模式”（也可以叫Demo学习模式），另一种是”高级模式“（也可以叫开发者模式），至于两种模式的区别，请仔细看我接下来的介绍吧。
二、基本使用模式
基本使用模式（Demo学习模式）其实就是我对OkHttp3的一个最基本的使用介绍，没有对其进行封装优化，用起来很简单，但局限性很强，仅作为Demo学习用。
使用之前首先我们要配置环境，这一点相当简单，一句话就可以搞定。在Android Studio环境，找到自己项目下的build.gradle文件，找到dependencies{},然后在里面添加
compile 'com.squareup.okhttp3:okhttp:3.3.0' //okttp依赖
就可以用了。请大家注意，里面的3.3.0是目前我写这篇的文章的版本，大家以后在用的时候最好还是选择最新的版本，因为不同的版本里面的方法可能不同，我之前就遇到这个坑，2.0版有一些方法在3.0上就没了，或者说被其他方法整合优化掉了，这一点请各位一定要注意更新。
搭建好环境后，咱们开始看看OkHttp3的核心类，一共有四个核心类。因此使用起来也就是分别使用这四个
1、OkHttpClient类:这个类用于处理请求，因此第一步就是要创建OkHttpClient实例
2、Request类:这个类用来构建请求参数，如url、请求方式、请求参数、header等
3、Call类:生成一个请求实例，这里可以选择设置是同步执行还是异步执行
4、Response:请求结果响应，包含HTTP响应，返回数据等，这里面就可以拿到接口传来时数据，然后就可以对数据进行处理了。
文字看的不清晰，咱们对着上面的四句话看看代码具体是啥样的。
// 1、拿到okhttpClient对象
OkHttpClient okHttpClient = new OkHttpClient();
// 2、构造Request
Request.Builder builder = new Request.Builder();
Request request = builder
.get()
.url(mBaseUrl + "login?username=zbq&userpassword=123")
.build();
// 3、将Request请求封装为Call
Call call = okHttpClient.newCall(request);
// 执行Call
// Response response = call.execute(); 同步执行
call.enqueue(new Callback() { // 异步执行
@Override
public void onFailure(Call call, IOException e) {
LogUtils.e("onFailure" + e.getMessage());
}
@Override
public void onResponse(Call call, Response response) throws IOException {
final String res = response.body().toString();
LogUtils.e(response.body().toString());
// 4、response回调在子线程中而不是UI线程
runOnUiThread(new Runnable() {
@Override
public void run() {
tv.setText(res);
}
});
}
}); // 1、拿到okhttpClient对象
OkHttpClient okHttpClient = new OkHttpClient();
FormBody requestBody = new FormBody.Builder()
.add("username","huanhuan").add("userpassword","12345").build();
// 2、构造Request
// 2.1 Post请求需要构造FormBody
Request.Builder builder = new Request.Builder();
Request request = builder.url(mBaseUrl +"login").post(requestBody).build();
// 3、将Request请求封装为Call
Call call = okHttpClient.newCall(request);
// 执行Call
// Response response = call.execute(); 同步执行
call.enqueue(new Callback() { // 异步执行
@Override
public void onFailure(Call call, IOException e) {
LogUtils.e("onFailure" + e.getMessage());
}
@Override
public void onResponse(Call call, Response response) throws IOException {
final String res = response.body().toString();
LogUtils.e(response.body().toString());
// response回调在子线程中而不是UI线程
runOnUiThread(new Runnable() {
@Override
public void run() {
tv.setText(res);
}
});
}
});
上述就是OkHttp3的最基本用法，对比两部分代码，大家就能发现是不是有很多重复的地方。一般项目里有很多调用网络的地方，如果每一个功能模块的网络请求都这么写，那还不被项目老大给骂死，即罗嗦，而且可复用性低，所以上述代码只适合小的演示Demo。接下来咱们开始写点儿实际工作中用的例子。
先提前声明一下，这部分内容有点多，而且每个人的想法可能都不一样，我是学习了任志强老师以及张鸿洋的资料后做的总结吧，如果我写的不对或者不好，还请各位大神指正。谢谢。
对着这张图咱们来拆解分析一下，看看要分装那些类
三、高级模式
这里的高级模式其实就是开发者模式，和上面基本模式的不同之处就是“封装”和“复用”。将OkHttp3在封装一次，方便以后使用。
基本的用法上面我都提到了，接下来我们看看我为封装的OkHttp3网络框架画的思路图：
Request封装
首先看最左边的request，这里面包含有请求参数、url、创建对象。请求参数一般都是以键值对的形式，比如uername : haha，我们可以用HashMap或HashMap进行存储，然后将其封装到RequestParams类，这样我们在request请求时直接创建一个对象传入参数即可。例如
public ConcurrentHashMap urlParams = new ConcurrentHashMap<>();
public ConcurrentHashMap fileParams = new ConcurrentHashMap<>()
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);
}
}
请求参数封装好后，接下来开始封装Request核心逻辑。网络请求通常情况下我们都是用的Get和Post请求，所以我们要写两个方法去分别做两个操作，这两个方法可以封装到CommonRequest类中。这个类的作用就是接收请求参数，然后生成Request对象。例如Get请求
/**
* 创建一个Get请求
* @param url
* @param params
* @return 返回一个创建好的Get请求对象
*/
public static Request createGetRequest(String url,RequestParams params){
StringBuilder stringBuilder = new StringBuilder(url).append("?");
if(params !=null){
for (Map.Entry entry : params.urlParams.entrySet()){
stringBuilder.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
}
}
return new Request.Builder().url(stringBuilder.substring(0,stringBuilder.length()-1))
.get().build();
} /**
* 创建一个Post请求
* @param url
* @param params
* @return 返回一个创建好的Post请求对象
*/
public static Request createPostRequest(String url,RequestParams params){
FormBody.Builder mFormBodyBuild = new FormBody.Builder();
if(params !=null){
for (Map.Entry entry : params.urlParams.entrySet()){
// 将请求参数遍历添加到请求构建类中
mFormBodyBuild.add(entry.getKey(),entry.getValue());
}
}
// 通过请求构建类的build方法获取到真正的请求体对象
FormBody formBody = mFormBodyBuild.build();
return new Request.Builder().url(url).post(formBody).build();
} public static final class Builder { private final List<String> names = new ArrayList<>(); private final List<String> values = new ArrayList<>(); public Builder add(String name, String value) { names.add(HttpUrl.canonicalize(name, FORM_ENCODE_SET, false, false, true, true)); values.add(HttpUrl.canonicalize(value, FORM_ENCODE_SET, false, false, true, true)); return this; } public Builder addEncoded(String name, String value) { names.add(HttpUrl.canonicalize(name, FORM_ENCODE_SET, true, false, true, true)); values.add(HttpUrl.canonicalize(value, FORM_ENCODE_SET, true, false, true, true)); return this; } public FormBody build() { return new FormBody(names, values); } }
这样最左边的Request请求部分咱们就封装完毕，接下来开始封装OkHttp的核心部分OkHttpClient。
OkHttpClient
首先咱们先来描述一下这个类的作用：请求的发送、请求参数的配置以及现在必要的https的支持。创建一个OkHttpClientCnter类。创建好后我们要做一些最基本的网络配置。
首先咱们先来描述一下这个类的作用：请求的发送、请求参数的配置以及现在必要的https的支持。创建一个OkHttpClientCnter类。创建好后我们要做一些最基本的网络配置。
// 为我们的client去配置参数
static {
// 创建我们client对象的构建者
OkHttpClient.Builder okHttpBuilder = new OkHttpClient.Builder();
// 是为构建者填充超时时间
okHttpBuilder.connectTimeout(TIME_OUT, TimeUnit.SECONDS);
okHttpBuilder.readTimeout(TIME_OUT, TimeUnit.SECONDS);
okHttpBuilder.writeTimeout(TIME_OUT, TimeUnit.SECONDS);
// 运行请求重定向
okHttpBuilder.followRedirects(true);
// https支持
okHttpBuilder.hostnameVerifier(new HostnameVerifier() {
@Override
public boolean verify(String hostname, SSLSession session) {
return true;
}
});
okHttpBuilder.sslSocketFactory(HttpsUtils.initSSLSocketFactory(), HttpsUtils.initTrustManager());
// 生成Client对象
mOkHttpClient = okHttpBuilder.build();
} public static SSLSocketFactory initSSLSocketFactory() {
SSLContext sslContext = null;
try {
sslContext = SSLContext.getInstance("SSL");
X509TrustManager[] xTrustArray = new X509TrustManager[]
{initTrustManager()};
sslContext.init(null,
xTrustArray, new SecureRandom());
} catch (Exception e) {
e.printStackTrace();
}
return sslContext.getSocketFactory();
}
public static X509TrustManager initTrustManager() {
X509TrustManager mTrustManager = new X509TrustManager() {
@Override
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[]{};
}
@Override
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
@Override
public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
};
return mTrustManager;
} /**
* 通过构造好的Get Request,Callback去发送请求
* @param request
* @param commCallback
* @return Call
*/
public static Call get(Request request, Callback commCallback){
Call call = mOkHttpClient.newCall(request);
call.enqueue(new commCallback);
return call;
}Callback封装
这一块的封装要做的事情有点多，要处理回调函数，处理数据异常，转发消息到UI线程最后还要将消息转化成对应的实体，看起来好麻烦，的确。但是我想说如果这一层封装的很好的话，以后调用时能够省略好多好多代码。何乐而不为呢？接下来我们一个一个的拆解实现。
1、处理回调函数
首先我们需要自定义回调事件监听，或许有人会问，Callback里面不是已经有回调事件，为什么还要自定义？
你看源码不是有吗
public interface Callback { /** * Called when the request could not be executed due to cancellation, a connectivity problem or * timeout. Because networks can fail during an exchange, it is possible that the remote server * accepted the request before the failure. */ void onFailure(Call call, IOException e); /** * Called when the HTTP response was successfully returned by the remote server. The callback may * proceed to read the response body with {@link Response#body}. The response is still live until * its response body is {@linkplain ResponseBody closed}. The recipient of the callback may * consume the response body on another thread. * * Note that transport-layer success (receiving a HTTP response code, headers and body) does * not necessarily indicate application-layer success: {@code response} may still indicate an * unhappy HTTP response code like 404 or 500. */ void onResponse(Call call, Response response) throws IOException; }的确，源码里是有。但是！这不代表以后还是这些方法，我刚才也提到了，由于OkHttp3的项目负责人太敬业了，总想让自己的代码更加完美好用，于是版本一升级，难免有的方法就过时消失或者被整合到其他方法中了，这个坑我在刚刚在讲Request里的FormBody就提到过了。所以，保险起见就是我们自己重新自定义一个回调事件接口，同时自定还有一个好处就是方便以后好扩展，大家看源码里面就只提供了 两个方法，如果以后我想要看看当前下载进度如何，源码里没有这个监听下载进度的回调方法，那岂不是呵呵了。为此我们要定义实现为好。OK说完了该实现了
/**
* 自定义事件监听
* Created by Administrator on 2017/7/23.
*/
public interface DisposeDataListener {
/**
* 请求成功回调事件处理
*/
public void onSuccess(Object responseObj);
/**
* 请求失败回调事件处理
*/
public void onFailure(Object reasonObj);
}/**
* 相当于对callBack的预处理
* Created by Administrator on 2017/7/23.
*/
public class DisposeDataHandle {
public DisposeDataListener mListener = null;
public Class mClass = null; // 字节码
public String mSource = null;
public DisposeDataHandle(DisposeDataListener listener)
{
this.mListener = listener;
}
public DisposeDataHandle(DisposeDataListener listener, Class clazz)
{
this.mListener = listener;
this.mClass = clazz;
}
public DisposeDataHandle(DisposeDataListener listener, String source)
{
this.mListener = listener;
this.mSource = source;
}
}2、异常处理
异常处理相比上面的处理回调函数就简单多了，我只需要获取异常的状态码和状态信息就好了。实现如下:
/**
* 自定义异常
* Created by Administrator on 2017/7/23.
*/
public class OkHttpException extends Exception {
private static final long serialVersionUID = 1L;
/**
* the server return code
*/
private int ecode;
/**
* the server return error message
*/
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;
}
}
3、4：转发消息到UI线程&将Json转化成对应的实体
首先我们来创建一个JsonCallbackCenter类，然后再来配置一些和服务交互的参数以及基本消息传递的对象，例如：
首先我们来创建一个JsonCallbackCenter类，然后再来配置一些和服务交互的参数以及基本消息传递的对象，例如：
// 与服务器返回的字段的一个对应关系
protected final String RESULT_CODE = "ecode"; // 服务器返回的状态
protected final int RESULT_CODE_VALUE = 0; // 服务返回的状态值
protected final String ERROR_MSG = "emsg"; // 服务器返回的消息
protected final String EMPTY_MSG = ""; // 空消息
protected final String COOKIE_STORE = "Set-Cookie"; // decide the server it
// 自定义异常类型
protected final int NETWORK_ERROR = -1; // 网络相关错误
protected final int JSON_ERROR = -2; // Json处理相关错误
protected final int OTHER_ERROR = -3; // 未知异常错误 /**
* 将其它线程的数据转发到UI线程
*/
private Handler mDeliveryHandler; // 进行消息转发
private DisposeDataListener mListener; // 自定义事件回调接口
private Class mClass; // 要转换的字节码 @Override
public void onFailure(final Call call, final IOException ioexception) {
/**
* 此时还在非UI线程，因此要转发
*/
mDeliveryHandler.post(new Runnable() {
@Override
public void run() {
mListener.onFailure(new OkHttpException(NETWORK_ERROR, ioexception));
}
});
} @Override
public void onResponse(final Call call, final Response response) throws IOException {
final String result = response.body().string();
mDeliveryHandler.post(new Runnable() {
@Override
public void run() {
handleResponse(result); // 处理从接口返回的数据
}
});
} /**
* 处理服务器返回的响应数据
* @param responseObj
*/
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());
// 开始尝试解析json
if(result.has(RESULT_CODE)){
// 从json对象中取出我们的响应码，若为0，则是正确的响应（根据服务状态码来定）
if (mClass == null) { // 不需要解析，直接返回数据到应用层
mListener.onSuccess(result);
} else {
Gson gson = new Gson();
Object obj = gson.fromJson(responseObj.toString(),mClass);
// 表明正确的转化成实体对象
if (obj != null) {
mListener.onSuccess(obj);
} else {
// 返回的不是合法的json
mListener.onFailure(new OkHttpException(JSON_ERROR, EMPTY_MSG));
}
}
}else {
// 将服务器返回我们的异常回调到应用层去处理
mListener.onFailure(new OkHttpException(OTHER_ERROR,result.get(RESULT_CODE)));
}
} catch (Exception e) {
mListener.onFailure(new OkHttpException(OTHER_ERROR, e.getMessage()));
e.printStackTrace();
}
}大致梳理一下上面的代码，首先就是要判断服务器返回的数据是否有效，无效的话直接调用咱们封装的onFailure()。然后根据服务器返回的状态码是否是成功的。接着就是要处理Json数据，就是将Json数据转化成实体对象.这里我们可以使用第三方的Gson库，直接在项目的build.gradle中引入就好了
compile 'com.google.code.gson:gson:2.4' 转化完后再进一步验证自己的转化后的结果，保证把正确的结果传递到UI线程中
好了，现在最后一个CallBack模块也封装好了，还记得刚刚我们在前面实现的Get请求可以优化吗，这里我将封装好的CallBack放进去看看。优化后如下
/**
* 通过构造好的Get Request,Callback去发送请求
* @param request
* @param handle
* @return Call
*/
public static Call get(Request request, DisposeDataHandle handle){
Call call = mOkHttpClient.newCall(request);
call.enqueue(new CommonJsonCallback(handle));
return call;
} //根据参数发送所有post请求
public static void postRequest(String url, RequestParams params,
DisposeDataListener listener, Class clazz) {
CommonOkHttpClient.get(CommonRequest.
createGetRequest(url, params), new DisposeDataHandle(listener, clazz));
}
/**
* 用户登陆请求
*
* @param listener
* @param userName
* @param passwd
*/
public static void login(String userName, String passwd, DisposeDataListener listener) {
RequestParams params = new RequestParams();
params.put("mb", userName);
params.put("pwd", passwd);
RequestCenter.postRequest(HttpConstants.LOGIN, params, listener, User.class);
} RequestCenter.login(userName, password, new DisposeDataListener() {
@Override
public void onSuccess(Object responseObj) {
DialogManager.getInstnce().dismissProgressDialog();
/**
* 这部分可以封装起来，封装为到一个登陆流程类中
*/
User user = (User) responseObj;
UserManager.getInstance().setUser(user);//保存当前用户单例对象
........
}
@Override
public void onFailure(Object reasonObj) {
DialogManager.getInstnce().dismissProgressDialog();
}
});
}
花了两天的时间断断续续的总算写好了，这期间也查阅了很多资料，学习了很多知识。由于本人水平有限，若有大神发现错误，还请帮忙指正，非常感谢。