android框架搭建——二次封装Volley框架

上一篇博文中提到了自己写一个网络工具类，然而自己的能力明显有限，封装的工具类无论从功能还是性能上都比不上前辈大牛们已经完善好的网络框架，但是我们又想更加方便的使用大牛们的框架，怎么办呢？我们可以二次封装一下网上的网络框架，让它们使用起来更加的方便，这里以目前很流行的Volley为例：

直接使用Volley的Get请求时的步骤：

1.首先要创建一个全局的Volley队列，我们可以写一个MyApplication类继承Application，在该类的onCreate方法中创建队列。

2.在Activity中通过Volley的Get请求获取参数。

3.请求完成后给请求增加Tag，并加入到Volley队列中。

4.在Activity的onStop()方法中删除队列中的请求

代码如下：

Myapplication.java:

/**
 * Created by 95 on 2015/10/14.
 */
public class MyApplication extends Application {
    /**
     * 先创建一个请求队列，因为这个队列是全局的，所以在Application中声明这个队列
     */
    public static RequestQueue queues;
    @Override
    public void onCreate() {
        super.onCreate();
        queues = Volley.newRequestQueue(getApplicationContext());
    }
    public static RequestQueue getQueues() {
        return queues;
    }
}

MainActivity.java:

    private void Volley_Get() {
        String url = Codes.ROOT_URL;
        JsonObjectRequest request = new JsonObjectRequest(Request.Method.GET, url, null, new Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject jsonObject) {
                Log.i("请求成功");
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {
		 Log.i("请求失败");
            }
        });
        request.setTag("login_Get");
        MyApplication.getQueues().add(request);
    }

MainActivity.java:

@Override
protected void onStop() {
        super.onStop();
        //删除队列中的请求
        MyApplication.getQueues().cancelAll("lesson_Post");
    }

步骤2的JsonObjectRequest()方法中的第一个参数是请求的模式（GET，POST），第二个参数是是url地址，第三个参数在GET模式下用不到，直接填null，后两个参数分别是成功和失败时的回调。

下面再来看看直接使用Volley的Post请求时的代码：

MainActivity.java:

 private void Volley_Post() {
        String url = Codes.ROOT_URL + "/lesson/index.api?";
        //有两种添加params的方式：1.复写getParams方法，在StringRequest对象后面加一个{getparams(){..}}
        //2.直接添加在JsonObjectRequest的Object参数中，方法如下：
        /*
        Map<String,String> hashMap = new HashMap<String,String>;
        hashMap.put(..)
        ..
        JSONObject object = new JSONObect(hashMap);
         */
        JsonObjectRequest request = new JsonObjectRequest(Request.Method.POST, url, null, new Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject jsonObject) {
                Log.i(MainActivity.this.getClass().getSimpleName(), "result>>" + jsonObject);
                lesson = new Gson().fromJson(jsonObject + "", new TypeToken<ApiBean<LessonBean>>() {
                }.getType());
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {

            }
        }) {
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                Map<String, String> hashMap = new HashMap<String, String>();
                hashMap.put("sort", 3 + "");
                return hashMap;
            }
        };
        request.setTag("lesson_Post");
        MyApplication.getQueues().add(request);
    }

大家都知道，Post有别于Get的地方在于请求参数并非直接加在url后面，在Volley框架中，有两种方式来添加Post模式下的请求参数，一种如代码中所写，复写JsonObjectRequst对象的getParams()方法，另一种则是在JsonObjectRequest构造方法的第三个参数处（之前Get模式下这里是null）添加请求参数，这个参数的类型是Object，我们先将请求参数加载进HashMap中，再将HashMap转换成JsonObject，如代码中注释所写的那样。同样的，在用post方式调接口时也需要创建标签和加入队列，在使用完毕后要将队列中的请求清除。

看到这里大家应该有个感觉，那就是每次请求数据都要给请求添加标签以及加入到队列中，使用完毕后还要从队列中清除请求太麻烦了，所以我们可以对Volley进行二次封装，先上代码：

抽象类VolleyInterface.java:

/**
 * 二次封装的好处：提高全局控制性，如果有要修改的地方，只需要改接口一个地方就好了
 */
public abstract class VolleyInterface {
    private Context context;
    public Response.Listener<String> listener;
    public Response.ErrorListener errorListener;

    public VolleyInterface(Context context) {
        this.context = context;
    }

    public abstract void onMySuccess(String result);

    public abstract void onMyError(VolleyError error);

    public Response.Listener<String> loadingListener() {
        listener = new Response.Listener<String>() {
            @Override
            public void onResponse(String s) {
                onMySuccess(s);
            }
        };
        return listener;
    }

    public Response.ErrorListener errorListener() {
        errorListener = new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {
                onMyError(volleyError);
            }
        };
        return errorListener;
    }
}

VolleyRequest.java:

public class VolleyRequest {
    public static StringRequest request;
    private Context context;

    public static void RequestGet(Context context, String url, String tag,VolleyInterface vif) {
        MyApplication.getQueues().cancelAll(tag);
        request = new StringRequest(Request.Method.GET, url,vif.loadingListener(),vif.errorListener());
        request.setTag(tag);
        MyApplication.getQueues().add(request);
        MyApplication.getQueues().start();
    }



    public static void RequestPost(Context context, String url, String tag, final Map<String,String> params,VolleyInterface vif) {
        MyApplication.getQueues().cancelAll(tag);
        request = new StringRequest(Request.Method.POST, url,vif.loadingListener(),vif.errorListener()){
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                return params;
            }
        };
        request.setTag(tag);
        MyApplication.getQueues().add(request);
        MyApplication.getQueues().start();
    }
}

MainActivity.java:

 private void Volley_Package() {
        String url = Codes.ROOT_URL;
        VolleyRequest.RequestGet(this, url, "Volley_package", new VolleyInterface(this) {
            @Override
            public void onMySuccess(String result) {
                Toast.makeText(MainActivity.this, "result=" + result, Toast.LENGTH_SHORT).show();
            }

            @Override
            public void onMyError(VolleyError error) {

            }
        });
    }

首先我们写一个类VolleyRequest.java，在该类中写两个方法分别对应get请求和post请求，大部分操作都和之前直接使用Volley框架类似，唯一的区别在于我们不可能在封装类中实现成功和失败后的回调（即JsonObjectRequest构造方法的最后两个参数）。所以我们写一个抽象类VolleyInterface.java，在这个抽象类中写两个方法获取成功回调和失败回调：loadingListener和errorListener，并在这两个方法中分别对成功回调和失败回调进行初始化，实现回调的抽象方法。然后在VolleyInterface.java中定义两个抽象方法：onMySuccess(),onMyError()。把这两个抽象方法放入已实现的回调方法中。ok，现在回到封装类VolleyRequest.java中，在最后两个参数处调用VolleyInterface.java的获取成功回调和获取失败回调的两个方法，因为这两个回调已经实现，所以不需要在封装类中实现回调了。通过这种方式，我们依然还是在Activity中实现回调的具体操作，并且极大的简化了使用时的代码量。

ok，二次封装Volley完成。