转-封装网络请求库，统一处理通用异常 (基于volley网络请求库)

/article/1838551.html

一、前言

volley的发布让网络请求也变得十分便利，但是我们通常懒得很想用一两句代码实现一个网络请求，其实你再经过封装就可以做到的。还有就是实际开发当中，我们会常常遇到很多异常情况，如网络异常、超时异常等等，那么我们如果有10个activity需要请求数据，那么在10个activity当中都去处理这些异常就变得十分麻烦，通过合理的设计其实我们能够在一个地方对异常情况进行统一处理，只有正确情况，才把数据返回给activity进行展示。这里我要介绍的就是这种方法，实际开发当中，合理的设计一些代码是很重要的，可以让你的开发变得更加简便、快捷。就像一样的食料，交给一个厨师和一个不会做饭的人，做出来的显然是不同的。

二、demo

喜欢通过实际demo来阐述一个解决问题的办法。上代码

1、首先是对volley进行再封装，这里只是简单的用了几个方法而已，volley还有很多强大的地方等待你去发现，我算抛砖引玉吧~~

[java] view plaincopy

package com.kroc.net;

import java.util.Map;

import android.content.Context;

import android.os.Message;

import com.android.volley.AuthFailureError;

import com.android.volley.Request;

import com.android.volley.RequestQueue;

import com.android.volley.Response.ErrorListener;

import com.android.volley.Response.Listener;

import com.android.volley.TimeoutError;

import com.android.volley.VolleyError;

import com.android.volley.toolbox.StringRequest;

import com.android.volley.toolbox.Volley;

import com.kroc.app.MyApp;

import com.kroc.util.NetWorkUtil;

/**

* @author 林楷鹏

* @description 网络相关工具类

* @create 2014-9-27下午5:15:43

*

*/

public class NetHelper {

private static RequestQueue requestQueue;//volley请求队列

private CommonHandler mHandler;

private Context mContext;

public NetHelper(Context context, CommonHandler mHandler) {

this.mContext = context;

this.mHandler = mHandler;

}

/**

* 获取volley请求队列

* @return

*/

public static RequestQueue getRequestQueue(){

if(requestQueue == null){

requestQueue = Volley.newRequestQueue(MyApp.getApp());

}

return requestQueue;

}

/**

* post方式请求数据

* @param url

* @param params

*/

public void postAsString(String url, final Map<String, String> params){

if(!NetWorkUtil.checkNetWork(mContext)){

mHandler.createExceptionMsg(new CNoNetWorkException());

return;

}

StringRequest request = new StringRequest(Request.Method.POST, url, resListener, errorListener){

protected Map<String,String> getParams() throws AuthFailureError {

return params;

};

};

getRequestQueue().add(request);

}

/**

* get方式请求数据

* @param url

*/

public void getAsString(String url){

if(!NetWorkUtil.checkNetWork(mContext)){

mHandler.createExceptionMsg(new CNoNetWorkException());

return;

}

StringRequest request = new StringRequest(Request.Method.GET, url, resListener, errorListener);

getRequestQueue().add(request);

}

/**

* 响应回调

*/

private Listener<String> resListener = new Listener<String>() {

@Override

public void onResponse(String response) {

Message msg = mHandler.obtainMessage();

msg.obj = response;

mHandler.handleMessage(msg);

}

};

/**

* 错误回调

*/

private ErrorListener errorListener = new ErrorListener() {

@Override

public void onErrorResponse(VolleyError error) {

if(error instanceof TimeoutError){

mHandler.createExceptionMsg(new CTimeOutException());

}

}

};

}

结合部分注释我相信还是可以看懂的，主要解释下几个重点：

正确响应了，通过handler进行分发响应结果：

[java] view plaincopy

private Listener<String> resListener = new Listener<String>() {

@Override

public void onResponse(String response) {

Message msg = mHandler.obtainMessage();

msg.obj = response;

mHandler.handleMessage(msg);

}

};

异常情况，就传入自己写的handler的子类CommonHandler处理，下面会有介绍该类：

[java] view plaincopy

/**

* 错误回调

*/

private ErrorListener errorListener = new ErrorListener() {

@Override

public void onErrorResponse(VolleyError error) {

if(error instanceof TimeoutError){

mHandler.createExceptionMsg(new CTimeOutException());

}

}

};

2、继承handler的CommonHandler，写成抽象类就是一种设计，设计模式当中叫做模板设计模式，如果不了解，可以看我的另外文章有介绍：《设计模式学习（一）—— 模板设计模式》。

[java] view plaincopy

package com.kroc.net;

import java.util.Map;

import android.os.Handler;

import android.os.Message;

import com.kroc.test.BaseActivity;

/**

* @author 林楷鹏

* @description 网络结果处理

* @create 2014-9-28下午5:10:26

*

*/

public abstract class CommonHandler extends Handler {

protected BaseActivity mActivity;

protected ICallBack mCallBack;//结果回调

protected NetHelper mNetHelper;

public CommonHandler(BaseActivity activity) {

this.mActivity = activity;

}

public NetHelper getNetHelper(){

if(mNetHelper == null){

mNetHelper = new NetHelper(mActivity, this);

}

return mNetHelper;

}

/**

* 非通用处理，交给各个请求地方自己处理

* @param msg

*/

public abstract void handleMainMessage(Message msg);

/**

* 请求服务器(不带参数)

* @param url

* @param callBack

*/

public abstract void request(ICallBack callBack, String url);

/**

* 请求服务器(带参数)

* @param url

* @param callBack

* @param params

*/

public abstract void request(ICallBack callBack, String url, Map<String, String> params);

@Override

public void handleMessage(Message msg) {

switch (msg.what) {

case NetValue.STATUS_NO_NETWORK:

case NetValue.STATUS_TIMEOUT:

case NetValue.STATUS_UNKNOWN:

showToast(msg.obj.toString());

break;

default:

handleMainMessage(msg);

break;

}

}

/**

* 处理通用异常，将异常封装成message分发出去，如超时、网络异常等

* @param exc

*/

public void createExceptionMsg(Exception exc){

Message msg = this.obtainMessage();

if(exc instanceof CNoNetWorkException){

msg.what = NetValue.STATUS_NO_NETWORK;

msg.obj = NetValue.TIP_NO_NETWORK;

}else if(exc instanceof CTimeOutException){

msg.what = NetValue.STATUS_TIMEOUT;

msg.obj = NetValue.TIP_TIMEOUT;

}else{

msg.what = NetValue.STATUS_UNKNOWN;

msg.obj = NetValue.TIP_UNKNOWN;

}

sendMessage(msg);

}

private void showToast(String content){

//TODO 自己实现个toast显示

System.out.println(content);

}

}

类中主要的点就在对异常数据的处理，如下：

[java] view plaincopy

/**

* 处理通用异常，将异常封装成message分发出去，如超时、网络异常等

* @param exc

*/

public void createExceptionMsg(Exception exc){

Message msg = this.obtainMessage();

if(exc instanceof CNoNetWorkException){

msg.what = NetValue.STATUS_NO_NETWORK;

msg.obj = NetValue.TIP_NO_NETWORK;

}else if(exc instanceof CTimeOutException){

msg.what = NetValue.STATUS_TIMEOUT;

msg.obj = NetValue.TIP_TIMEOUT;

}else{

msg.what = NetValue.STATUS_UNKNOWN;

msg.obj = NetValue.TIP_UNKNOWN;

}

sendMessage(msg);

}

在此方法当中将异常装到message当中，然后send出去，再复写handleMessage(Message msg)进行处理，如下：

[java] view plaincopy

@Override

public void handleMessage(Message msg) {

switch (msg.what) {

case NetValue.STATUS_NO_NETWORK:

case NetValue.STATUS_TIMEOUT:

case NetValue.STATUS_UNKNOWN:

showToast(msg.obj.toString());

break;

default:

handleMainMessage(msg);

break;

}

}

这里就可以将通用的异常解决掉了，剩下的就是正确的结果，交给handleMainMessage(Message msg)，而你可以发现，这个方法我把它定义成抽象方法，为何？就要子类自己去实现处理，这就是模板设计模式的一个好处。

3、好啦，比较重点的两个类也在此。折腾了这么一会，上些测试代码看看怎样~~此类继承了刚刚的抽象类CommonHandler，实现抽象方法：

[java] view plaincopy

package com.kroc.test;

import java.util.Map;

import android.os.Message;

import com.kroc.net.CommonHandler;

import com.kroc.net.ICallBack;

public class TestBusiness extends CommonHandler {

public TestBusiness(BaseActivity activity) {

super(activity);

}

@Override

public void handleMainMessage(Message msg) {

mCallBack.displayResult(ICallBack.SUCCESS, msg.obj.toString());

}

@Override

public void request(ICallBack callBack, String url) {

this.mCallBack = callBack;

getNetHelper().getAsString(url);

}

@Override

public void request(ICallBack callBack, String url,

Map<String, String> params) {

}

}

这里为了方便测试，我用get请求，准备请求个百度网页哈哈~此类我通常叫做xx的业务处理层，由于demo简陋，就没太多东西，实际当中就在这里处理数据，解析json、存储到文件、数据库啊等等等等......

最后在activity中发起请求，拿到结果，就几行，真的。

[java] view plaincopy

package com.kroc.test;

import com.kroc.net.ICallBack;

import com.kroc.net.NetValue;

import android.os.Bundle;

public class TestActivity extends BaseActivity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

//请求数据

TestBusiness business = new TestBusiness(this);

business.request(new ICallBack() {

@Override

public void displayResult(int status, Object... params) {

//处理结果

System.out.println("结果这里："+params[0]);

}

}, NetValue.TEST_URL);

}

}

我们看看打印结果，为了展示方便就这样简陋点啦，不要在意这些细节哈哈~~

正常情况如下：



然后，试下异常，关掉手机WiFi、还有3G网络，结果如下：



好啦，大概就是这样，不好的还希望批判哈哈~别太粗鲁哦。

~~~~代码下载~~~~

版权声明：本文为博主原创文章，未经博主允许不得转载。