android volley解析与二次封装

　　最近看到一本书，其中有一句话写的不错：实际上，将第三方API打包是个良好的实践手段，当你打包一个第三方API，你就降低了对它的依赖，未来你可以不太痛苦地改用其他代码库，在你测试自己的代码时，打包也有助于模拟第三方调用。打包的好处还在于你不必帮死在某个特定的API设计上。你可以定义自己感觉舒服的API。

　　现在我们公司的应用就有这个问题，老大不知道出于什么考虑，使用的是AQuery框架进行的网络访问和图片加载，很多人可能没有听说过这个库，因为github上显示它已经在2013年停止更新了。那么现在如果需要更新整个应用的框架成volley怎么办？答案是很难，非常难，整个应用和AQuery框架耦合非常严重，修改起来的难度和时间成本都不可估计。

　　基于以上上下文，Volley尽管已经很完善了，但是为了以后的考虑，还是需要将Volley进行简单封装，外部不能直接使用Volley相关类，只能使用通过封装之后提供的api进行网络访问和图片加载。

在封装一个api之前需要详细了解一下这个api，网上的Volley介绍太多了，我列出几个讲的比较好的：

https://bxbxbai.github.io/2014/09/14/android-working-with-volley/　　这个主要是讲了一下Volley的用法
http://code.tutsplus.com/tutorials/an-introduction-to-volley--cms-23800　　这个介绍了Volley的一些实用功能，比如header，cookies和访问优先级
http://www.androidhive.info/2014/05/android-working-with-volley-library-1/　　这个博客将Volley进行了简单的封装

看完这些博客之后，应该对使用有了初步了解，下面是对Volley源码的详细分析：

http://www.chengxuyuans.com/Android/90526.html

还有一个比较重要和实用的是Volley有一个判断缓存是否失效的功能，这个功能主要是通过Request类的parseNetworkResponse()方法来获取网络数据的header
        HttpHeaderParser.parseCacheHeaders(response)
根据header里面的信息来判断缓存的失效


   现在我的初步想法是有两种方案，第一种是将Volley只进行简单的封装，方便使用，这种封装方式的优点是可以使用Volley的所有功能，缺点是会造成整个项目和Volley第三方API的耦合程度很高，不方便以后的修改；第二种就是将Volley进行高程度封装，外部不允许调用任何原生Volley的功能，只能使用封装类提供的接口，这种方案优点是可以非常方便的修改框架，缺点就是无法完全使用Volley的各种功能，只能使用最基本的功能。

   这是我的想法，不知道是不是错的，小白一个，只能想到这种拙劣的解决方案，望指点。

　　有了这两种方案，于是就开始着手写代码封装了

　　第一种方案：

BaseVolleyApi.class类

public abstract class BaseVolleyApi {
    private static RequestQueue requestQueue;
    private static ImageLoader imageLoader;

    public static RequestQueue getRequestQueue() {
        if (requestQueue == null) {
            synchronized (BaseVolleyApi.class){
                if (requestQueue == null)
                    requestQueue = Volley.newRequestQueue(RootApplication.getInstance());
            }
        }
        return requestQueue;
    }

    public static ImageLoader getImageLoader() {
        if (imageLoader == null) {
            synchronized (BaseVolleyApi.class) {
                if (imageLoader == null){
                    VolleyLruCache cache = new VolleyLruCache();
                    imageLoader = new ImageLoader(getRequestQueue(), cache);
                }
            }
        }
        return imageLoader;
    }
}

VolleyLruCache.class类

public class VolleyLruCache extends LruCache<String, Bitmap> implements ImageLoader.ImageCache{

    private static int getCacheSize(){
        return (int)(Runtime.getRuntime().maxMemory()/1024/8);
    }

    public VolleyLruCache() {
        this(getCacheSize());
    }

    private VolleyLruCache(int size){
        super(size);
    }

    @Override
    public Bitmap getBitmap(String url) {
        return get(url);
    }

    @Override
    public void putBitmap(String url, Bitmap bitmap) {
        put(url, bitmap);
    }
}

上面的实现方案就是第一种，简单封装，方便使用，耦合度很大，不方便以后的框架修改

第二种方案：

第二种方案就比较复杂了，主要是要对Volley的功能进行抽取，选出最基本的功能进行封装，这样就能够相对轻松的更换框架。这种方案的代码复杂度就比较高了，网络访问和图片加载就需要分成两个单独的类去处理。

BaseNetApi.class类

public abstract class BaseNetApi {
    /** 网络访问requestQueue */
    private RequestQueue requestQueue;

    private RequestQueue getRequestQueue(int maxDiskCacheBytes){
        if (requestQueue == null)
            requestQueue = Volley.newRequestQueue(RootApplication.getInstance(), maxDiskCacheBytes);
        return requestQueue;
    }

    protected RequestQueue getRequestQueue(){
        return getRequestQueue(-1);
    }

    /**
     * 回调接口
     */
    public interface OnNetCallback<T>{
        void onSuccess(T result);
        void onFail(NetError error);
    }

    private boolean checkIfExtendsRequest(Class clazz){
        while (clazz.getSuperclass() != null){
            clazz = clazz.getSuperclass();
            if (clazz == Request.class)
                return true;
        }
        return false;
    }

    /**
     * 网络请求
     */
    protected <T> void makeRequest(final Context context, Class<?> clazz, String url, final Map<String, String> params, final OnNetCallback<T> callback){
        //网络请求
        Request request = null;
        //失败回调
        Response.ErrorListener errorListener = null;
        //成功回调
        Response.Listener listener = null;
        //判空
        if (callback != null) {
            errorListener = new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    if (context instanceof Activity && (((Activity)(context)).isFinishing())) {
                        L.i("activity finish, not callback");
                        return ;
                    }
                    NetError netError = new NetError();
                    netError.transferVolleyError(error);
                    callback.onFail(netError);
                }
            };
            listener = new Response.Listener<T>() {
                @Override
                public void onResponse(T response) {
                    if (context instanceof Activity && (((Activity)(context)).isFinishing())) {
                        L.i("activity finish, not callback");
                        return ;
                    }
                    callback.onSuccess(response);
                }
            };
        }

        //启动网络请求
        if (clazz == ImageRequest.class){
            throw new IllegalArgumentException("please use imageloader");
        }else if (checkIfExtendsRequest(clazz)) {
            try {
                Constructor constructor = clazz.getConstructor(int.class, String.class, Response.Listener.class,
                        Response.ErrorListener.class, Map.class);
                int method = Request.Method.GET;
                if (params != null)
                    method = Request.Method.POST;
                request = (Request) constructor.newInstance(method, url, listener, errorListener, params);
            } catch (Exception e) {
                L.e("error reflect", e);
                return;
            }
        }else {
            throw new IllegalArgumentException("unsupported type");
        }

        //自定义超时时间，重试次数
//        request.setRetryPolicy(new DefaultRetryPolicy());
        getRequestQueue().add(request);
    }

    /**
     * 对{@linkplain StringRequest}的封装类
     */
    private static class StringRequestImpl extends StringRequest{
        private Map<String, String> params;

        public StringRequestImpl(int method, String url, Response.Listener<String> listener,
                                 Response.ErrorListener errorListener, Map<String, String> params) {
            super(method, url, listener, errorListener);
            this.params = params;
        }

        @Override
        protected Map<String, String> getParams() throws AuthFailureError {
            return params;
        }
    }

    /**
     * 对{@linkplain JsonObjectRequest}的封装类
     */
    private static class JsonObjectRequestImpl extends JsonObjectRequest{
        private Map<String, String> params;

        public JsonObjectRequestImpl(int method, String url, Response.Listener<JSONObject> listener,
                                 Response.ErrorListener errorListener, Map<String, String> params) {
            super(method, url, listener, errorListener);
            this.params = params;
        }

        @Override
        protected Map<String, String> getParams() throws AuthFailureError {
            return params;
        }
    }

    /**
     * 对{@linkplain JsonArrayRequest}的封装类
     */
    private static class JsonArrayRequestImpl extends JsonArrayRequest{
        private Map<String, String> params;

        public JsonArrayRequestImpl(int method, String url, Response.Listener<JSONArray> listener,
                                 Response.ErrorListener errorListener, Map<String, String> params) {
            super(method, url, listener, errorListener);
            this.params = params;
        }

        @Override
        protected Map<String, String> getParams() throws AuthFailureError {
            return params;
        }
    }

    /**
     * string 请求
     * @param context 相关上下文
     * @param url　网络访问url
     * @param params 网络请求参数
     * @param callback　网络请求回调
     */
    public void stringRequest(Context context, String url, Map<String, String> params, OnNetCallback<String> callback){
        makeRequest(context, StringRequestImpl.class, url, params, callback);
    }

    /**
     * jsonObject 请求
     * @param context 相关上下文
     * @param url　网络访问url
     * @param params 网络请求参数
     * @param callback　网络请求回调
     */
    public void jsonObjectRequest(Context context, String url, Map<String, String> params, OnNetCallback<JSONObject> callback){
        makeRequest(context, JsonObjectRequestImpl.class, url, params, callback);
    }

    /**
     * jsonArray 请求
     * @param context 相关上下文
     * @param url　网络访问url
     * @param params 网络请求参数
     * @param callback　网络请求回调
     */
    public void jsonArrayRequest(Context context, String url, Map<String, String> params, OnNetCallback<JSONArray> callback){
        makeRequest(context, JsonArrayRequestImpl.class, url, params, callback);
    }
}

ImageLoader.class类

public class ImageLoader {
    /** 最大的图片缓存大小 */
    private final int MAXDISKCACHEBYTES = 10 * 1024 *1024;
    private static volatile ImageLoader instance;
    private com.android.volley.toolbox.ImageLoader imageLoader;

    private ImageLoader(){
        RequestQueue requestQueue = Volley.newRequestQueue(RootApplication.getInstance(), MAXDISKCACHEBYTES);
        VolleyLruCache lruCache = new VolleyLruCache();
        imageLoader = new com.android.volley.toolbox.ImageLoader(requestQueue, lruCache);
    }

    public static ImageLoader getInstance(){
        if (instance == null){
            synchronized (ImageLoader.class){
                if (instance == null)
                    instance = new ImageLoader();
            }
        }
        return instance;
    }

    /** 通过反射获取imageview的大小 */
    private int getImageViewFieldValue(Object object, String fieldName) {
        int value = 0;
        try {
            Field field = ImageView.class.getDeclaredField(fieldName);
            field.setAccessible(true);
            int fieldValue = (Integer) field.get(object);
            if (fieldValue > 0 && fieldValue < Integer.MAX_VALUE) {
                value = fieldValue;
            }
        } catch (Exception e) {
            L.e(e);
        }
        return value;
    }

    /**
     * 加载图片
     * @param url 图片url
     * @param imageView 需要加载图片的视图
     */
    public void loadImage(String url, final ImageView imageView){
        loadImage(url, imageView, null);
    }

    /**
     * 只带回调的图片加载
     * @param url 图片url
     * @param listener 图片加载回调
     */
    public void loadImage(String url, final OnLoadCallBack listener){
        loadImage(url, 0, 0, listener);
    }

    /**
     * 带回调的加载图片
     * @param url 图片url
     * @param width 需要加载的图片宽
     * @param height 需要加载的图片高
     * @param listener 加载图片完成回调
     */
    public void loadImage(String url, int width, int height, final OnLoadCallBack listener){
        loadImage(url, null, width, height, listener);
    }

    /**
     * 带回调的加载图片
     * @param url 图片url
     * @param imageView 需要加载图片的视图
     * @param listener 加载图片的回调
     */
    public void loadImage(String url, final ImageView imageView, final OnLoadCallBack listener){
        int width = getImageViewFieldValue(imageView, "mMaxWidth");
        int height = getImageViewFieldValue(imageView, "mMaxHeight");

        loadImage(url, imageView, width, height, listener);
    }

    /**
     * 加载图片
     * @param url 图片url
     * @param imageView 需要加载图片的视图
     * @param width 需要加载视图的宽
     * @param height 需要加载视图的高
     * @param listener 加载图片回调
     */
    public void loadImage(String url, final ImageView imageView, int width, int height, final OnLoadCallBack listener){
        imageLoader.get(url, new com.android.volley.toolbox.ImageLoader.ImageListener() {
            @Override
            public void onResponse(com.android.volley.toolbox.ImageLoader.ImageContainer response, boolean isImmediate) {
                if (imageView != null)
                    imageView.setImageBitmap(response.getBitmap());
                if (listener != null)
                    listener.onLoadSuccess(response.getBitmap(), response.getRequestUrl());
            }

            @Override
            public void onErrorResponse(VolleyError error) {
                if (listener != null) {
                    NetError netError = new NetError();
                    netError.transferVolleyError(error);
                    listener.onLoadFail(netError);
                }
            }
        }, width, height);
    }

    /**
     * 加载图片
     * @param url 图片url
     * @param imageView 需要加载该图片的url
     * @param defaultImageResId 加载图片时的默认资源id
     * @param errorImageResId 加载图片失败时显示的图片资源id
     */
    public void loadImage(String url, final ImageView imageView, int defaultImageResId, int errorImageResId){
        int width = getImageViewFieldValue(imageView, "mMaxWidth");
        int height = getImageViewFieldValue(imageView, "mMaxHeight");

        loadImage(url, imageView, defaultImageResId, errorImageResId, width, height);
    }

    /**
     * 加载图片
     * @param url 图片url
     * @param imageView 需要加载该图片的url
     * @param defaultImageResId 加载图片时的默认资源id
     * @param errorImageResId 加载图片失败时显示的图片资源id
     * @param width 加载图片的宽度
     * @param height 加载图片的高度
     */
    public void loadImage(String url, final ImageView imageView, int defaultImageResId, int errorImageResId,
                          int width, int height){
        com.android.volley.toolbox.ImageLoader.ImageListener listener =
                com.android.volley.toolbox.ImageLoader.getImageListener(imageView,
                        defaultImageResId, errorImageResId);
        imageLoader.get(url, listener, width, height);
    }

    /**
     * 加载图片回调
     */
    public interface OnLoadCallBack {
        void onLoadSuccess(Bitmap bitmap, String url);
        void onLoadFail(NetError error);
    }
}

上面的两个类，就是最基本的网络访问和图片加载

基于此，还封装了基本的错误类，主要是用来将Volley的exception转换成通用的exception

NetError.class类

public class NetError extends Exception{
    public int errorCode;
    public String errorMessage;

    /**
     * 将volley的错误信息转换成通用的信息
     */
    public void transferVolleyError(VolleyError error){
        if (error.networkResponse != null)
            this.errorCode = error.networkResponse.statusCode;
        this.errorMessage = error.toString();
    }
}

上面就是列举的第二种封装方式，封装了最基本的功能。

以上就是我最基本的想法，写在这里来抛砖引玉，不知道这种思想是否正确

源码在我的github中，点我

希望大家多多评论