Android网络框架Volley

Volley 是Google I/O 2013推出的网络通讯库，在volley推出以前咱们通常会选择比较成熟的第三方网络通讯库，如：

• android-async-http

• retrofit

• okhttp

他们各有优劣，以前我的则比较喜欢用android-async-http, 现在Google推出了官方的针对Android平台上的网络通讯库，能使网络通讯更快，更简单，更健壮，Volley在提供了高性能网络通信功能的同时，对网络图片加载也提供了良好的支持，彻底能够知足简单REST客户端的需求, 咱们没有理由不跟上时代的潮流

 

使用Volley

 

下载Volley源码并build jar包。

$ git clone https://android.googlesource.com/platform/frameworks/volley
$ cd volley
$ android update project -p
$ ant jar

而后把生成的jar包引用到咱们的项目中，extras目录下则包含了目前最新的volley源码。

说明

此Demo主要介绍了平常网络开发经常使用的基本功能，但volley的扩展性很强，能够根据须要定制你本身的网络请求。

volley视频地址： http://www.youtube.com/watch?v=yhv8l9F44qo&feature=player_embedded

以上是在Google IO的演讲上ppt的配图，从上面这张图咱们能够看出，volley适合快速，简单的请求（Json对象，图片加载）。

volley的特性：

 

• JSON，图像等的异步下载；
• 网络请求的排序（scheduling）
• 网络请求的优先级处理
• 缓存
• 多级别取消请求
• 和Activity和生命周期的联动（Activity结束时同时取消全部网络请求）

 

接下来，咱们来学习简单的使用下volley给我提供的API吧。

1.首先拿到一个请求队列（RequestQueue只须要一个实例便可，不像AsyncTask每次使用都要new一个）

 

// 初始化RequestQueue一个activity只须要一个
    private void initRequestQueue() {
        mQueue = Volley.newRequestQueue(getApplicationContext());
    }

2.实现volley的异步请求类（JsonObjectRequest,JsonArrayRequest,StringRequest,ImageRequest）

 

因为用法都相差不大，我就不一一举例了，举几个经常使用有表明性的例子：

如下代码是StringRequest的get请求：

// get请求

private void loadGetStr(String url) {

    StringRequest srReq = new StringRequest(Request.Method.GET, url,
            new StrListener(), new StrErrListener()) {

        protected final String TYPE_UTF8_CHARSET = "charset=UTF-8";

        // 重写parseNetworkResponse方法改变返回头参数解决乱码问题
        // 主要是看服务器编码，若是服务器编码不是UTF-8的话那么就须要本身转换，反之则不须要
        @Override
        protected Response<String> parseNetworkResponse(
                NetworkResponse response) {
            try {
                String type = response.headers.get(HTTP.CONTENT_TYPE);
                if (type == null) {
                    type = TYPE_UTF8_CHARSET;
                    response.headers.put(HTTP.CONTENT_TYPE, type);
                } else if (!type.contains("UTF-8")) {
                    type += ";" + TYPE_UTF8_CHARSET;
                    response.headers.put(HTTP.CONTENT_TYPE, type);
                }
            } catch (Exception e) {
            }
            return super.parseNetworkResponse(response);
        }
    };
    srReq.setShouldCache(true); // 控制是否缓存
    startVolley(srReq);
}

如下代码是JsonObjectRequest的post请求：

// post请求
private void loadPostJson(String url) {
    // 第二个参数说明:
    // Constructor which defaults to GET if jsonRequest is null, POST
    // otherwise.
    // 默认状况下设成null为get方法,不然为post方法。
    JsonObjectRequest srReq = new JsonObjectRequest(url, null,
            new JsonListener(), new StrErrListener()) {

        @Override
        protected Map<String, String> getParams() throws AuthFailureError {
            Map<String, String> map = new HashMap<String, String>();
            map.put("w", "2459115");
            map.put("u", "f");
            return map;
        }
    };
    srReq.setShouldCache(false); // 控制是否缓存
    startVolley(srReq);
}

你们注意看的话，不管是JsonObjectReques的postt仍是StringRequest的get都须要传入两个监听函数一个是成功一个是失败，成功监听他们会返回相应类型的数据：

 

// Str请求成功回调
private class StrListener implements Listener<String> {

    @Override
    public void onResponse(String arg0) {
        Log.e(Tag, arg0);

    }

}

// Gson请求成功回调
private class GsonListener implements Listener<ErrorRsp> {

    @Override
    public void onResponse(ErrorRsp arg0) {
        Toast.makeText(mContext, arg0.toString(), Toast.LENGTH_LONG).show();
    }

}
// 共用失败回调
private class StrErrListener implements ErrorListener {

    @Override
    public void onErrorResponse(VolleyError arg0) {
        Toast.makeText(mContext,
                VolleyErrorHelper.getMessage(arg0, mContext),
                Toast.LENGTH_LONG).show();
    }

}

接下来是ImageRequest

/**
 * 第三第四个参数分别用于指定容许图片最大的宽度和高度，若是指定的网络图片的宽度或高度大于这里的最大值，则会对图片进行压缩，
 * 指定成0的话就表示无论图片有多大，都不会进行压缩。
 *
 * @param url
 *            图片地址
 * @param listener
 * @param maxWidth
 *            指定容许图片最大的宽度
 * @param maxHeight
 *            指定容许图片最大的高度
 * @param decodeConfig
 *            指定图片的颜色属性，Bitmap.Config下的几个常量.
 * @param errorListener
 */
private void getImageRequest(final ImageView iv, String url) {
    ImageRequest imReq = new ImageRequest(url, new Listener<Bitmap>() {

        @Override
        public void onResponse(Bitmap arg0) {
            iv.setImageBitmap(arg0);
        }
    }, 60, 60, Bitmap.Config.ARGB_8888, new StrErrListener());
    startVolley(imReq);
}

看到如今你们确定会疑惑写了这么多不一样类型的Request到底如何运行？接下请看：

 

 

// 添加及开始请求
private void startVolley(Request req) {

    // 设置超时时间
    // req.setRetryPolicy(new DefaultRetryPolicy(20 * 1000, 1, 1.0f));
    // 将请求加入队列
    mQueue.add(req);
    // 开始发起请求
    mQueue.start();
}

volley不只提供了这些请求的方式，还提供了加载图片的一些方法和控件：

好比咱们一个列表须要加载不少图片咱们可使用volley给咱们提供的ImageLoader（ ImageLoader比ImageRequest更加高效，由于它不只对图片进行缓存，还能够过滤掉重复的连接，避免重复发送请求。）

 

public class ImageAdapter extends ArrayAdapter<String> {

    private RequestQueue mQueue;
    private ImageLoader mImageLoader;

    public ImageAdapter(Context context, List<String> objects) {
        super(context, 0, objects);
        mQueue = Volley.newRequestQueue(getContext());
        mImageLoader = new ImageLoader(mQueue, new BitmapCache());
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        String url = getItem(position);
        ImageView imageView;
        if (convertView == null) {
            imageView = new ImageView(getContext());
        } else {
            imageView = (ImageView) convertView;
        }
        // getImageListener（imageView控件对象，默认图片地址，失败图片地址）;
        ImageListener listener = ImageLoader.getImageListener(imageView, android.R.drawable.ic_menu_rotate, android.R.drawable.ic_delete);
        // get(图片地址，listener，宽，高)；自动帮你处理图片的宽高不再怕大图片的oom了
        mImageLoader.get(url, listener,100,200);
        return imageView;
    }

}

固然还须要重写ImageCache这个类 //使用LruCache不再用怕加载多张图片oom了

 

 

public class <span style="font-family: Arial;">BitmapCache</span><span style="font-family: Arial;"> extends LruCache<String, Bitmap> implements ImageCache {</span>
    // LruCache 原理：Cache保存一个强引用来限制内容数量，每当Item被访问的时候，此Item就会移动到队列的头部。 当cache已满的时候加入新的item时，在队列尾部的item会被回收。
    // 解释：当超出指定内存值则移除最近最少用的图片内存
    public static int getDefaultLruCacheSize() {
        // 拿到最大内存
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        // 拿到内存的八分之一来作图片内存缓存
        final int cacheSize = maxMemory / 8;

        return cacheSize;
    }

    public BitmapLruCache() {
        this(getDefaultLruCacheSize());
    }

    public BitmapLruCache(int sizeInKiloBytes) {
        super(sizeInKiloBytes);
    }

    @Override
    protected int sizeOf(String key, Bitmap value) {
        return value.getRowBytes() * value.getHeight() / 1024;
    }

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

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

Volley还提供的加载图片的控件com.android.volley.NetworkImageView。（这个控件在被从父控件detach的时候，会自动取消网络请求的，即彻底不用咱们担忧相关网络请求的生命周期问题，并且NetworkImageView还会根据你对图片设置的width和heigh自动压缩该图片不会产生多的内存，还有NetworkImageView在列表中使用不会图片错误）

 

 

<com.android.volley.toolbox.NetworkImageView
    android:id="@+id/network_image_view"
    android:layout_width="100dp"
    android:layout_height="100dp" />

使用方法：

 

 

private void networkImageViewUse(NetworkImageView iv, String url) {
        ImageLoader imLoader = new ImageLoader(mQueue, new BitmapLruCache());
        iv.setDefaultImageResId(R.drawable.ic_launcher);
        iv.setErrorImageResId(R.drawable.ic_launcher);
        iv.setImageUrl(url, imLoader);
    }

咱们说了这么多都是请求，那么如何取消请求呢？

 

1.activity自动销毁时它会自定取消全部请求。

2.给请求设置标签：

 

request.setTag("My Tag");

 

取消全部指定标记的请求：

 

request.cancelAll("My Tag");

Volley的架构设计：

 

其中蓝色部分表明主线程，绿色部分表明缓存线程，橙色部分表明网络线程。咱们在主线程中调用RequestQueue的add()方法来添加一条网络请求，这条请求会先被加入到缓存队列当中，若是发现能够找到相应的缓存结果就直接读取缓存并解析，而后回调给主线程。若是在缓存中没有找到结果，则将这条请求加入到网络请求队列中，而后处理发送HTTP请求，解析响应结果，写入缓存，并回调主线程。

 

 

接下来咱们要看看如何把volley使用到实战项目里面，咱们先考虑下一些问题：

从上一篇来看 mQueue 只须要一个对象便可，new RequestQueue对象对资源一种浪费，咱们应该在application，以及能够把取消请求的方法也在application进行统一管理，看如下代码：

 

package com.chronocloud.lib.base;

import android.app.Application;
import android.text.TextUtils;

import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.VolleyLog;
import com.android.volley.toolbox.Volley;

public class ApplicationController extends Application {

    /**
     * Log or request TAG
     */
    public static final String TAG = "VolleyPatterns";

    /**
     * Global request queue for Volley
     */
    private RequestQueue mRequestQueue;

    /**
     * A singleton instance of the application class for easy access in other
     * places
     */
    private static ApplicationController sInstance;

    @Override
    public void onCreate() {
        super.onCreate();

        // initialize the singleton
        sInstance = this;
    }

    /**
     * @return ApplicationController singleton instance
     */
    public static synchronized ApplicationController getInstance() {
        return sInstance;
    }

    /**
     * @return The Volley Request queue, the queue will be created if it is null
     */
    public RequestQueue getRequestQueue() {
        // lazy initialize the request queue, the queue instance will be
        // created when it is accessed for the first time
        if (mRequestQueue == null) {
            // 1
            // 2
            synchronized (ApplicationController.class) {
                if (mRequestQueue == null) {
                    mRequestQueue = Volley
                            .newRequestQueue(getApplicationContext());
                }
            }
        }
        return mRequestQueue;
    }

    /**
     * Adds the specified request to the global queue, if tag is specified then
     * it is used else Default TAG is used.
     *
     * @param req
     * @param tag
     */
    public <T> void addToRequestQueue(Request<T> req, String tag) {
        // set the default tag if tag is empty
        req.setTag(TextUtils.isEmpty(tag) ? TAG : tag);

        VolleyLog.d("Adding request to queue: %s", req.getUrl());

        getRequestQueue().add(req);
    }

    /**
     * Adds the specified request to the global queue using the Default TAG.
     *
     * @param req
     * @param tag
     */
    public <T> void addToRequestQueue(Request<T> req) {
        // set the default tag if tag is empty
        req.setTag(TAG);

        getRequestQueue().add(req);
    }

    /**
     * Cancels all pending requests by the specified TAG, it is important to
     * specify a TAG so that the pending/ongoing requests can be cancelled.
     *
     * @param tag
     */
    public void cancelPendingRequests(Object tag) {
        if (mRequestQueue != null) {
            mRequestQueue.cancelAll(tag);
        }
    }
}

接下来就是Volley虽然给咱们提供了不少不一样的Request（JsonObjectRequest,JsonArrayRequest,StringRequest,ImageRequest），可是仍是知足不了咱们实战中的需求，咱们实战开发中常常用到的是xml格式，Gson解析。

 

接下来咱们来看看，如何自定义Request

XmlRequest：

 

public class XMLRequest extends Request<XmlPullParser> {

    private final Listener<XmlPullParser> mListener;

    public XMLRequest(int method, String url, Listener<XmlPullParser> listener,
            ErrorListener errorListener) {
        super(method, url, errorListener);
        mListener = listener;
    }

    public XMLRequest(String url, Listener<XmlPullParser> listener, ErrorListener errorListener) {
        this(Method.GET, url, listener, errorListener);
    }

    @Override
    protected Response<XmlPullParser> parseNetworkResponse(NetworkResponse response) {
        try {
            String xmlString = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers));
            XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
            XmlPullParser xmlPullParser = factory.newPullParser();
            xmlPullParser.setInput(new StringReader(xmlString));
            return Response.success(xmlPullParser, HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        } catch (XmlPullParserException e) {
            return Response.error(new ParseError(e));
        }
    }

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

}

GsonRequest（注意须要自行导入gson.jar）：

 

 

public class GsonRequest<T> extends Request<T> {

    private final Listener<T> mListener;

    private Gson mGson;

    private Class<T> mClass;

    public GsonRequest(int method, String url, Class<T> clazz, Listener<T> listener,
            ErrorListener errorListener) {
        super(method, url, errorListener);
        mGson = new Gson();
        mClass = clazz;
        mListener = listener;
    }

    public GsonRequest(String url, Class<T> clazz, Listener<T> listener,
            ErrorListener errorListener) {
        this(Method.GET, url, clazz, listener, errorListener);
    }

    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse response) {
        try {
            String jsonString = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers));
            return Response.success(mGson.fromJson(jsonString, mClass),
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        }
    }

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

}

接下只差最后一步了就是封装它的错误处理，使用过volley的都知道，volley的监听错误提示都是NoConnectionError。。。等等，这类的错误提示，显然这不是咱们想给用户呈现的错误提示，由于就算提示了用户也不明白什么意思，因此咱们还要封装一下，能让用户看的更清楚的理解这些错误提示。 ym—— Android网络框架Volley(体验篇)咱们讲过每一个请求都须要设置一个失败的监听：

 

 

// 共用失败回调
private class StrErrListener implements ErrorListener {

    @Override
    public void onErrorResponse(VolleyError arg0) {
        Toast.makeText(mContext,
                VolleyErrorHelper.getMessage(arg0, mContext),
                Toast.LENGTH_LONG).show();
    }

}

以上代码有个VolleyError对象，咱们能够从这个对象上下手：

 

 

package com.example.volley;

import java.util.HashMap;
import java.util.Map;

import android.content.Context;

import com.android.volley.AuthFailureError;
import com.android.volley.NetworkError;
import com.android.volley.NetworkResponse;
import com.android.volley.NoConnectionError;
import com.android.volley.ServerError;
import com.android.volley.TimeoutError;
import com.android.volley.VolleyError;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
//正如前面代码看到的，在建立一个请求时，须要添加一个错误监听onErrorResponse。若是请求发生异常，会返回一个VolleyError实例。
//如下是Volley的异常列表：
//AuthFailureError：若是在作一个HTTP的身份验证，可能会发生这个错误。
//NetworkError：Socket关闭，服务器宕机，DNS错误都会产生这个错误。
//NoConnectionError：和NetworkError相似，这个是客户端没有网络链接。
//ParseError：在使用JsonObjectRequest或JsonArrayRequest时，若是接收到的JSON是畸形，会产生异常。
//SERVERERROR：服务器的响应的一个错误，最有可能的4xx或5xx HTTP状态代码。
//TimeoutError：Socket超时，服务器太忙或网络延迟会产生这个异常。默认状况下，Volley的超时时间为2.5秒。若是获得这个错误可使用RetryPolicy。

public class VolleyErrorHelper {

    /**
     * Returns appropriate message which is to be displayed to the user against
     * the specified error object.
     *
     * @param error
     * @param context
     * @return
     */
    public static String getMessage(Object error, Context context) {
        if (error instanceof TimeoutError) {
            return context.getResources().getString(
                    R.string.generic_server_down);
        } else if (isServerProblem(error)) {
            return handleServerError(error, context);
        } else if (isNetworkProblem(error)) {
            return context.getResources().getString(R.string.no_internet);
        }
        return context.getResources().getString(R.string.generic_error);
    }

    /**
     * Determines whether the error is related to network
     *
     * @param error
     * @return
     */
    private static boolean isNetworkProblem(Object error) {
        return (error instanceof NetworkError)
                || (error instanceof NoConnectionError);
    }

    /**
     * Determines whether the error is related to server
     *
     * @param error
     * @return
     */
    private static boolean isServerProblem(Object error) {
        return (error instanceof ServerError)
                || (error instanceof AuthFailureError);
    }

    /**
     * Handles the server error, tries to determine whether to show a stock
     * message or to show a message retrieved from the server.
     *
     * @param err
     * @param context
     * @return
     */
    private static String handleServerError(Object err, Context context) {
        VolleyError error = (VolleyError) err;

        NetworkResponse response = error.networkResponse;

        if (response != null) {
            switch (response.statusCode) {
            case 404:
            case 422:
            case 401:
                try {
                    // server might return error like this { "error":
                    // "Some error occured" }
                    // Use "Gson" to parse the result
                    HashMap<String, String> result = new Gson().fromJson(
                            new String(response.data),
                            new TypeToken<Map<String, String>>() {
                            }.getType());

                    if (result != null && result.containsKey("error")) {
                        return result.get("error");
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
                // invalid request
                return error.getMessage();

            default:
                return context.getResources().getString(
                        R.string.generic_server_down);
            }
        }
        return context.getResources().getString(R.string.generic_error);
    }
}

以上代码中引用的xml是：

 

 

<string name="no_internet">无网络链接~！</string>
<string name="generic_server_down">链接服务器失败~！</string>
<string name="generic_error">网络异常,请稍后再试~！</string>

接下来，数据请求这一块已经说完了，咱们来讲下图片这一块，我我的喜欢使用universal-image-loader而不是volley本身提供的（我的认为使用起来universal-image-loader更便捷一些）。

 

 

下面主要是讲Volley在某些细节方面的选择和实现.值得咱们学习的地方以及若是更好的使用Volley。

 

1.Volley本地缓存为何有时候不会进行缓存？

缓存使用前提服务器必须支持，缓存，配置Cache-Control头信息，

由于Volley须要从这些头信息判断缓存是否已通过期。若是已通过期Volley将会从新从网络获取数据。

本人用抓包工具抓了没法缓存的返回头信息

能够支持缓存的头信息

 

2.若是咱们本身写一个网络请求框架，咱们内部实现会选择使用HttpURLConnection仍是HttpClient？

咱们经过源码来看看Volley是如何选择使用的

  

public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
    File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);
    String userAgent = "volley/0";
    try {
        String packageName = context.getPackageName();
        PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
        userAgent = packageName + "/" + info.versionCode;
    } catch (NameNotFoundException e) {
    }
    if (stack == null) {
        if (Build.VERSION.SDK_INT >= 9) {
            stack = new HurlStack();
        } else {
            stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
        }
    }
    Network network = new BasicNetwork(stack);
    RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
    queue.start();
    return queue;
}

这里会判断若是手机系统版本号是大于9（Android 2.3）的，则建立一个HurlStack的实例，不然就建立一个HttpClientStack的实例。实际上HurlStack的内部就是使用HttpURLConnection进行网络通信的，而HttpClientStack的内部则是使用HttpClient进行网络通信的，这里为何这样选择呢？参考文章： Android访问网络，使用HttpURLConnection仍是HttpClient？这就是它为什么这么快的缘由。

 

从这点咱们能够学习到，要针对不一样SDK版本作去相应更优的处理方式，这样才能达到最好的效果。

 

 3.Volley给咱们提供了ImageRrequest，ImageLoader，NetworkImageView，它们分别使用于什么场景为何？

单张图片的加载能够经过发起 ImageReuqst 请求来实现，但为了应用内存缓存，推荐使用 ImageLoader 

NetwoekImageView专门用于批量图片加载的场景：

 

public class NetworkImageView extends ImageView {
    private String mUrl;

    // 默认显示的图片
    private int mDefaultImageId;

    // 加载失败时显示的图片
    private int mErrorImageId;

    // 主方法入口
    public void setImageUrl(String url, ImageLoader imageLoader) {
        mUrl = url;
        mImageLoader = imageLoader;
        // 这个方法将会对ImageView的尺寸是否有效、是否为同一张图片进行判断
        // 在执行新请求前，也会取消上一次在这个View里启动的另外一个已经失效的请求
        // 因为篇幅的限制以及代码行数太多，这里不贴出具体实现的代码
        loadImageIfNecessary(false);
    }

    // 若是图片已经滑离屏幕，变为不可见，将执行取消请求的操做
    @Override
    protected void onDetachedFromWindow() {
        if (mImageContainer != null) mImageContainer.cancelRequest();
        super.onDetachedFromWindow();
    }
}

在ListView加载多张图片的时候，NetworkImageView能够防止出现图片错误的现象，以及当NetworkImageView滑出屏幕的时候会取消加载图片请求，这样就保证加载多张图片的时候用户快速滑动列表的流畅性。给用户带来更优的体验。

 

• 上一篇Android仿QQ5.0侧滑菜单ResideMenu源码分析
• 下一篇Android开发--WIFI输入密码Dialog的实现