转载-ym—— Android网络框架Volley(体验篇)

目录(?)[-]

1. 使用Volley
2. 说明

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一个）

[java]  view plain copy print ?

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

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

由于用法都相差不大，我就不一一举例了，举几个常用有代表性的例子：

以下代码是StringRequest的get请求：

[java]  view plain copy print ?

1. // get请求  

[java]  view plain copy print ?

1. private void loadGetStr(String url) {  
2.   
3.     StringRequest srReq = new StringRequest(Request.Method.GET, url,  
4.             new StrListener(), new StrErrListener()) {  
5.   
6.         protected final String TYPE_UTF8_CHARSET = "charset=UTF-8";  
7.   
8.         // 重写parseNetworkResponse方法改变返回头参数解决乱码问题  
9.         // 主要是看服务器编码，如果服务器编码不是UTF-8的话那么就需要自己转换，反之则不需要  
10.         @Override  
11.         protected Response<String> parseNetworkResponse(  
12.                 NetworkResponse response) {  
13.             try {  
14.                 String type = response.headers.get(HTTP.CONTENT_TYPE);  
15.                 if (type == null) {  
16.                     type = TYPE_UTF8_CHARSET;  
17.                     response.headers.put(HTTP.CONTENT_TYPE, type);  
18.                 } else if (!type.contains("UTF-8")) {  
19.                     type += ";" + TYPE_UTF8_CHARSET;  
20.                     response.headers.put(HTTP.CONTENT_TYPE, type);  
21.                 }  
22.             } catch (Exception e) {  
23.             }  
24.             return super.parseNetworkResponse(response);  
25.         }  
26.     };  
27.     srReq.setShouldCache(true); // 控制是否缓存  
28.     startVolley(srReq);  
29. }  

以下代码是 JsonObjectRequest的post 请求：

[java]  view plain copy print ?

1. // post请求  
2. private void loadPostJson(String url) {  
3.     // 第二个参数说明:  
4.     // Constructor which defaults to GET if jsonRequest is null, POST  
5.     // otherwise.  
6.     // 默认情况下设成null为get方法,否则为post方法。  
7.     JsonObjectRequest srReq = new JsonObjectRequest(url, null,  
8.             new JsonListener(), new StrErrListener()) {  
9.   
10.         @Override  
11.         protected Map<String, String> getParams() throws AuthFailureError {  
12.             Map<String, String> map = new HashMap<String, String>();  
13.             map.put("w", "2459115");  
14.             map.put("u", "f");  
15.             return map;  
16.         }  
17.     };  
18.     srReq.setShouldCache(false); // 控制是否缓存  
19.     startVolley(srReq);  
20. }  

大家注意看的话，无论是 JsonObjectReques的postt还是StringRequest的get都需要传入两个监听函数一个是成功一个是失败，成功监听他们会返回相应类型的数据：

[java]  view plain copy print ?

1. // Str请求成功回调  
2. private class StrListener implements Listener<String> {  
3.   
4.     @Override  
5.     public void onResponse(String arg0) {  
6.         Log.e(Tag, arg0);  
7.   
8.     }  
9.   
10. }  
11.   
12. // Gson请求成功回调  
13. private class GsonListener implements Listener<ErrorRsp> {  
14.   
15.     @Override  
16.     public void onResponse(ErrorRsp arg0) {  
17.         Toast.makeText(mContext, arg0.toString(), Toast.LENGTH_LONG).show();  
18.     }  
19.   
20. }  
21. // 共用失败回调  
22. private class StrErrListener implements ErrorListener {  
23.   
24.     @Override  
25.     public void onErrorResponse(VolleyError arg0) {  
26.         Toast.makeText(mContext,  
27.                 VolleyErrorHelper.getMessage(arg0, mContext),  
28.                 Toast.LENGTH_LONG).show();  
29.     }  
30.   
31. }  

接下来是 ImageRequest

[java]  view plain copy print ?

1. /** 
2.  * 第三第四个参数分别用于指定允许图片最大的宽度和高度，如果指定的网络图片的宽度或高度大于这里的最大值，则会对图片进行压缩， 
3.  * 指定成0的话就表示不管图片有多大，都不会进行压缩。 
4.  *  
5.  * @param url 
6.  *            图片地址 
7.  * @param listener 
8.  * @param maxWidth 
9.  *            指定允许图片最大的宽度 
10.  * @param maxHeight 
11.  *            指定允许图片最大的高度 
12.  * @param decodeConfig 
13.  *            指定图片的颜色属性，Bitmap.Config下的几个常量. 
14.  * @param errorListener 
15.  */  
16. private void getImageRequest(final ImageView iv, String url) {  
17.     ImageRequest imReq = new ImageRequest(url, new Listener<Bitmap>() {  
18.   
19.         @Override  
20.         public void onResponse(Bitmap arg0) {  
21.             iv.setImageBitmap(arg0);  
22.         }  
23.     }, 60, 60, Bitmap.Config.ARGB_8888, new StrErrListener());  
24.     startVolley(imReq);  
25. }  

看到现在大家肯定会疑惑写了这么多不同类型的Request到底如何运行？接下请看：

[java]  view plain copy print ?

1. // 添加及开始请求  
2. private void startVolley(Request req) {  
3.   
4.     // 设置超时时间  
5.     // req.setRetryPolicy(new DefaultRetryPolicy(20 * 1000, 1, 1.0f));  
6.     // 将请求加入队列  
7.     mQueue.add(req);  
8.     // 开始发起请求  
9.     mQueue.start();  
10. }  

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

比如我们一个列表需要加载很多图片我们可以使用volley给我们提供的ImageLoader（ ImageLoader比ImageRequest更加高效，因为它不仅对图片进行缓存，还可以过滤掉重复的链接，避免重复发送请求。）

[java]  view plain copy print ?

1. public class ImageAdapter extends ArrayAdapter<String> {  
2.       
3.     private RequestQueue mQueue;  
4.     private ImageLoader mImageLoader;  
5.   
6.     public ImageAdapter(Context context, List<String> objects) {  
7.         super(context, 0, objects);  
8.         mQueue = Volley.newRequestQueue(getContext());  
9.         mImageLoader = new ImageLoader(mQueue, new BitmapCache());  
10.     }  
11.       
12.     @Override  
13.     public View getView(int position, View convertView, ViewGroup parent) {  
14.         String url = getItem(position);  
15.         ImageView imageView;  
16.         if (convertView == null) {  
17.             imageView = new ImageView(getContext());  
18.         } else {  
19.             imageView = (ImageView) convertView;  
20.         }  
21.         // getImageListener（imageView控件对象，默认图片地址，失败图片地址）;  
22.         ImageListener listener = ImageLoader.getImageListener(imageView, android.R.drawable.ic_menu_rotate, android.R.drawable.ic_delete);  
23.         // get(图片地址，listener，宽，高)；自动帮你处理图片的宽高再也不怕大图片的oom了  
24.         mImageLoader.get(url, listener,100,200);  
25.         return imageView;  
26.     }  
27.   
28. }  

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

[java]  view plain copy print ?

1. public class <span style="font-family: Arial;">BitmapCache</span><span style="font-family: Arial;"> extends LruCache<String, Bitmap> implements ImageCache {</span>  
2.     // LruCache 原理：Cache保存一个强引用来限制内容数量，每当Item被访问的时候，此Item就会移动到队列的头部。 当cache已满的时候加入新的item时，在队列尾部的item会被回收。  
3.     // 解释：当超出指定内存值则移除最近最少用的图片内存  
4.     public static int getDefaultLruCacheSize() {  
5.         // 拿到最大内存  
6.         final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);  
7.         // 拿到内存的八分之一来做图片内存缓存  
8.         final int cacheSize = maxMemory / 8;  
9.   
10.         return cacheSize;  
11.     }  
12.   
13.     public BitmapLruCache() {  
14.         this(getDefaultLruCacheSize());  
15.     }  
16.   
17.     public BitmapLruCache(int sizeInKiloBytes) {  
18.         super(sizeInKiloBytes);  
19.     }  
20.   
21.     @Override  
22.     protected int sizeOf(String key, Bitmap value) {  
23.         return value.getRowBytes() * value.getHeight() / 1024;  
24.     }  
25.   
26.     @Override  
27.     public Bitmap getBitmap(String url) {  
28.         return get(url);  
29.     }  
30.   
31.     @Override  
32.     public void putBitmap(String url, Bitmap bitmap) {  
33.         put(url, bitmap);  
34.     }  
35. }  

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

[html]  view plain copy print ?

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

使用方法：

[java]  view plain copy print ?

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

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

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

2.给请求设置标签：

[java]  view plain copy print ?

1. request.setTag("My Tag");    

取消所有指定标记的请求：

[java]  view plain copy print ?

1. request.cancelAll("My Tag");    

Volley的架构设计：

其中蓝色部分代表主线程，绿色部分代表缓存线程，橙色部分代表网络线程。我们在主线程中调用RequestQueue的add()方法来添加一条网络请求，这条请求会先被加入到缓存队列当中，如果发现可以找到相应的缓存结果就直接读取缓存并解析，然后回调给主线程。如果在缓存中没有找到结果，则将这条请求加入到网络请求队列中，然后处理发送HTTP请求，解析响应结果，写入缓存，并回调主线程。接下来还有ym—— Android网络框架Volley(实战篇)