一. 前言（简述）
OkHttp是一个高效的HTTP库
Ø 支持 SPDY ，共享同一个Socket来处理同一个服务器所有请求
Ø 如果SPDY不可用，则通过连接池来减少请求延时；
Ø 无缝的支持GZIP来减少数据流量；
Ø 缓存响应数据来减少重复的网络请求。
二简述在项目中使用自己封装的网络框架
1.首先定义一个管理者OkHttpClientManager 这个类采用单例设计模式，直接上代码。
private static OkHttpClientManager mInstance;
public OkHttpClient mOkHttpClient;//可以在程序外调用OkHttpClientManager.mOkHttpClient.cancel
private Handler mDelivery;
private static final String TAG = "OkHttpClientManager";
private OkHttpClientManager() {
mOkHttpClient = new OkHttpClient();
//OkHttp支持连接，读取和写入超时。
mOkHttpClient.setConnectTimeout(10, TimeUnit.SECONDS);
mOkHttpClient.setWriteTimeout(10, TimeUnit.SECONDS);
mOkHttpClient.setReadTimeout(30, TimeUnit.SECONDS);
//cookie enabled一种预定义策略，表示只接受来自原始服务器的 cookie。
mOkHttpClient.setCookieHandler(new CookieManager(null, CookiePolicy.ACCEPT_ORIGINAL_SERVER));
mDelivery = new Handler(Looper.getMainLooper());
}
public static OkHttpClientManager getInstance() {
if (mInstance == null) {
synchronized (OkHttpClientManager.class) {
if (mInstance == null) {
mInstance = new OkHttpClientManager();
}
}
}
return mInstance;
}
这里给这个client设置了读写超时时间，设置cookie等属性值。
接下来我们就要写常见的Http请求了，当然常见的Http请求用的最多的是get和post啦，下面分别进行封装。
/**
* 异步的post请求
*
* @param url
* @param callback
* @param params
*/
private void _postAsyn(String url, final INetClientHandler callback, Map<String, String> params) {
Param[] paramsArr = map2Params(params);
Request request = buildPostRequest(url, paramsArr);
deliveryResult(callback, request);
}
这里我给出了异步的执行post请求，那么这个INetClientHandler 到底是个什么鬼？往下看！
public interface INetClientHandler {
//状态码为0 表示成功
public void onSuccess(String response);
//网络状态异常
public void onNetFail();
//状态码不为0 状态失败，toast错误信息
public void onStateFail(IErrorBody iErrorBody);
//只要访问网络成功都会执行此方法
public void onFinish();
//状态码不为0返回的JSON串
public void onFailed(String response);
}
打开INetClientHandler 我们可以看出其实这就是个接口，仔细看看接口定义的几个方法，onSuccess，onFinish，onFailed，onStateFailed等接口回调，是不是感觉有种似曾相识的感觉，没错，我们在HttpUtils里面也知道成功和失败的回调，这里我只是把回调的方法写的详细点，（成功，失败，结束，网络状态异常，服务器异常等情况）。
private Param[] map2Params(Map<String, String> params) {
if (params == null) return new Param[0];
int size = params.size();
Param[] res = new Param[size];
Set<Map.Entry<String, String>> entries = params.entrySet();
int i = 0;
for (Map.Entry<String, String> entry : entries) {
res[i++] = new Param(entry.getKey(), entry.getValue());
}
return res;
}
这段代码主要封装我们的post提交的map，我们把它封装成一个数组，因为往服务器里面传递的数据我用Map来存储。
private Request buildPostRequest(String url, Param[] params) {
if (params == null) {
params = new Param[0];
}
FormEncodingBuilder builder = new FormEncodingBuilder();
for (Param param : params) {
if (!CommonUtil.isEmpty(param.value)) {
builder.add(param.key, param.value);
}
}
RequestBody requestBody = builder.build();
return new Request.Builder()
.url(url)
.tag(TAG)
.post(requestBody)
.build();
}
注：这里的Param封装了键值对
public static class Param {
public Param() {
}
public String key;
public String value;
public Param(String key, String value) {
this.key = key;
this.value = value;
}
}
这一段代码相信大家都能看懂，只是封装了一个请求而已，看到这里，我们怎样传一个请求呢，往下看
private void deliveryResult(final INetClientHandler callback, Request request) {
mOkHttpClient.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(final Request request, final IOException e) {
sendFailedStringCallback(request, e, callback);
}
@Override
public void onResponse(final Response response) {
try {
final String string = response.body().string();
sendSuccessResultCallback(string, callback);
} catch (IOException e) {
sendFailedStringCallback(response.request(), e, callback);
}
}
});
}这部分传递的就是请求结果了，我们把请求后的结果自己去进行操作，来个callback吧！
private void sendFailedStringCallback(final Request request, final Exception e, final INetClientHandler callback) {
mDelivery.post(new Runnable() {
@Override
public void run() {
if (callback != null) {
callback.onNetFail();//记得这里吗 是我们接口定义的回调啊
callback.onFinish();
}
}
});
}这里给出了网络状态异常
private void sendSuccessResultCallback(final Object object, final INetClientHandler callback) {
mDelivery.post(new Runnable() {
@Override
public void run() {
if (callback != null) {
Log.i("test", object.toString());
ResponseBody body = ResponseBody.parse(object.toString());
if (body.isOK()) {
callback.onSuccess(object.toString());
callback.onFinish();
} else {
IErrorBody ieb = IErrorBody.CODEERROR;
ieb.setCode(body.getCode());
ieb.setMessage(body.getMessage());
callback.onFailed(object.toString());
callback.onStateFail(ieb);
callback.onFinish();
}
}
}
});
}这里就是我们成功时候的回调啦，client类封装完毕，但我们怎么给出去呢，我们提供了一个方法，调用就可以啦！
//*************对外公布的方法************
public static void postAsyn(String url, final INetClientHandler callback, Map<String, String> params) {
getInstance()._postAsyn(url, callback, params);
}这是封装内部做的事情，那么怎么使用呢？这就让NetManager登场啦！
举个栗子
/**
* 注册
* @param absParams
* @param handler
*/
public static void regsiter(AbsHashParams absParams, final INetClientHandler handler){
Map<String,String> map= ParamsHelper.getParams(absParams);
OkHttpClientManager.postAsyn(UrlInterface.API_REGISTER, handler, map);
}
显然这是项目中注册的接口，只需要直接调用就行啦 NetManager.regsiter(),当然我们要传递点参数啦 AbsHashParams 登场，这个类是个抽象类。
public abstract class AbsHashParams extends AbsParams{
@Override
public Map<String, String> getMap() {
Map<String,String> map=new HashMap<>();
//传递共有的参数，方便以后封板加密或者增加共有参数
map.put("channel_id", "1");
// if(CommonParams.getSign()!=null){
// map.put("sign", CommonParams.getSign());
//
// CommonUtil.getSign(context,"com.luochen.reader")
// }
map.put("sign", CommonUtil.getSign(AppUtils.getAppContext(),"com.luochen.reader"));
map.put("device_id", CommonParams.getDevice_id());
map.put("timestamp", System.currentTimeMillis() + "");
if(StringUtils.isValid(CommonParams.getToken())){
map.put("uid", CommonParams.getUid());
map.put("token", CommonParams.getToken());
}
// map.put("uid", CommonParams.getUid());
// map.put("token", CommonParams.getToken());
getOtherParams(map);
return map;
}
public abstract Map<String, String> getOtherParams(Map<String,String> map);
}我们把每次需要的参数都放在上面的方法，如果需要其他的就重写getOtherParams（）方法，返回个map就行了，上面的参数读者不必深究，无外乎就是token 签名 用户id等基础信息，这些读者可以根据自身项目去重新写。
注意：上面说到INetClientHandler ，当然我们不需要时刻的去重写不需要的接口，这违反了设计模式6大原则的内容，即我们不要依赖我们不需要的接口，即接口隔离原则。所以就得重写啦
public class NetClientHandler implements INetClientHandler {
private Context context;
public NetClientHandler(@NonNull Context context) {
this.context = context;
}
@Override
public void onSuccess(String response) {
Log.i("test", "response=" + response);
}
@Override
public void onNetFail() {
if (context != null) {
// ToasterHelper.show(context, "您的网络异常，请检查网络!!");
Toast.makeText(context,"您的网络异常，请检查网络!!",Toast.LENGTH_SHORT).show();
}
// else if (TUtils.isValid(AppUtils.getAppContext())) {
// ToasterHelper.show(context, "您的网络异常，请检查网络!!");
// }
}
@Override
public void onStateFail(IErrorBody iErrorBody) {
if (!CommonUtil.isEmpty(iErrorBody)) {
if(iErrorBody.getMessage()!=null){
// ToasterHelper.show(context.getApplicationContext(), iErrorBody.getMessage().toString());
Toast.makeText(context,iErrorBody.getMessage().toString(),Toast.LENGTH_SHORT).show();
}
}
if (iErrorBody.getCode() == 1008) {
return;
} else {
if (!CommonUtil.isEmpty(iErrorBody.getMessage()))
// ToasterHelper.show(context, iErrorBody.getMessage());
Toast.makeText(context,iErrorBody.getMessage(),Toast.LENGTH_SHORT).show();
}
}
@Override
public void onFinish() {
}
@Override
public void onFailed(String response) {
}
}
//注册
NetManager.regsiter(new AbsHashParams() {
@Override
public Map<String, String> getOtherParams(Map<String, String> map) {
//所有传递的数据
map.put("username","yuan");
map.put("password","123");
return map;
}
}, new INetClientHandler() {
@Override
public void onSuccess(String response) {
//成功时 response返回的json
}
@Override
public void onNetFail() {
//网络失败时
}
@Override
public void onStateFail(IErrorBody iErrorBody) {
//服务器异常
}
@Override
public void onFinish() {
//结束时 这里可以给出关闭提示框等等
}
@Override
public void onFailed(String response) {
//失败时
}
});这里我们给出了具体处理方法，对服务器错误的处理，对网络错误的处理，如果不用就让父类处理，如果想其他的就重写这个方法。处理特殊的需求。至此，本次的封装OkHttp主要的类就到这里了，难免代码有误，请指正。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
