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

http://blog.csdn.net/kroclin/article/details/40540761

一、前言

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

二、demo

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

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

1. package com.kroc.net;
2. import java.util.Map;
3. import android.content.Context;
4. import android.os.Message;
5. import com.android.volley.AuthFailureError;
6. import com.android.volley.Request;
7. import com.android.volley.RequestQueue;
8. import com.android.volley.Response.ErrorListener;
9. import com.android.volley.Response.Listener;
10. import com.android.volley.TimeoutError;
11. import com.android.volley.VolleyError;
12. import com.android.volley.toolbox.StringRequest;
13. import com.android.volley.toolbox.Volley;
14. import com.kroc.app.MyApp;
15. import com.kroc.util.NetWorkUtil;
16. /**
17. * @author 林楷鹏
18. * @description 网络相关工具类
19. * @create 2014-9-27下午5:15:43
20. *
21. */
22. public class NetHelper {
23. private static RequestQueue requestQueue;//volley请求队列
24. private CommonHandler mHandler;
25. private Context mContext;
26. public NetHelper(Context context, CommonHandler mHandler) {
27. this.mContext = context;
28. this.mHandler = mHandler;
29. }
30. /**
31. * 获取volley请求队列
32. * @return
33. */
34. public static RequestQueue getRequestQueue(){
35. if(requestQueue == null){
36. requestQueue = Volley.newRequestQueue(MyApp.getApp());
37. }
38. return requestQueue;
39. }
40. /**
41. * post方式请求数据
42. * @param url
43. * @param params
44. */
45. public void postAsString(String url, final Map<String, String> params){
46. if(!NetWorkUtil.checkNetWork(mContext)){
47. mHandler.createExceptionMsg(new CNoNetWorkException());
48. return;
49. }
50. StringRequest request = new StringRequest(Request.Method.POST, url, resListener, errorListener){
51. protected Map<String,String> getParams() throws AuthFailureError {
52. return params;
53. };
54. };
55. getRequestQueue().add(request);
56. }
57. /**
58. * get方式请求数据
59. * @param url
60. */
61. public void getAsString(String url){
62. if(!NetWorkUtil.checkNetWork(mContext)){
63. mHandler.createExceptionMsg(new CNoNetWorkException());
64. return;
65. }
66. StringRequest request = new StringRequest(Request.Method.GET, url, resListener, errorListener);
67. getRequestQueue().add(request);
68. }
69. /**
70. * 响应回调
71. */
72. private Listener<String> resListener = new Listener<String>() {
73. @Override
74. public void onResponse(String response) {
75. Message msg = mHandler.obtainMessage();
76. msg.obj = response;
77. mHandler.handleMessage(msg);
78. }
79. };
80. /**
81. * 错误回调
82. */
83. private ErrorListener errorListener = new ErrorListener() {
84. @Override
85. public void onErrorResponse(VolleyError error) {
86. if(error instanceof TimeoutError){
87. mHandler.createExceptionMsg(new CTimeOutException());
88. }
89. }
90. };
91. }

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

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

1. private Listener<String> resListener = new Listener<String>() {
2. @Override
3. public void onResponse(String response) {
4. Message msg = mHandler.obtainMessage();
5. msg.obj = response;
6. mHandler.handleMessage(msg);
7. }
8. };

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

1. /**
2. * 错误回调
3. */
4. private ErrorListener errorListener = new ErrorListener() {
5. @Override
6. public void onErrorResponse(VolleyError error) {
7. if(error instanceof TimeoutError){
8. mHandler.createExceptionMsg(new CTimeOutException());
9. }
10. }
11. };

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

1. package com.kroc.net;
2. import java.util.Map;
3. import android.os.Handler;
4. import android.os.Message;
5. import com.kroc.test.BaseActivity;
6. /**
7. * @author 林楷鹏
8. * @description 网络结果处理
9. * @create 2014-9-28下午5:10:26
10. *
11. */
12. public abstract class CommonHandler extends Handler {
13. protected BaseActivity mActivity;
14. protected ICallBack mCallBack;//结果回调
15. protected NetHelper mNetHelper;
16. public CommonHandler(BaseActivity activity) {
17. this.mActivity = activity;
18. }
19. public NetHelper getNetHelper(){
20. if(mNetHelper == null){
21. mNetHelper = new NetHelper(mActivity, this);
22. }
23. return mNetHelper;
24. }
25. /**
26. * 非通用处理，交给各个请求地方自己处理
27. * @param msg
28. */
29. public abstract void handleMainMessage(Message msg);
30. /**
31. * 请求服务器(不带参数)
32. * @param url
33. * @param callBack
34. */
35. public abstract void request(ICallBack callBack, String url);
36. /**
37. * 请求服务器(带参数)
38. * @param url
39. * @param callBack
40. * @param params
41. */
42. public abstract void request(ICallBack callBack, String url, Map<String, String> params);
43. @Override
44. public void handleMessage(Message msg) {
45. switch (msg.what) {
46. case NetValue.STATUS_NO_NETWORK:
47. case NetValue.STATUS_TIMEOUT:
48. case NetValue.STATUS_UNKNOWN:
49. showToast(msg.obj.toString());
50. break;
51. default:
52. handleMainMessage(msg);
53. break;
54. }
55. }
56. /**
57. * 处理通用异常，将异常封装成message分发出去，如超时、网络异常等
58. * @param exc
59. */
60. public void createExceptionMsg(Exception exc){
61. Message msg = this.obtainMessage();
62. if(exc instanceof CNoNetWorkException){
63. msg.what = NetValue.STATUS_NO_NETWORK;
64. msg.obj = NetValue.TIP_NO_NETWORK;
65. }else if(exc instanceof CTimeOutException){
66. msg.what = NetValue.STATUS_TIMEOUT;
67. msg.obj = NetValue.TIP_TIMEOUT;
68. }else{
69. msg.what = NetValue.STATUS_UNKNOWN;
70. msg.obj = NetValue.TIP_UNKNOWN;
71. }
72. sendMessage(msg);
73. }
74. private void showToast(String content){
75. //TODO 自己实现个toast显示
76. System.out.println(content);
77. }
78. }

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

1. /**
2. * 处理通用异常，将异常封装成message分发出去，如超时、网络异常等
3. * @param exc
4. */
5. public void createExceptionMsg(Exception exc){
6. Message msg = this.obtainMessage();
7. if(exc instanceof CNoNetWorkException){
8. msg.what = NetValue.STATUS_NO_NETWORK;
9. msg.obj = NetValue.TIP_NO_NETWORK;
10. }else if(exc instanceof CTimeOutException){
11. msg.what = NetValue.STATUS_TIMEOUT;
12. msg.obj = NetValue.TIP_TIMEOUT;
13. }else{
14. msg.what = NetValue.STATUS_UNKNOWN;
15. msg.obj = NetValue.TIP_UNKNOWN;
16. }
17. sendMessage(msg);
18. }

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

1. @Override
2. public void handleMessage(Message msg) {
3. switch (msg.what) {
4. case NetValue.STATUS_NO_NETWORK:
5. case NetValue.STATUS_TIMEOUT:
6. case NetValue.STATUS_UNKNOWN:
7. showToast(msg.obj.toString());
8. break;
9. default:
10. handleMainMessage(msg);
11. break;
12. }
13. }

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

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

1. package com.kroc.test;
2. import java.util.Map;
3. import android.os.Message;
4. import com.kroc.net.CommonHandler;
5. import com.kroc.net.ICallBack;
6. public class TestBusiness extends CommonHandler {
7. public TestBusiness(BaseActivity activity) {
8. super(activity);
9. }
10. @Override
11. public void handleMainMessage(Message msg) {
12. mCallBack.displayResult(ICallBack.SUCCESS, msg.obj.toString());
13. }
14. @Override
15. public void request(ICallBack callBack, String url) {
16. this.mCallBack = callBack;
17. getNetHelper().getAsString(url);
18. }
19. @Override
20. public void request(ICallBack callBack, String url,
21. Map<String, String> params) {
22. }
23. }

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

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

1. package com.kroc.test;
2. import com.kroc.net.ICallBack;
3. import com.kroc.net.NetValue;
4. import android.os.Bundle;
5. public class TestActivity extends BaseActivity {
6. @Override
7. protected void onCreate(Bundle savedInstanceState) {
8. super.onCreate(savedInstanceState);
9. //请求数据
10. TestBusiness business = new TestBusiness(this);
11. business.request(new ICallBack() {
12. @Override
13. public void displayResult(int status, Object... params) {
14. //处理结果
15. System.out.println("结果这里："+params[0]);
16. }
17. }, NetValue.TEST_URL);
18. }
19. }

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

正常情况如下：

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

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

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

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