Volley的简单封装

算了一下，好像有很久没有写博客了。其实，关于写博客这件事，我从来没有把他当成我的一种任务，而是在学习过程中的一种总结和自我发现，同样也是为了练一练文笔，说不定有一天，我也能出一本书像《第一行代码》，《安卓从小工到专家》，《App研发录》等等这样的书。人生短短数十载，总要留下些什么。好像说的有点多，话不多说。来谈谈今天的主要内容。我总在一些交流群中看到有人说，那个XXX二次封装的OkHttp如何怎样怎样。其实，当我看到他这样说的时候我在想，为什么不自己进行二次封装同样更加满足自己的需求呢？也许你会觉得这东西很难，人家有现成的东西为什么不用呢？我觉得，前提是你要理解了才能拿来用。话不多说，拿一个我自己做的Demo给大家看一看。

这个小东西，我所使用的是Volley，并且实现了对Volley的简单二次封装。这里写出来，希望对你有所启发。

数据方面，由于调用的是聚合上的免费API,返回的数据是Json。在安卓中处理Json，其实首选是想Gson,fastJson，这样的框架。因为我Gson用的比较多，并且关于写JavaBean对象，Android Studio 也有jsonformat这样的小插件可以快速实现，省去了很多时间。

***Volley整合Gson**

好在Volley提供了一个Request类帮助我们实现自定义的Request。所以实现起来并不复杂。我们希望，从我们自定义的Requet中能够直接返回我们的JavaBean对象，便于我们对数据的操作。实现代码：

public class ApiJsonRequest<T>extends Request<T>{
    private Class<T> clazz;
    private Response.Listener<T> mListener;
    private Gson gson;
    private int position;

    public ApiJsonRequest(int method, String url, Response.ErrorListener errorListener,
                          Response.Listener<T> listener, Class<T> clazz) {
        super(method, url, errorListener);
        this.mListener=listener;
        this.clazz=clazz;
    }

    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse response) {
        String json;
        try {
            json=new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        } catch (UnsupportedEncodingException e) {
            json=new String(response.data);
        }
        T obj;
        try {
            if (gson==null) {
                gson = new Gson();
            }
            obj=gson.fromJson(json,clazz);
            return Response.success(obj,HttpHeaderParser.parseCacheHeaders(response));
        }catch (Exception e) {
            return Response.error(new ParseError());
        }

    }

    @Override
    protected void deliverResponse(T response) {
        mListener.onResponse(response);
    }
}

可以看到，这里主要有三个方法需要我们去实现。构造方法中，我们传入一个请求成功的监听。由于我们需要返回JavaBean对象，但是却不知道这个JavaBean对象具体指向谁，所以这里可以传入一个泛型T,在实现这个Request的时候就指定JavaBean对象用于Gson解析。之后再parseNetworkResponse中通过NetworkResponse拿到调用String类的构造方法，将二进制字节组转换为一个Java字符串，用于我们的Gson解析，为了防止Gson对象在数据请求的时候被重复调用，要在初始化时进行判空。最后调用Json.fromJson将这个对象Response出去;deliverResponse这个方法主要用于决定我们返回的数据对象。下面是使用：

private void getData() {
        ApiJsonRequest<NewsParseBean> apiJsonRequest = new ApiJsonRequest<>(Request.Method.GET,
                NewsBean.requestUrl + type + NewsBean.apiKey, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {

            }
        }, new Response.Listener<NewsParseBean>() {
            @Override
            public void onResponse(NewsParseBean response) {
                //获取最新数据
                processData(response);
                //显示新闻
                showNews();

            }
        }, NewsParseBean.class,position);
        apiJsonRequest.setTag(getClass().getSimpleName());
        requestQueue.add(apiJsonRequest);
    }

一个简单的整合Gson的Volley就写完了。是不是很简单？

***整合LruCache***

上图那个小Demo，运行起来是十分的流畅。在图片加载方面，我所使用的是Android中的LruCache。一种内存缓存策略，你能看到，其实加载速度是非常的快，非常的流畅的。附上代码：

public class ApiImageCache implements ImageLoader.ImageCache {
    private LruCache<String,Bitmap>lruCache;
    private static int maxSize= ApiConstant.IMAGE_SIZE;
    private static ApiImageCache instance;
    private ApiImageCache() {
        lruCache=new LruCache<String, Bitmap>(maxSize){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getByteCount()/1024/1024;
            }
        };
    }
    public static synchronized ApiImageCache getInstance () {
        if (instance==null) {
            instance=new ApiImageCache(){};
        }
        return instance;
    }
    @Override
    public Bitmap getBitmap(String url) {
        return lruCache.get(url);
    }

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

    }
}

在实现Volley加载图片的时候需要我们对图片进行自定义的处理，这里实现ImageLoader.ImageCache就可以了。之后，我为了方便，将它写成单例。在构造方法中使用LruCache进行图片加载处理。实现很简单，需要注意的是LruCache返回的是图片的大小。

Volley:

public class ApiVolleyUtils {
    private static ApiVolleyUtils instance;
    private static RequestQueue requestQueue;
    private static ImageLoader imageLoader;
    private static ImageLoader.ImageCache imageCache;

    public RequestQueue getRequestQueue() {
        return requestQueue;
    }

    public ImageLoader getImageLoader() {
        return imageLoader;
    }

    public ImageLoader.ImageCache getImageCache() {
        return imageCache;
    }

    private ApiVolleyUtils(Context context){
        requestQueue= Volley.newRequestQueue(context);
        imageCache=ApiImageCache.getInstance();
        imageLoader=new ImageLoader(requestQueue,imageCache);

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

}

使用：

ImageLoader imageLoader = apiVolleyUtils.getImageLoader();
            if (!NetUtils.isNetWork(UIUtils.getContext())) {
                // getDiskImage(holder, diskLruCache, key);
            } else {
                //getNetDisk(position, diskLruCache, key);
                imageLoader.get(respondList.get(position).getThumbnail_pic_s(),
                        new ImageLoader.ImageListener() {
                            @Override
                            public void onResponse(ImageLoader.ImageContainer response, boolean isImmediate) {
                                holder.ivNews.setImageBitmap(response.getBitmap());
                            }
                            @Override
                            public void onErrorResponse(VolleyError error) {

                            }
                        });

好了，关于这个小Demo中的Volley网络模块接介绍完了，关于这些框架，我们不仅需要学习如何使用跟重要的是，要学会如何对框架进行二次封装，满足自己的实际需要。希望这篇博客对你有所启发。