他们各有优劣,之前个人则比较喜欢用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();
- }
- }
- /**
- * 第三第四个参数分别用于指定允许图片最大的宽度和高度,如果指定的网络图片的宽度或高度大于这里的最大值,则会对图片进行压缩,
- * 指定成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);
- }
- // 添加及开始请求
- 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;
- }
- }
- 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");
其中蓝色部分代表主线程,绿色部分代表缓存线程,橙色部分代表网络线程。我们在主线程中调用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);
- }
- }
- }
接下来我们来看看,如何自定义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);
- }
- }
- // 共用失败回调
- private class StrErrListener implements ErrorListener {
- @Override
- public void onErrorResponse(VolleyError arg0) {
- Toast.makeText(mContext,
- VolleyErrorHelper.getMessage(arg0, mContext),
- Toast.LENGTH_LONG).show();
- }
- }
- 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>
下面主要是讲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;
- }
从这点我们可以学习到,要针对不同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();
- }
- }
他们各有优劣,之前个人则比较喜欢用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();
- }
- }
- /**
- * 第三第四个参数分别用于指定允许图片最大的宽度和高度,如果指定的网络图片的宽度或高度大于这里的最大值,则会对图片进行压缩,
- * 指定成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);
- }
- // 添加及开始请求
- 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;
- }
- }
- 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");
其中蓝色部分代表主线程,绿色部分代表缓存线程,橙色部分代表网络线程。我们在主线程中调用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);
- }
- }
- }
接下来我们来看看,如何自定义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);
- }
- }
- // 共用失败回调
- private class StrErrListener implements ErrorListener {
- @Override
- public void onErrorResponse(VolleyError arg0) {
- Toast.makeText(mContext,
- VolleyErrorHelper.getMessage(arg0, mContext),
- Toast.LENGTH_LONG).show();
- }
- }
- 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>
下面主要是讲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;
- }
从这点我们可以学习到,要针对不同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();
- }
- }
他们各有优劣,之前个人则比较喜欢用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();
- }
- }
- /**
- * 第三第四个参数分别用于指定允许图片最大的宽度和高度,如果指定的网络图片的宽度或高度大于这里的最大值,则会对图片进行压缩,
- * 指定成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);
- }
- // 添加及开始请求
- 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;
- }
- }
- 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");
其中蓝色部分代表主线程,绿色部分代表缓存线程,橙色部分代表网络线程。我们在主线程中调用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);
- }
- }
- }
接下来我们来看看,如何自定义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);
- }
- }
- // 共用失败回调
- private class StrErrListener implements ErrorListener {
- @Override
- public void onErrorResponse(VolleyError arg0) {
- Toast.makeText(mContext,
- VolleyErrorHelper.getMessage(arg0, mContext),
- Toast.LENGTH_LONG).show();
- }
- }
- 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>
下面主要是讲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;
- }
从这点我们可以学习到,要针对不同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();
- }
- }